Class CandyMachineClient

You may use the guards() client to access the default guards available as well as register your own guards.

const guardsClient = metaplex.candyMachines().guards();

You may use the builders() client to access the underlying Transaction Builders of this module.

const buildersClient = metaplex.candyMachines().builders();

You may use the pdas() client to build PDAs related to this module.

const pdasClient = metaplex.candyMachines().pdas();

Calls the special "route" instruction on a specific guard.

This allows guards to provide additional features such as creating PDAs that verify a payer before the mint instruction is executed or freezing and thawing minted NFTs.

The "route" instruction must select a specific guard on a specific group (if groups are enabled) since it is possible for the same type of guard to have different settings based on its group.

Additionally, it is possible for a guard to support multiple "paths" within their "route" instruction. The route settings of the guard will usually use the path property to distinguish them.

const { nft } = await metaplex
  .candyMachines()
  .callGuardRoute({
    candyMachine,
    guard: 'allowList',
    settings: {
      path: 'proof',
      merkleProof: getMerkleProof(data, leaf)
    },
  };

Creates a brand new Candy Machine with the provided settings.

Unless the withoutCandyGuard option is set to true, a Candy Guard will be created with the given guards and immediately linked to the Candy Machine.

 const { candyMachine } = await metaplex
   .candyMachines()
   .create({
     itemsAvailable: toBigNumber(5000),
     sellerFeeBasisPoints: 333, // 3.33%
     collection: {
       address: collectionNft.address,
       updateAuthority: collectionUpdateAuthority,
     },
   });

Creates a new Candy Guard account with the provided settings.

const { candyGuard } = await metaplex
  .candyMachines()
  .createCandyGuard({
    guards: {
      startDate: { date: toDateTime('2022-09-05T20:00:00.000Z') },
      solPayment: { amount: sol(1.5), },
      botTax: { lamports: sol(0.01), lastInstruction: true },
    },
  };

Deletes a Candy Machine account by withdrawing its rent-exempt balance.

await metaplex
  .candyMachines()
  .delete({
    candyMachine: candyMachine.address,
    candyGuard: candyMachine.candyGuard.address,
    authority,
  };

Deletes a Candy Guard account by withdrawing its rent-exempt balance.

await metaplex
  .candyMachines()
  .deleteCandyGuard({
    candyGuard,
    authority,
  };

Find all Candy Guards matching by a given authority.

const candyGuards = await metaplex
  .candyMachines()
  .findAllCandyGuardsByAuthority({ authority: new PublicKey('...') });

Find an existing Candy Machine by its address.

const candyMachine = await metaplex
  .candyMachines()
  .findbyAddress({ address };

Find an existing Candy Guard by its address.

const candyGuard = await metaplex
  .candyMachines()
  .findCandyGuardbyAddress({ address };

Helper method that fetches a Candy Guard via the base address used to derived its PDA.

const candyGuard = await metaplex
  .candyMachines()
  .findCandyGuardByBaseAddress({ address: base });

Insert items into an existing Candy Machine.

Note that the name and URI of each item should not include the prefixes configured in the config line settings.

await metaplex
  .candyMachines()
  .insertItems({
    candyMachine,
    items: [
      { name: 'My NFT #1', uri: 'https://example.com/nft1' },
      { name: 'My NFT #2', uri: 'https://example.com/nft2' },
      { name: 'My NFT #3', uri: 'https://example.com/nft3' },
    ],
  };

Mints the next NFT from a given candy machine.

const { nft } = await metaplex
  .candyMachines()
  .mint({
    candyMachine,
    collectionUpdateAuthority,
  };

Helper method that refetches a given Candy Machine or Candy Guard.

const candyMachine = await metaplex.candyMachines().refresh(candyMachine);
const candyGuard = await metaplex.candyMachines().refresh(candyGuard);

Unwraps the given Candy Machine from its Candy Guard.

This makes the Candy Machine authority its own mint authority again

await metaplex
  .candyMachines()
  .unwrapCandyGuard({
    candyMachine,
    candyGuard,
  };

Updates the every aspect of an existing Candy Machine, including its authorities, collection and guards (when associated with a Candy Guard).

await metaplex
  .candyMachines()
  .update({
    candyMachine,
    sellerFeeBasisPoints: 500,
  };

Updates an existing Candy Guard account.

Note that the provided guards and groups will replace the existing ones.

await metaplex
  .candyMachines()
  .updateCandyGuard({
    candyGuard: candyGuard.address,
    guards: {
      startDate: { date: toDateTime('2022-09-05T20:00:00.000Z') },
      solPayment: { amount: sol(1.5), },
      botTax: { lamports: sol(0.01), lastInstruction: true },
    },
    groups: [],
  };

{@inheritDoc updateCandyGuardAuthorityOperation}

Wraps the given Candy Machine in a Candy Guard.

This makes the Candy Guard the mint authority for the Candy Machine which means all minting will have to go through the Candy Guard.

await metaplex
  .candyMachines()
  .wrapCandyGuard({
    candyMachine,
    candyGuard,
  };