Skip to main content

ERC20SignatureMintable

Functionality available for contracts that implement the IERC20 and ISignatureMintERC20 interfaces.

Allows you to utilize signature-based minting of new tokens.

generate​

Generate a signature that a wallet address can use to mint the specified number of tokens.

This is typically an admin operation, where the owner of the contract generates a signature that allows another wallet to mint tokens.

const payload = {
  quantity: 100, // (Required) The quantity of tokens to be minted
  to: "{{wallet_address}}", // (Required) Who will receive the tokens
  currencyAddress: "{{currency_contract_address}}", // (Optional) the currency to pay with
  price: 0.5, // (Optional) the price to pay for minting those tokens (in the currency above)
  mintStartTime: new Date(), // (Optional) can mint anytime from now
  mintEndTime: new Date(Date.now() + 60 * 60 * 24 * 1000), // (Optional) to 24h from now,
  primarySaleRecipient: "0x...", // (Optional) custom sale recipient for this token mint
};

const signature = await contract.erc20.signature.generate(payload);
Configuration

The mintRequest object you provide to the generate function outlines what the signature can be used for.

The quantity and to fields are required, while the rest are optional.

quantity (required)​

The number of tokens this signature can be used to mint.

const signature = await contract.erc20.signature.generate({
  quantity: "{{quantity}}",
  to: "{{wallet_address}}",
});

to (required)​

The wallet address that can use this signature to mint tokens.

This is to prevent another wallet from intercepting the signature and using it to mint tokens for themselves.

const signature = await contract.erc20.signature.generate({
  quantity: "{{quantity}}",
  to: "{{wallet_address}}",
});

uid (optional)​

A unique identifier for the payload, used to prevent replay attacks and other types of exploits. Note that the input value gets hashed in the actual payload that gets generated.

The smart contract enforces on-chain that no uid gets used more than once, which means you can deterministically generate the uid to prevent specific exploits.

For example, below we use the uid field to ensure that the user can request multiple payloads and send them to the blockchain all at once:

const balance = await contract.balance();
const signature = await contract.erc20.signature.generate({
  quantity: "{{quantity}}",
  to: "{{wallet_address}}",
  uid: `${walletAddress}-${balance}`,
});

currencyAddress (optional)​

The address of the currency to pay for minting the tokens (use the price field to specify the price).

Defaults to NATIVE_TOKEN_ADDRESS (the native currency of the network, e.g. Ether on Ethereum).

const signature = await contract.erc20.signature.generate({
  quantity: "{{quantity}}",
  to: "{{wallet_address}}",
  currencyAddress: "{{currency_contract_address}}",
});

price (optional)​

If you want the user to pay for minting the tokens, you can specify the price per token.

Defaults to 0 (free minting).

const signature = await contract.erc20.signature.generate({
  quantity: "{{quantity}}",
  to: "{{wallet_address}}",
  price: "{{price}}", // The user will have to pay `price * quantity` for minting the tokens
});

mintStartTime (optional)​

The time from which the signature can be used to mint tokens.

Defaults to Date.now() (now).

const signature = await contract.erc20.signature.generate({
  quantity: "{{quantity}}",
  to: "{{wallet_address}}",
  mintStartTime: new Date(), // The user can mint the tokens from this time
});

mintEndTime (optional)​

The time until which the signature can be used to mint tokens.

Defaults to new Date(Date.now() + 1000 * 60 * 60 * 24 * 365 * 10), (10 years from now).

const signature = await contract.erc20.signature.generate({
  quantity: "{{quantity}}",
  to: "{{wallet_address}}",
  mintEndTime: new Date(Date.now() + 60 * 60 * 24 * 1000), // The user can mint the tokens until this time
});

primarySaleRecipient (optional)​

If a price is specified, the funds will be sent to the primarySaleRecipient address.

Defaults to the primarySaleRecipient address of the contract.

const signature = await contract.erc20.signature.generate({
  quantity: "{{quantity}}",
  to: "{{wallet_address}}",
  price: "{{price}}",
  primarySaleRecipient: "{{wallet_address}}", // The funds will be sent to this address
});

generateBatch​

Generate multiple signatures at once (see generate).

const txResult = await contract.erc20.signature.generateBatch([
  {
    quantity: 100, // (Required) The quantity of tokens to be minted
    to: "{{wallet_address}}", // (Required) Who will receive the tokens
    currencyAddress: "{{currency_contract_address}}", // (Optional) the currency to pay with
    price: 0.5, // (Optional) the price to pay for minting those tokens (in the currency above)
    mintStartTime: new Date(), // (Optional) can mint anytime from now
    mintEndTime: new Date(Date.now() + 60 * 60 * 24 * 1000), // (Optional) to 24h from now,
    primarySaleRecipient: "0x...", // (Optional) custom sale recipient for this token mint
  },
  {
    quantity: 100, // (Required) The quantity of tokens to be minted
    to: "{{wallet_address}}", // (Required) Who will receive the tokens
    currencyAddress: "{{currency_contract_address}}", // (Optional) the currency to pay with
    price: 0.5, // (Optional) the price to pay for minting those tokens (in the currency above)
    mintStartTime: new Date(), // (Optional) can mint anytime from now
    mintEndTime: new Date(Date.now() + 60 * 60 * 24 * 1000), // (Optional) to 24h from now,
    primarySaleRecipient: "0x...", // (Optional) custom sale recipient for this token mint
  },
]);
Configuration

signatures​

An array of signatures to generate. See generate for details.

mint​

Mint tokens from a previously generated signature (see generate).

// Use the signed payload to mint the tokens
const txResult = contract.erc20.signature.mint(signature);
Configuration

signature (required)​

The signature created by the generate function.

The typical pattern is the admin generates a signature, and the user uses it to mint the tokens, under the conditions specified in the signature.

Must be of type SignedPayload20

// Use the signed payload to mint the tokens
const txResult = contract.erc20.signature.mint(
  signature, // Signature generated by the `generate` function
);

mintBatch​

Use multiple signatures at once to mint tokens.

Each signature must be of type SignedPayload20.

const txResult = await contract.erc20.signature.mintBatch([
  signature1, // Signature generated by the `generate` or `generateBatch` function
  signature2,
  signature3,
]);
Configuration

signatures​

An array of signatures to mint. Each signature must be of type SignedPayload20.

See mint for details.

verify​

Verify that a payload is correctly signed.

This allows you to provide a payload, and prove that it was valid and was generated by a wallet with permission to generate signatures.

If a payload is not valid, the mint/mintBatch functions will fail (even without this verification check), but you can use this function to verify that the payload is valid before attempting to mint the tokens if you want to show a more user-friendly error message.

const isValid = await contract.erc20.signature.verify(
  signature, // A previously generated signature
);
Configuration

signature​

The signature to verify.

Must be of type SignedPayload20

See generate for details.