Skip to main content

Claim / Claim Conditions

Functionality available for contracts that implement the IDropSinglePhase or IDropSinglePhase_V1 interfaces.

Enables wallets to claim (mint) tokens from the contract under specific conditions.

claim​

Claim a specified number of tokens to the connected wallet.

const txResult = await contract.erc20.claim("{{amount}}");
Configuration

amount (required)​

The amount of tokens to claim.

Must be a string or number.

options (optional)​

Customizable ClaimOptions object that can be used to override the default behaviour of the claim.

There are three options available:

  • checkERC20Allowance - Whether to check the ERC20 allowance of the sender, defaults to true.
  • currencyAddress - The currency to pay for each token claimed, defaults to NATIVE_TOKEN_ADDRESS for native currency.
  • pricePerToken - The price to pay for each token claimed. Not relevant when using claim conditions.
const txResult = await contract.erc20.claim("{{amount}}", {
  checkERC20Allowance: false, // Set to true if you want to check ERC20 allowance
  currencyAddress: "{{currency_contract_address}}",
  pricePerToken: "{{price}}",
});

claimTo​

The same as claim, but allows specifying the recipient address rather than using the connected wallet.

const txResult = await contract.erc20.claimTo("{{recipient}}", "{{amount}}");
Configuration

recipient (required)​

The wallet address to receive the claimed tokens.

Must be a string.

amount (required)​

The amount of tokens to claim.

Must be a string or number.

options (optional)​

Customizable ClaimOptions object that can be used to override the default behaviour of the claim.

See claim for more details.

canClaim​

Check if tokens are currently available for claiming, optionally specifying if a specific wallet address can claim.

const canClaim = await contract.erc20.claimConditions.canClaim("{{quantity}}");
Configuration

quantity (required)​

The amount of tokens to claim.

This checks to see if the specified amount of tokens are available for claiming. i.e.:

  • There is sufficient quantity available for claiming.
  • This amount of tokens can be claimed in a single transaction.

Must be a string or number.

addressToCheck (optional)​

The wallet address to check if it can claim tokens.

This considers all aspects of the active claim phase, including allowlists, previous claims, etc.

Must be a string.

Return Value​

Returns a boolean indicating if the specified amount of tokens can be claimed or not.

boolean;

getActive​

Retrieve the currently active claim phase, if any.

const activePhase = await contract.erc20.claimConditions.getActive();
Configuration

options (optional)​

Provide an object containing a withAllowlist property to include the allowlist in the response.

By default, the method will not include the allowlist in the returned data.

To include the allowlist in the returned data, set the withAllowlist option to true.

This will add a snapshot property to the returned data, which contains the allowlist in an array.

const activePhase = contract?.erc20.getActive(
  {
    withAllowlist: true,
  },
);

Return Value​

If there is no active claim phase, returns undefined.

If a claim condition is active, returns a ClaimCondition object containing the following properties:

{
  maxClaimableSupply: string;
  startTime: Date;
  price: BigNumber;
  currencyAddress: string;
  maxClaimablePerWallet: string;
  waitInSeconds: BigNumber;
  merkleRootHash: string | number[];
  availableSupply: string;
  currentMintSupply: string;
  currencyMetadata: {
      symbol: string;
      value: BigNumber;
      name: string;
      decimals: number;
      displayValue: string;
  };
  metadata?: {
      [x: string]: unknown;
      name?: string | undefined;
  } | undefined;
  snapshot?: {
      price?: string | undefined;
      currencyAddress?: string | undefined;
      address: string;
      maxClaimable: string;
  }[] | null | undefined;
}

getAll​

Get all the claim phases configured on the drop contract.

const claimPhases = await contract.erc20.claimConditions.getAll();
Configuration

options (optional)​

Optionally return the allowlist with each claim phase.

See getActive configuration for more details.

Return Value​

Returns an array of ClaimCondition objects.

{
  maxClaimableSupply: string;
  startTime: Date;
  price: BigNumber;
  currencyAddress: string;
  maxClaimablePerWallet: string;
  waitInSeconds: BigNumber;
  merkleRootHash: string | number[];
  availableSupply: string;
  currentMintSupply: string;
  currencyMetadata: {
      symbol: string;
      value: BigNumber;
      name: string;
      decimals: number;
      displayValue: string;
  };
  metadata?: {
      [x: string]: unknown;
      name?: string | undefined;
  } | undefined;
  snapshot?: {
      price?: string | undefined;
      currencyAddress?: string | undefined;
      address: string;
      maxClaimable: string;
  }[] | null | undefined;
}[]

getClaimIneligibilityReasons​

Get an array of reasons why a specific wallet address is not eligible to claim tokens, if any.

const reasons = await contract.erc20.getClaimIneligibilityReasons(
  "{{quantity}}", // Quantity of tokens to claim
  "{{wallet_address}}", // Wallet address to check
);
Configuration

quantity (required)​

The amount of tokens to check if the wallet address can claim.

Must be a string or number.

addressToCheck (optional)​

The wallet address to check if it can claim tokens.

Must be a string.

Return Value​

Returns an array of ClaimEligibility strings, which may be empty.

For example, if the user is not in the allowlist, this hook will return ["This address is not on the allowlist."].

If the user is eligible to claim tokens, the hook will return an empty array.

ClaimEligibility[]

