References
Erc20

Erc20

Standard ERC20 Token functions

Basic functionality for a ERC20 contract that handles all unit transformation for you.

Example


const contract = await sdk.getContract("{{contract_address}}");
await contract.erc20.transfer(walletAddress, amount);


class Erc20<
    T extends TokenERC20 | DropERC20 | BaseERC20 =
      | BaseERC20
      | BaseSignatureMintERC20,
  >
  implements UpdateableNetwork, DetectableFeature {}

Defined in


function constructor(
  contractWrapper: ContractWrapper<T>,
  storage: ThirdwebStorage<IpfsUploadBatchOptions>,
  chainId: number,
): Erc20<T>;

Parameters

Type


let contractWrapper: ContractWrapper<T>;

Type


let storage: ThirdwebStorage<IpfsUploadBatchOptions>;

Type


let chainId: number;

Returns


let returnType: Erc20<T>;

Methods

Defined in

Get token allowance

Get the allowance of a 'spender' wallet over the connected wallet's funds - the allowance of a different address for a token is the amount of tokens that the spender wallet is allowed to spend on behalf of the connected wallet.

Example


// Address of the wallet to check token allowance
const spenderAddress = "0x...";
const allowance = await contract.erc20.allowance(spenderAddress);


function allowance(
  spender: string,
): Promise<{
  decimals: number;
  displayValue: string;
  name: string;
  symbol: string;
  value: BigNumber;
}>;

Parameters

Type


let spender: string;

Returns


let returnType: Promise<{
  decimals: number;
  displayValue: string;
  name: string;
  symbol: string;
  value: BigNumber;
}>;

The allowance of one wallet over anothers funds.

Defined in

Get token allowance of a specific wallet

Get the allowance of one wallet over another wallet's funds - the allowance of a different address for a token is the amount of tokens that the wallet is allowed to spend on behalf of the specified wallet.

Example


// Address of the wallet who owns the funds
const owner = "{{wallet_address}}";
// Address of the wallet to check token allowance
const spender = "0x...";
const allowance = await contract.erc20.allowanceOf(owner, spender);


function allowanceOf(
  owner: string,
  spender: string,
): Promise<{
  decimals: number;
  displayValue: string;
  name: string;
  symbol: string;
  value: BigNumber;
}>;

Parameters

Type


let owner: string;

Type


let spender: string;

Returns


let returnType: Promise<{
  decimals: number;
  displayValue: string;
  name: string;
  symbol: string;
  value: BigNumber;
}>;

The allowance of one wallet over anothers funds.

Defined in

Get token balance for the currently connected wallet

Get a wallets token balance.

Example


const balance = await contract.erc20.balance();


function balance(): Promise<{
  decimals: number;
  displayValue: string;
  name: string;
  symbol: string;
  value: BigNumber;
}>;

Returns


let returnType: Promise<{
  decimals: number;
  displayValue: string;
  name: string;
  symbol: string;
  value: BigNumber;
}>;

The balance of a specific wallet.

Defined in

Get token balance for a specific wallet

Get a wallets token balance.

Example


const walletAddress = "{{wallet_address}}";
const balance = await contract.erc20.balanceOf(walletAddress);


function balanceOf(
  address: string,
): Promise<{
  decimals: number;
  displayValue: string;
  name: string;
  symbol: string;
  value: BigNumber;
}>;

Parameters

Type


let address: string;

Returns


let returnType: Promise<{
  decimals: number;
  displayValue: string;
  name: string;
  symbol: string;
  value: BigNumber;
}>;

The balance of a specific wallet.

Defined in

Get the token metadata

name, symbol, etc...

Example


const token = await contract.erc20.get();


function get(): Promise<{
  decimals: number;
  name: string;
  symbol: string;
}>;

Returns


let returnType: Promise<{
  decimals: number;
  name: string;
  symbol: string;
}>;

The token metadata

Defined in

Deprecated

Use contract.erc20.mint.prepare(...args) instead

Construct a mint transaction without executing it

This is useful for estimating the gas cost of a mint transaction, overriding transaction options and having fine grained control over the transaction execution.


function getMintTransaction(
  receiver: string,
  amount: string | number,
): Promise<
  Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>
>;

Parameters

Address you want to send the token to

Type


let receiver: string;

The amount of tokens you want to mint

Type


let amount: string | number;

Returns


let returnType: Promise<
  Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>
>;

Defined in

Get the total supply for this token

Get how much supply has been minted

Example


const balance = await contract.erc20.totalSupply();


function totalSupply(): Promise<{
  decimals: number;
  displayValue: string;
  name: string;
  symbol: string;
  value: BigNumber;
}>;

Returns


let returnType: Promise<{
  decimals: number;
  displayValue: string;
  name: string;
  symbol: string;
  value: BigNumber;
}>;

Defined in


function burn(amount: string | number): Promise<TResult>;

Parameters

Type


let amount: string | number;

Returns


let returnType: Promise<TResult>;

Preparable

You can also prepare the transaction without executing it by calling burn.prepare() with same arguments. Learn more

Defined in


function burnFrom(
  holder: string,
  amount: string | number,
): Promise<TResult>;

Parameters

Type


let holder: string;

Type


let amount: string | number;

Returns


let returnType: Promise<TResult>;

Preparable

You can also prepare the transaction without executing it by calling burnFrom.prepare() with same arguments. Learn more

