What is a Multichain Deployment?

The Multichain Deployment feature in Fireblocks allows you to deploy the same smart contract to the same address across multiple EVM-compatible blockchain networks, all in one streamlined UI flow.

📘
Note:
This feature is currently available only for EVM chains.

This is particularly useful when:

Maintaining identical contract addresses on different networks (for example, Ethereum, Arbitrum, or Polygon) for seamless cross-chain integration.
Having your dApp, token, or protocol rely on a consistent contract address to simplify frontends, indexers, or backend services.
Reducing complexity for developers, indexers, and frontend apps by using a single contract address across all chains.
Improving user experience: Users interacting with your protocol on different chains do not have to deal with varying addresses.

Fireblocks utilizes a deterministic deployment mechanism to ensure the same address across blockchains. To perform a multichain deployment, use the Fireblocks SDK to select the chains where the contract will be deployed. As long as you have enough gas on each selected network, deployment proceeds simultaneously.

Multichain Deployment using the Fireblocks SDK

Step 1: Install dependencies & bootstrap the SDK

Add packages:
Create .env and store the public and private key of your api-user:
Initialize the client:

Step 2: Define the deployment scope

Fields:

contractId - ensure the contract template is uploaded, and you have the templateId from the template.
deployerVaultAccountId - the deployerVaultAccountId that will deploy the tokens. Ensure the vault has sufficient native gas for transaction fees. Use the Get Vault Accounts endpoint to retrieve the correct vault account ID.
targetChains - the Fireblocks asset IDs for each network you are deploying to (for example, ETH_TEST5).
feeLevel - the gas-price tier for broadcasting each deployment transaction..

Step 3: Build the CreateMultichainTokenRequest

What each block does

_logic – points the proxy to your implementation contract.
_data – packs the proxy’s initialize() call to create a name, symbol, and set roles for the ERC-20F deployment.

What deployFunctionParams represents

The deployFunctionParams represents the list of constructor/initializer arguments that Fireblocks will pass to the specific contract template you picked. For an upgradeable proxy you usually see two items (_logic and _data). For a non-upgradeable contract, you might have one, three, or zero items, depending on the template’s ABI requirements. Always adjust the entire deployFunctionParams array—the field names, types, order, and values—to match the constructor or initializer of the contract you’re deploying. For instructions on finding the initializer’s parameters, see “Highlights” in this guide.

Step 4: Submit & monitor the deployment

On Success:

Once deployment is complete, you can view your deployed contracts in the Fireblocks Console on the Tokenization page, in the Tokens and Contracts section, or use the Get Deployed Contracts endpoint. You can also track the status of each deployment in the Recent Activity tab. In this example, we deployed to Ethereum Holesky and Ethereum Sepolia. Both deployments share the same contract address, confirming a successful multichain deployment.

Deployed Contracts:

Important deployment information

Before proceeding with a multichain deployment, keep the following in mind:

You need gas for transaction fees on every selected network. Ensure the deployer wallet has enough of each base asset (for example, ETH, MATIC) on each chain to cover deployment costs. Being unable to pay transaction fees will block deployment.
Deployment is pre-validated across all chains. Fireblocks runs simulations before executing transactions. If any chain is predicted to fail, the deployment will not proceed for any chain. This guarantees consistency across your selected networks.
Transactions must be signed per chain. Even though the deployment is unified, a separate transaction must be signed for each chain. Expect multiple signing prompts during execution.
Inputs apply uniformly across all chains. Deployment parameters, such as token name, symbol, supply, and roles (this includes the minter address), are shared across all selected networks. You cannot customize them per chain. If different parameters are required per network, you need to deploy each token contract separately,and the contract address will differ.

Additional SDK capability – getDeployableAddress

You can predict the contract address before broadcasting using the getDeployableAddress endpoint. This uses the initializer and salt in issueTokenMultiChain() to compute the deterministic address that a template will deploy to. After following Steps 1-3 above, call tokenization.getDeployableAddress().

Fields

templateId - the contract template ID you will deploy.
initParams - the exact deployFunctionParams array from Step 3.
chainDescriptor - the Fireblocks asset IDs of the network you are deploying to (for example . ETH_TEST5).
salt - any arbitrary whole number that becomes part of the deterministic calculation and therefore fixes the resulting contract address.

Knowing the address ahead of time lets you pre-whitelist or publish it before the actual issueTokenMultiChain() call.