// ClaimEligibility Enum
export enum ClaimEligibility {
  NotEnoughSupply = "There is not enough supply to claim.",
  AddressNotAllowed = "This address is not on the allowlist.",
  WaitBeforeNextClaimTransaction = "Not enough time since last claim transaction. Please wait.",
  AlreadyClaimed = "You have already claimed the token.",
  NotEnoughTokens = "There are not enough tokens in the wallet to pay for the claim.",
  NoActiveClaimPhase = "There is no active claim phase at the moment. Please check back in later.",
  NoClaimConditionSet = "There is no claim condition set.",
  NoWallet = "No wallet connected.",
  Unknown = "No claim conditions found.",
}

getClaimTransaction​

Construct a claim transaction without executing it. This is useful for estimating the gas cost of a claim transaction, overriding transaction options and having fine grained control over the transaction execution.

const claimTransaction =
  await contract.erc20.claimConditions.getClaimTransaction(
    "{{wallet_address}}",
    "{{quantity}}",
  );
Configuration

walletAddress (required)​

The wallet address to claim tokens for.

Must be a string.

quantity (required)​

The amount of tokens to claim.

Must be a string, number or BigNumber.

options (optional)​

See claim configuration for more details.

Return Value​

TransactionTask;

getClaimerProofs​

Returns allowlist information and merkle proofs for a given wallet address. Returns null if no proof is found for the given wallet address.

const claimerProofs = await contract.erc20.claimConditions.getClaimerProofs(
  "{{wallet_address}}",
);
Configuration

walletAddress (required)​

The wallet address to get the merkle proofs for.

Must be a string.

Return Value​

{
    price?: string | undefined;
    currencyAddress?: string | undefined;
    address: string;
    proof: string[];
    maxClaimable: string;
} | null | undefined

set​

Overwrite the claim phases on the drop contract.

const txResult = await contract.erc20.claimConditions.set([
  {
    metadata: {
      name: "Phase 1", // The name of the phase
    },
    currencyAddress: "0x...", // The address of the currency you want users to pay in
    price: 1, // The price of the token in the currency specified above
    maxClaimablePerWallet: 1, // The maximum number of tokens a wallet can claim
    maxClaimableSupply: 100, // The total number of tokens that can be claimed in this phase
    startTime: new Date(), // When the phase starts (i.e. when users can start claiming tokens)
    waitInSeconds: 60 * 60 * 24 * 7, // The period of time users must wait between repeat claims
    snapshot: [
      {
        address: "0x...", // The address of the wallet
        currencyAddress: "0x...", // Override the currency address this wallet pays in
        maxClaimable: 5, // Override the maximum number of tokens this wallet can claim
        price: 0.5, // Override the price this wallet pays
      },
    ],
    merkleRootHash: "0x...", // The merkle root hash of the snapshot
  },
]);
Configuration

price​

The price per token in the currency specified above.

The default value is 0.

maxClaimablePerWallet​

The maximum number of tokens a wallet can claim.

The default value is unlimited.

maxClaimableSupply​

The total number of tokens that can be claimed in this phase.

For example, if you lazy mint 1000 tokens and set the maxClaimableSupply to 100, then only 100 tokens will be claimable in this phase, leaving 900 tokens to be claimed in the next phases (if you have any).

This is useful for "early bird" use cases, where you allow users to claim a limited number of tokens at a discounted price during the first X amount of time.

startTime​

When the phase starts (i.e. when users can start claiming tokens).

The default value is immediately.

waitInSeconds​

The amount of time between claims a wallet must wait before they can claim again.

The default value is 0, meaning users can claim again immediately after claiming.

snapshot​

A list of wallets that you want to override the default claim conditions for.

Wallet addresses within this list can be set to pay in a different currency, have a different price, and have a different maximum claimable amount.

{
  address: string;
  currencyAddress?: string;
  maxClaimable?: number;
  price?: number;
}

Learn more about improved claim conditions.

merkleRootHash​

If you want to provide your own merkle tree for your snapshot, provide the merkle root hash here.

This is only recommended for advanced use cases.

update​

Update a single claim phase on the drop contract, by providing the index of that phase and the new phase configuration.

The index is the position of the phase in the list of phases you have made, starting from zero. e.g. if you have two phases, the first phase has an index of 0 and the second phase has an index of 1.

const txResult = await contract.erc20.claimConditions.update(
  0, // The index of the phase to update
  {
    metadata: {
      name: "Phase 1", // The name of the phase
    },
    currencyAddress: "0x...", // The address of the currency you want users to pay in
    price: 1, // The price of the token in the currency specified above
    maxClaimablePerWallet: 1, // The maximum number of tokens a wallet can claim
    maxClaimableSupply: 100, // The total number of tokens that can be claimed in this phase
    startTime: new Date(), // When the phase starts (i.e. when users can start claiming tokens)
    waitInSeconds: 60 * 60 * 24 * 7, // The period of time users must wait between repeat claims
    snapshot: [
      {
        address: "0x...", // The address of the wallet
        currencyAddress: "0x...", // Override the currency address this wallet pays in
        maxClaimable: 5, // Override the maximum number of tokens this wallet can claim
        price: 0.5, // Override the price this wallet pays
      },
    ],
    merkleRootHash: "0x...", // The merkle root hash of the snapshot
  },
);
Configuration

See set configuration for more details.