Step 2. Token Transfer

Assets can be transferred in multiple ways:

• The first one is the easiest and does not require technical knowledge.
• The second option does not rely on the frontend or backend services (only the RPC node) and is used when all signers are loaded in the same environment.
• The third option is using safe-core-sdk libraries. It will also include a multiple-owner signature flow using only a protocol kit.

Option 1. Protofire Safe UI:

If a recreated safe is supported in Protofire Safe UI [2], it is possible to send the asset directly from the website. UI offers multiple ways to do so. The most straightforward one — selecting a token in the assets tab.

However, sometimes token data may be missing because of the transfer event and multisig creation timelines. Therefore, tokens can also be transferred using the transaction builder. For a native token, since the ABI does not exist, it is enough to pass an empty array [].

To transfer ERC20 or NFT tokens, the flow would be similar, but with the addition of the missing token contract data to the Enter Address and Enter ABI inputs:

Successful transaction examples:

• Native token transfer: 0x5285cab6a1af909190407756a40447d3788c21d1b5d0db059fea206524364b09
• ERC20 Transfer: 0xd8db855b1621df975f8b087d5b43b8abd2fe41c52f26c75941a2bfbc9cfc1b65

Option 2:

This method allows interaction with safes only via the command line (no backend service is required). Installation commands are available at the safe-cli [3] repository.

Example of an initialization command:

docker run -it safeglobal/safe-cli safe-cli 0xA4A16b02A9D7b4465cE6962C048AEcb8B40FBd72 https://rpc.ankr.com/zksync_era_sepolia

The Safe-cli repository has detailed examples and documentation (cases can be found in the Usage section). Here are some of the token transfer commands:

send-ether
send-erc20
send-erc721

The first step when using safe-cli could be pre-loading owners and only then performing agreed-upon commands.

Notes

• If signers can not be in the same environment, use tx-service (third-party backend service) as suggested in this issue (#178) or try protocol-kit (Option 3).
• ⚠️ For enhanced security, a hardware wallet option is also possible (and recommended for mainnet currency handling).

Once all owners are loaded, execute the transfer command:

send_ether 0xc085ceFdB9607030708A9D4f50922eDf9A96EF4D 883837

The result: (0x441e…72e312):

Sent tx with tx-hash 0x441e1b839648893a8fe74bdef164feccea0a2d2d11461608ce6736a4e572e312 and safe-nonce 10, waiting for receipt
Tx was executed on block-number=5172821, fees deducted=0.0000101727

It is also visible in the Protofire Safe UI!

Step 4A: Propose or execute the transaction via API-kit:

This option interacts with the transaction service [6] (a third-party or self-hosted backend service) that stores pending data in the queue.

This data can be fetched again and passed for execution via protocol-kit, or executed directly in the UI (this method is chosen).

//import SafeApiKit from '@safe-global/api-kit'

const apiKit = new SafeApiKit({
    chainId: BigInt(300),
    txServiceUrl: 'https://transaction-zksync-sepolia.safe.protofire.io/api'
});

await apiKit.proposeTransaction({
    safeAddress: SAFE_ADDRESS,
    safeTransactionData: safeTransaction.data,
    safeTxHash,
    senderAddress: OWNER_ADDRESS,
    senderSignature: signature.data
  })

After a successful proposal, users can see and execute it in the UI.

The transaction is executed successfully:

• 0x3799e2cd66e29702a8230f82ede5948cfb4ec254a4344960e50586ca33cbad16 (native token transfer example)

However, if the transaction service is missing, API-Kit can’t be used; therefore:

Step 4C: Using Protocol Kit for Multiple Owners

This method can be executed if users with multiple owners don’t want to use the frontend or the backend service and are in different execution environments.

Scenario: There are two owners of the multisignature wallet. They prefer passing data and executing the transfer in separate environments using the locally accessed library:

Owner 1 actions:

• Retrieve data from steps 1 to 3 (transfer signature and transaction data) and transform it into a string (can be encrypted).

// prepared safeTransaction and signature
// ...
const txData = {
  safeTransaction: safeTransaction.data,
  safeTxHash,
  signatures: [signature.data]
}
const serializedData = JSON.stringify(txData)
// encryption in code is skipped

• Pass the serialized/encrypted data to the next owner via secure channels.

Owner 2 actions:

• Parse (and decrypt) the serialized data:

const deserializedData = JSON.parse(serializedData)

• Repeat Step 1 for the second owner. Initialize the protocol kit with the second owner’s signer’s data:

const protocolKitOwner2 = await Safe.init({...})

• Form the transaction using the deserialized data:

const safeTransaction = await protocolKitOwner2.createTransaction({
  transactions: [deserializedData.safeTransaction]
})

• Add previous owner(s) signatures:

deserializedData.signatures.forEach(sig : SafeSignature => {
  safeTransaction.addSignature(sig)
})

• Sign with the last required signature:

const safeTxHash = await protocolKitOwner2.getTransactionHash(safeTransaction)
const signature = await protocolKitOwner2.signHash(safeTxHash)
safeTransaction.addSignature(signature)

• Check if the transaction is valid and try to execute it:

const isValid = await protocolKitOwner2.isValidTransaction(safeTransaction)

if(isValid){
  const executedTx = await protocolKitOwner2.executeTransaction(safeTransaction)
  // await receipt using viem/ other libraries by passing executedTx.hash
}

Executed! Transaction hash:

• 0x110c5e7f53f1e3f606921a4da65d63732005adaf8011da58a4e91573dca7774d

Transaction data can also be viewed in the UI if the network is supported:

The Second Part is Done!

By now, you should have retrieved funds using the most preferred option. And, as stated in the previous part, this approach works for most of the EVM-based networks, not only zkSync!

If you plan to securely store your funds in a multi-signature wallet and are not sure if the EVM network is supported, check out more about Protofire solutions! As an official Safe partner and Safe Guardian, Protofire ensures your treasury, protocol, or DAO is protected by infrastructure trusted by industry leaders.

• Explore the list of 100+ Safe deployments: https://safe.protofire.io/safes/
• Read more about safes and their extension/solutions: https://safe.protofire.io/

References

1. EVM Safe in zkSync. Part I: Recreate Multisigs with EVM Interpreter — https://medium.com/protofire-blog/evm-safe-in-zksync-part-i-recreate-multisigs-with-evm-interpreter-fe0b9dc84ce2
2. Protofire Safe UI — https://app.safe.protofire.io/
3. Safe Cli — https://github.com/safe-global/safe-cli
4. Safe Core SDK — https://github.com/safe-global/safe-core-sdk
5. How to perform basic transactions checks on Safe{Wallet} https://help.safe.global/en/articles/276343-how-to-perform-basic-transactions-checks-on-safe-wallet
6. Safe Transaction Service — https://github.com/safe-global/safe-transaction-service