References
ContractDeployer

ContractDeployer

Handles deploying new contracts


class ContractDeployer extends RPCConnectionHandler {}

Defined in


function constructor(
  network: NetworkInput,
  options:
    | undefined
    | {
        clientId?: string;
        gasSettings?: {
          maxPriceInGwei?: number;
          speed?: "standard" | "fast" | "fastest";
        };
        gasless?:
          | {
              experimentalChainlessSupport?: boolean;
              openzeppelin: {
                domainName?: string;
                domainSeparatorVersion?: string;
                domainVersion?: string;
                relayerForwarderAddress?: string;
                relayerUrl: string;
                useEOAForwarder?: boolean;
              };
            }
          | {
              biconomy: {
                apiId: string;
                apiKey: string;
                deadlineSeconds?: number;
              };
            }
          | {
              engine: {
                domainName?: string;
                domainSeparatorVersion?: string;
                domainVersion?: string;
                relayerForwarderAddress?: string;
                relayerUrl: string;
              };
              experimentalChainlessSupport?: boolean;
            };
        gatewayUrls?: Array<string>;
        readonlySettings?: { chainId?: number; rpcUrl: string };
        rpcBatchSettings?: { sizeLimit?: number; timeLimit?: number };
        secretKey?: string;
        supportedChains?: Array<{
          chainId: number;
          nativeCurrency: {
            decimals: number;
            name: string;
            symbol: string;
          };
          rpc: Array<string>;
          slug: string;
        }>;
      },
  storage: ThirdwebStorage<IpfsUploadBatchOptions>,
): ContractDeployer;

Parameters

Type


let network: NetworkInput;

Type


let options:
  | undefined
  | {
      clientId?: string;
      gasSettings?: {
        maxPriceInGwei?: number;
        speed?: "standard" | "fast" | "fastest";
      };
      gasless?:
        | {
            experimentalChainlessSupport?: boolean;
            openzeppelin: {
              domainName?: string;
              domainSeparatorVersion?: string;
              domainVersion?: string;
              relayerForwarderAddress?: string;
              relayerUrl: string;
              useEOAForwarder?: boolean;
            };
          }
        | {
            biconomy: {
              apiId: string;
              apiKey: string;
              deadlineSeconds?: number;
            };
          }
        | {
            engine: {
              domainName?: string;
              domainSeparatorVersion?: string;
              domainVersion?: string;
              relayerForwarderAddress?: string;
              relayerUrl: string;
            };
            experimentalChainlessSupport?: boolean;
          };
      gatewayUrls?: Array<string>;
      readonlySettings?: { chainId?: number; rpcUrl: string };
      rpcBatchSettings?: { sizeLimit?: number; timeLimit?: number };
      secretKey?: string;
      supportedChains?: Array<{
        chainId: number;
        nativeCurrency: {
          decimals: number;
          name: string;
          symbol: string;
        };
        rpc: Array<string>;
        slug: string;
      }>;
    };

Type


let storage: ThirdwebStorage<IpfsUploadBatchOptions>;

Returns


let returnType: ContractDeployer;

Methods

Defined in

Listen to all deploy transactions from this deployer


function addDeployListener(
  listener: (event: DeployEvent) => void,
): void;

Parameters

the listener to add

Type


let listener: (event: DeployEvent) => void;

Returns


let returnType: void;

Defined in

Deploy any published contract by its name


function deployPublishedContractDeterministic(
  contractName: string,
  constructorParams: Array<any>,
  publisherAddress: string,
  contractVersion: string,
  saltForCreate2?: string,
): Promise<string>;

Parameters

the name of the contract to deploy

Type


let contractName: string;

the constructor params to pass to the contract

Type


let constructorParams: Array<any>;

the address of the publisher

Type


let publisherAddress: string;

Type


let contractVersion: string;

Optional: salt for create2 deployment, will determine deployment address

Type


let saltForCreate2: string;

Returns


let returnType: Promise<string>;

Defined in


function getTransactionsForDeploy(
  publishMetadataUri: string,
  options?: DeployOptions,
): Promise<Array<DeploymentTransaction>>;

Parameters

the uri of the publish metadata

Type


let publishMetadataUri: string;

the deploy options

Type


let options: DeployOptions;

Returns


let returnType: Promise<Array<DeploymentTransaction>>;

Defined in

Predict Create2 address of a contract