Defined in


function claim(
  amount: string | number,
  options: ClaimOptions,
): Promise<TResult>;

Parameters

Type


let amount: string | number;

Type


let options: ClaimOptions;

Returns


let returnType: Promise<TResult>;

The transaction receipt

Preparable

You can also prepare the transaction without executing it by calling claim.prepare() with same arguments. Learn more

Defined in


function claimTo(
  destinationAddress: string,
  amount: string | number,
  options: ClaimOptions,
): Promise<TResult>;

Parameters

Type


let destinationAddress: string;

Type


let amount: string | number;

Type


let options: ClaimOptions;

Returns


let returnType: Promise<TResult>;

The transaction receipt

Preparable

You can also prepare the transaction without executing it by calling claimTo.prepare() with same arguments. Learn more

Defined in


function mint(amount: string | number): Promise<TResult>;

Parameters

Type


let amount: string | number;

Returns


let returnType: Promise<TResult>;

Preparable

You can also prepare the transaction without executing it by calling mint.prepare() with same arguments. Learn more

Defined in


function mintBatchTo(
  args: Array<{ amount: string | number; toAddress: string }>,
): Promise<TResult>;

Parameters

Type


let args: Array<{ amount: string | number; toAddress: string }>;

Returns


let returnType: Promise<TResult>;

Preparable

You can also prepare the transaction without executing it by calling mintBatchTo.prepare() with same arguments. Learn more

Defined in


function mintTo(
  receiver: string,
  amount: string | number,
): Promise<TResult>;

Parameters

Type


let receiver: string;

Type


let amount: string | number;

Returns


let returnType: Promise<TResult>;

Preparable

You can also prepare the transaction without executing it by calling mintTo.prepare() with same arguments. Learn more

Defined in


function setAllowance(
  spender: string,
  amount: string | number,
): Promise<TResult>;

Parameters

Type


let spender: string;

Type


let amount: string | number;

Returns


let returnType: Promise<TResult>;

Preparable

You can also prepare the transaction without executing it by calling setAllowance.prepare() with same arguments. Learn more

Defined in


function transfer(
  to: string,
  amount: string | number,
): Promise<TResult>;

Parameters

Type


let to: string;

Type


let amount: string | number;

Returns


let returnType: Promise<TResult>;

Preparable

You can also prepare the transaction without executing it by calling transfer.prepare() with same arguments. Learn more

Defined in


function transferBatch(
  args: Array<{ amount: string | number; toAddress: string }>,
): Promise<TResult>;

Parameters

Type


let args: Array<{ amount: string | number; toAddress: string }>;

Returns


let returnType: Promise<TResult>;

Preparable

You can also prepare the transaction without executing it by calling transferBatch.prepare() with same arguments. Learn more

Defined in


function transferFrom(
  from: string,
  to: string,
  amount: string | number,
): Promise<TResult>;

Parameters

Type


let from: string;

Type


let to: string;

Type


let amount: string | number;

Returns


let returnType: Promise<TResult>;

Preparable

You can also prepare the transaction without executing it by calling transferFrom.prepare() with same arguments. Learn more

Properties

Defined in


let featureName: "ERC20";

Accessors

Defined in


let chainId: number;

Defined in

Configure claim conditions

Define who can claim NFTs in the collection, when and how many.


let claimConditions: DropClaimConditions<BaseDropERC20>;

Example


const presaleStartTime = new Date();
const publicSaleStartTime = new Date(Date.now() + 60 * 60 * 24 * 1000);
const claimConditions = [
  {
    startTime: presaleStartTime, // start the presale now
    maxClaimableSupply: 2, // limit how many mints for this presale
    price: 0.01, // presale price
    snapshot: ['0x...', '0x...'], // limit minting to only certain addresses
  },
  {
    startTime: publicSaleStartTime, // 24h after presale, start public sale
    price: 0.08, // public sale price
  }
]);
await contract.erc20.claimConditions.set(claimConditions);

Defined in

Mint with signature

Generate dynamic tokens with your own signature, and let others mint them using that signature.


let signature: Erc20SignatureMintable;

Example


// see how to craft a payload to sign in the `contract.erc20.signature.generate()` documentation
const signedPayload = contract.erc20.signature().generate(payload);
 
// now the payload can be used to mint tokens
const tx = contract.erc20.signature.mint(signedPayload);

Was this page helpful?

Need help?
Visit our support site
Watch our
Video Tutorials
View our
Changelog

Subscribe for the latest dev updates

Erc20

Example

Signature

Constructor

Signature

Parameters

contractWrapper

Type

storage

Type

chainId

Type

Returns

Return Type

Methods

allowance

Example

Signature

Parameters

spender

Type

Returns

Return Type

allowanceOf

Example

Signature

Parameters

owner

Type

spender

Type

Returns

Return Type

balance

Example

Signature

Returns

Return Type

balanceOf

Example

Signature

Parameters

address

Type

Returns

Return Type

get

Example

Signature

Returns

Return Type

getMintTransaction

Signature

Parameters

receiver

Type

amount

Type

Returns

Return Type

totalSupply

Example

Signature

Returns

Return Type

burn

Signature

Parameters

amount

Type

Returns

Return Type

Preparable

burnFrom

Signature

Parameters

holder

Type

amount

Type