function predictAddressDeterministic(
  contractName: string,
  constructorParams: Array<any>,
  publisherAddress: string,
  contractVersion: string,
  saltForCreate2?: string,
): Promise<string>;

Parameters

the name of the contract

Type


let contractName: string;

the constructor params to pass to the contract

Type


let constructorParams: Array<any>;

Type


let publisherAddress: string;

Type


let contractVersion: string;

Optional: salt for create2 deployment, will determine deployment address

Type


let saltForCreate2: string;

Returns


let returnType: Promise<string>;

Defined in

Remove all deploy listeners


function removeAllDeployListeners(): void;

Returns


let returnType: void;

Defined in

Remove a deploy listener


function removeDeployListener(
  listener: (event: DeployEvent) => void,
): void;

Parameters

the listener to remove

Type


let listener: (event: DeployEvent) => void;

Returns


let returnType: void;

Defined in


function deployAirdropERC1155(
  metadata: AirdropContractDeployMetadata,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let metadata: AirdropContractDeployMetadata;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

Preparable

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

Defined in


function deployAirdropERC20(
  metadata: AirdropContractDeployMetadata,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let metadata: AirdropContractDeployMetadata;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

Preparable

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

Defined in


function deployAirdropERC721(
  metadata: AirdropContractDeployMetadata,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let metadata: AirdropContractDeployMetadata;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

Preparable

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

Defined in


function deployBuiltInContract(
  contractType: any,
  contractMetadata: any,
  version: string,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let contractType: any;

Type


let contractMetadata: any;

Type


let version: string;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

A promise of the address of the newly deployed contract

Preparable

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

Defined in


function deployContractWithAbi(
  abi: ContractInterface,
  bytecode: BytesLike | { object: string },
  constructorParams: Array<any>,
): Promise<string>;

Parameters

Type


let abi: ContractInterface;

Type


let bytecode: BytesLike | { object: string };

Type


let constructorParams: Array<any>;

Returns


let returnType: Promise<string>;

Preparable

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

Defined in


function deployEdition(
  metadata: NFTContractDeployMetadata,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let metadata: NFTContractDeployMetadata;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

The address of the deployed contract

Preparable

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

Defined in


function deployEditionDrop(
  metadata: NFTContractDeployMetadata,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let metadata: NFTContractDeployMetadata;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

The address of the deployed contract

Preparable

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

Defined in


function deployLoyaltyCard(
  metadata: NFTContractDeployMetadata,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let metadata: NFTContractDeployMetadata;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

The address of the deployed contract

Preparable

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

Defined in


function deployMarketplace(
  metadata: MarketplaceContractDeployMetadata,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let metadata: MarketplaceContractDeployMetadata;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

The address of the deployed contract

Preparable

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

Defined in


function deployMarketplaceV3(
  metadata: MarketplaceV3ContractDeployMetadata,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let metadata: MarketplaceV3ContractDeployMetadata;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

The address of the deployed contract

Preparable

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

Defined in


function deployMultiwrap(
  metadata: MultiwrapContractDeployMetadata,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let metadata: MultiwrapContractDeployMetadata;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

Preparable

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

Defined in


function deployNFTCollection(
  metadata: NFTContractDeployMetadata,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let metadata: NFTContractDeployMetadata;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

The address of the deployed contract

Preparable

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

Defined in


function deployNFTDrop(
  metadata: NFTContractDeployMetadata,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let metadata: NFTContractDeployMetadata;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

The address of the deployed contract

Preparable

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

Defined in


function deployOpenEdition(
  metadata: OpenEditionContractDeployMetadata,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let metadata: OpenEditionContractDeployMetadata;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

The address of the deployed contract

Preparable

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

Defined in


function deployPack(
  metadata: NFTContractDeployMetadata,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let metadata: NFTContractDeployMetadata;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

The address of the deployed contract

Preparable

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

Defined in


function deployProxy(
  implementationAddress: string,
  implementationAbi: ContractInterface,
  initializerFunction: string,
  initializerArgs: Array<any>,
): Promise<string>;

Parameters

Type


let implementationAddress: string;

Type


let implementationAbi: ContractInterface;

Type


let initializerFunction: string;

Type


let initializerArgs: Array<any>;

Returns


let returnType: Promise<string>;

Preparable

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

Defined in


function deployPublishedContract(
  publisherAddress: string,
  contractName: string,
  constructorParams: Array<any>,
  version: any,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let publisherAddress: string;

Type


let contractName: string;

Type


let constructorParams: Array<any>;

Type


let version: any;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

Preparable

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

Defined in


function deploySignatureDrop(
  metadata: NFTContractDeployMetadata,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let metadata: NFTContractDeployMetadata;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

The address of the deployed contract

Preparable

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

Defined in


function deploySplit(
  metadata: SplitContractDeployMetadata,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let metadata: SplitContractDeployMetadata;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

The address of the deployed contract

Preparable

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

Defined in


function deployToken(
  metadata: TokenContractDeployMetadata,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let metadata: TokenContractDeployMetadata;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

The address of the deployed contract

Preparable

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

Defined in


function deployTokenDrop(
  metadata: TokenContractDeployMetadata,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let metadata: TokenContractDeployMetadata;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

The address of the deployed contract

Preparable

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

Defined in


function deployViaFactory(
  factoryAddress: string,
  implementationAddress: string,
  implementationAbi: ContractInterface,
  initializerFunction: string,
  initializerArgs: Array<any>,
  saltForProxyDeploy: string,
): Promise<TResult>;

Parameters

Type


let factoryAddress: string;

Type


let implementationAddress: string;

Type


let implementationAbi: ContractInterface;

Type


let initializerFunction: string;

Type


let initializerArgs: Array<any>;

Type


let saltForProxyDeploy: string;

Returns


let returnType: Promise<TResult>;

Preparable

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

Defined in


function deployVote(
  metadata: VoteContractDeployMetadata,
  options: DeployOptions,
): Promise<string>;

Parameters

Type


let metadata: VoteContractDeployMetadata;

Type


let options: DeployOptions;

Returns


let returnType: Promise<string>;

The address of the deployed contract

Preparable

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

Inherited Methods

Inherited from RPCConnectionHandler.addListener


function addListener(
  event: T,
  fn: (...args: Array<any>) => void,
  context?: any,
): this;

Parameters

Type


let event: T;

Type


let fn: (...args: Array<any>) => void;

Type


let context: any;

Returns


let returnType: this;

Inherited from RPCConnectionHandler.emit

Calls each of the listeners registered for a given event.


function emit(event: T, ...args: Array<any>): boolean;

Parameters

Type


let event: T;

Type


let args: Array<any>;

Returns


let returnType: boolean;

Inherited from RPCConnectionHandler.eventNames

Return an array listing the events for which the emitter has registered listeners.


function eventNames(): Array<string | symbol>;

Returns


let returnType: Array<string | symbol>;

Defined in

Inherited from RPCConnectionHandler.getProvider

Explicitly get the active provider.


function getProvider(): Provider;

Returns


let returnType: Provider;

The active provider

Defined in

Inherited from RPCConnectionHandler.getSigner

Explicitly get the active signer.


function getSigner(): undefined | Signer;

Returns


let returnType: undefined | Signer;

The active signer, if there is one

Defined in

Inherited from RPCConnectionHandler.getSignerOrProvider


function getSignerOrProvider(): Signer | Provider;

Returns


let returnType: Signer | Provider;

The current signer if there is one, otherwise the active provider

Defined in

Inherited from RPCConnectionHandler.isReadOnly


function isReadOnly(): boolean;

Returns


let returnType: boolean;

whether or not a signer is set, true if there is no signer so the class is in "read only" mode

Inherited from RPCConnectionHandler.listenerCount

Return the number of listeners listening to a given event.


function listenerCount(event: string | symbol): number;

Parameters

Type


let event: string | symbol;

Returns


let returnType: number;

Inherited from RPCConnectionHandler.listeners

Return the listeners registered for a given event.


function listeners(event: T): Array<(...args: Array<any>) => void>;

Parameters

Type


let event: T;

Returns


let returnType: Array<(...args: Array<any>) => void>;

Inherited from RPCConnectionHandler.off


function off(
  event: T,
  fn?: (...args: Array<any>) => void,
  context?: any,
  once?: boolean,
): this;

Parameters

Type


let event: T;

Type


let fn: (...args: Array<any>) => void;

Type


let context: any;

Type


let once: boolean;

Returns


let returnType: this;

Inherited from RPCConnectionHandler.on

Add a listener for a given event.


function on(
  event: T,
  fn: (...args: Array<any>) => void,
  context?: any,
): this;

Parameters

Type


let event: T;

Type


let fn: (...args: Array<any>) => void;

Type


let context: any;

Returns


let returnType: this;

Inherited from RPCConnectionHandler.once

Add a one-time listener for a given event.


function once(
  event: T,
  fn: (...args: Array<any>) => void,
  context?: any,
): this;

Parameters

Type


let event: T;

Type


let fn: (...args: Array<any>) => void;

Type


let context: any;

Returns


let returnType: this;

Inherited from RPCConnectionHandler.removeAllListeners

Remove all listeners, or those of the specified event.


function removeAllListeners(event?: string | symbol): this;

Parameters

Type


let event: string | symbol;

Returns


let returnType: this;

Inherited from RPCConnectionHandler.removeListener

Remove the listeners of a given event.


function removeListener(
  event: T,
  fn?: (...args: Array<any>) => void,
  context?: any,
  once?: boolean,
): this;

Parameters

Type


let event: T;

Type


let fn: (...args: Array<any>) => void;

Type


let context: any;

Type


let once: boolean;

Returns


let returnType: this;

Properties

Defined in


let network: NetworkInput;

Defined in


let options: {
  clientId?: string;
  gasSettings: {
    maxPriceInGwei: number;
    speed: "standard" | "fast" | "fastest";
  };
  gasless?:
    | {
        experimentalChainlessSupport: boolean;
        openzeppelin: {
          domainName: string;
          domainSeparatorVersion: string;
          domainVersion: string;
          relayerForwarderAddress?: string;
          relayerUrl: string;
          useEOAForwarder: boolean;
        };
      }
    | {
        biconomy: {
          apiId: string;
          apiKey: string;
          deadlineSeconds: number;
        };
      }
    | {
        engine: {
          domainName: string;
          domainSeparatorVersion: string;
          domainVersion: string;
          relayerForwarderAddress?: string;
          relayerUrl: string;
        };
        experimentalChainlessSupport: boolean;
      };
  gatewayUrls?: Array<string>;
  readonlySettings?: { chainId?: number; rpcUrl: string };
  rpcBatchSettings?: { sizeLimit: number; timeLimit: number };
  secretKey?: string;
  supportedChains: Array<{
    chainId: number;
    nativeCurrency: {
      decimals: number;
      name: string;
      symbol: string;
    };
    rpc: Array<string>;
    slug: string;
  }>;
};


type clientId = string;


type gasSettings = {
  maxPriceInGwei: number;
  speed: "standard" | "fast" | "fastest";
};


type gasless =
  | {
      experimentalChainlessSupport: boolean;
      openzeppelin: {
        domainName: string;
        domainSeparatorVersion: string;
        domainVersion: string;
        relayerForwarderAddress?: string;
        relayerUrl: string;
        useEOAForwarder: boolean;
      };
    }
  | {
      biconomy: {
        apiId: string;
        apiKey: string;
        deadlineSeconds: number;
      };
    }
  | {
      engine: {
        domainName: string;
        domainSeparatorVersion: string;
        domainVersion: string;
        relayerForwarderAddress?: string;
        relayerUrl: string;
      };
      experimentalChainlessSupport: boolean;
    };


type gatewayUrls = Array<string>;


type readonlySettings = { chainId?: number; rpcUrl: string };


type rpcBatchSettings = { sizeLimit: number; timeLimit: number };


type secretKey = string;


type supportedChains = Array<{
  chainId: number;
  nativeCurrency: { decimals: number; name: string; symbol: string };
  rpc: Array<string>;
  slug: string;
}>;


let prefixed: string | boolean;

Was this page helpful?

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

Subscribe for the latest dev updates

ContractDeployer

Signature

Constructor

Signature

Parameters

network

Type

options

Type

storage

Type

Returns

Return Type

Methods

addDeployListener

Signature

Parameters

listener

Type

Returns

Return Type

deployPublishedContractDeterministic

Signature

Parameters

contractName

Type

constructorParams

Type

publisherAddress

Type

contractVersion

Type

saltForCreate2

Type

Returns

Return Type

getTransactionsForDeploy

Signature

Parameters

publishMetadataUri

Type

options

Type

Returns

Return Type

predictAddressDeterministic

Signature

Parameters

contractName

Type

constructorParams

Type

publisherAddress

Type

contractVersion

Type

saltForCreate2

Type

Returns

Return Type

removeAllDeployListeners

Signature

Returns

Return Type

removeDeployListener

Signature

Parameters

listener

Type

Returns

Return Type

deployAirdropERC1155

Signature

Parameters

metadata

Type

options

Type

Returns

Return Type