ZEN Claim CLI Tool

A command line utility for claiming existing ZEN migrated to Base. There are multiple tools included that may be used on the command line or as a node module in other Node.js applications.

Overview

Tools Included

SECURITY CONSIDERATIONS

Installation

Usage

• zenclaim-seedtool
• zenclaim-signtool
• zenclaim-verifymessage
• zenclaim-recoverpubkey
• zenclaim-claimzenaddress
• zenclaim-claimmultisigaddress
• zenclaim-deriveclaimdirectaddress
• zenclaim-claimdirect
• zenclaim-deriveclaimdirectmultisig
• zenclaim-claimdirectmultisig

Submitting a Claim For a ZEN Address

Submitting a Claim for a Multisig Address

Troubleshooting

Overview

A snapshot of all ZEN account balances was taken at a certain point in time and added to a smart contract on Base. A claim process was created to allow ZEN holders to claim their new ZEN by creating and submitting a claim. There is a UI to make simple claims. This tool supports every step of the process for more complex or bulk claims, including those involving multisig addresses.

• The general claim process is to create and sign a message containing the Base destination address with the private key of the ZEN address that contains the ZEN.
• The message and the Base destination is then sent to a contract on the Base network after verifying the message and the balance.
• The contract sends the amount found in the snapshot to the destination address on Base.

Tools Included

Tools included allow you to:

• Recover ZEN addresses and private keys from a seed phrase
• Sign a message with a private key
• Verify a signed message
• Return the public key recovered from a signed message
• Submit a claim for a standard transparent address
• Submit a claim for a multisig address

SECURITY CONSIDERATIONS

This tool requires seed phrases and private keys on both ZEN and Base networks for some of the commands. Steps should be taken to protect the secret values in all environments.

Please follow these precautions to avoid leaking sensitive information:

• Disable shell history before running the tool to prevent secrets from being recorded:
  set +o history
• Avoid running in multi-user environments where other users can access the system process list. Command-line arguments, which may contain secrets, could be visible to other users.

Additional security best practices are beyond the scope of this guide.

Installation

Prerequisites: Node.js version 20 or higher installed.

To install the package, clone the repository from github.

git clone https://github.com/HorizenOfficial/horizen-migration-cli.git
git checkout 1.0.0-HBETACLAIM

In the horizen-migration-cli folder created, install the node modules.

npm install

To test the installation, in the installation folder run.

npx zenclaim-signtool --help

Usage

For ease of use, references have been created that point to the individual main files. These files support running as both command line (bash) or importing as a module. The mapping may be found in the package.json file.

zenclaim-seedtool

Derive ZEN addresses and keys from a seed phrase. Most seed phrases are 24 words. Some older wallets used 12 words. Any number of words are supported by the tool. Be sure to enter words separated by a single space, with no leading or trailing spaces. The words, their order, and their case must exactly match the original. Check the addresses returned match the source.

This returns a JSON object with multiple addresses and keys or an object with an error message.

Example Usage:

As a CLI:

npx zenclaim-seedtool --mnemonicPhrase="your seed phrase here" --network="testnet"

As a module:

import { deriveAddresses } from 'zenclaim-seedtool';

const options = {
  mnemonicPhrase: "your usually 12 or 24 seed phrase here",
  network: "testnet"
};

deriveAddresses(options).then(result => {
  if(result.error) return console.error(result.error);
  console.log(result);
}).catch(error => {
  console.error(error.message);
});

Arguments/Options:

Only the mnemonicPhrase is required. Defaults are for ZEN mainnet and the default derivation path.
Drop the dashes when creating an options object for module use.

  --mnemonicPhrase="" (mandatory, usually 12 or 24 words)
  --mnemonicPassword="" (optional, default "", seed password)
  --numAddresses=int (optional, default 5)
  --derivationPath="" (optional, default "m/44'/121'/0'/0/")
  --derivationAddressIndexOffset=int (optional, default 0, offset of last integer in derivation path)
  --network="mainnet||testnet" (optional, default "mainnet")
  --stringify (optional default array, array as JSON.stringify() output)
  --help  display this help
  --verbose display additional values to help debug
 // Short forms of arguments for the command line only
  -ph="" -pw="" -na= -dp="" -do="" -nt="" -s -h -v

Notes: help, stringify and short forms are only available in the CLI.

zenclaim-signtool

Sign a special message with the private key of the ZEN source address. See instructions for building a message for a multisig address in the multisig tool as it has a different format.

The format of the message to sign is the word "HBETACLAIM" plus the address (checksum format) of the account on Base to receive the funds. The private key is from the address containing the ZEN at the time of the snapshot.

Returns an object with an address and signature or an object with an error message.

As a CLI

npx zenclaim-signtool --privKey="your_zen_private_key_here" --message="your_message_here" --network="testnet"

As a module:

import { signMessage } from 'zenclaim-signtool';

const options = { 
  privKey: "your_private_key_here", 
  message: "your_message_here",
  network: "testnet"
}

signMessage(options).then(result => {
  if (result.error) {
    console.error(result.error);
  } else {
  console.log(result);
  }
}).catch(error => {
  console.error(error.message);
});

Arguments/Options:

Only the message and private key are required. Defaults are for ZEN mainnet.
Drop the dashes when creating the options object for module use.

 --privKey="" (mandatory, WIF (Wallet Import Format) or raw format private key)
 --message="" (mandatory) 
 --compressed=true||false (optional, default true) 
 --network="mainnet||testnet" (optional, default mainnet)
 --stringify (optional JSON.stringify() output, default object {signature, address})
 --help  display this help
 --verbose  display additional values to help debug
// Short forms of arguments for the command line only
  -pk="" -ms="" -cp= -nt="" -s -h -v

The message to sign should consist of the word HBETACLAIM and the destination address on Base Example "HBETACLAIM0x0Fd343F9a263906bD6AfebfDD4011579979E8aeC" See the multisig claim tool for the message to sign for multisig addresses. That tool can generate a message to sign for you.

zenclaim-verifymessage

Verify a message when passed a message, ZEN address, and signature.
Returns either true or false on success or an object with an error message.

As a CLI:

npx zenclaim-verifymessage --message="your_signed_message_here" --zenAddress="your_znaddress_here" --signature="signature_here" --network="testnet"

As a Module:

import { verifyMessage } from 'zenclaim-verifymessage';

const options = { 
  message: "message_here", 
  zenAddress: "zen_address_here", 
  signature: "signature_here",
  network: "testnet"
};

verifyMessage(options).then(result => {
  if (result.error) {
    console.error(result.error);
  } else {
  console.log(result);
  }
}).catch(error => {
  console.error(error.message);
});

Arguments/Options:

The message, zenAddress and signature are all required.
Drop the dashes when creating an options object for module use.

 --message="" (mandatory) 
 --zenAddress="" (mandatory)
 --signature="" (mandatory)
 --help  display this help
 --verbose  display arguments received
// Short forms of arguments for command line 
  -ms="" -za="" -sg="" -h -v 

zenclaim-recoverpubkey

Recover the public key of a ZEN address from a signed message. This tool extracts the public key and determines the x and y coordinates required by the claim smart contract. This is only needed if interacting with the smart contract directly without using zenclaim-claimzenaddress

The claim smart contract requires the public key of the claimed address in a special format. This command extracts the public key of the zen address from the message and message signature and determines the x and y coordinates. It is unlikely it would be used unless you are building a custom script or app to submit claims. The claim tools already perform this action.

Returns an object with the x and y coordinates or an object with an error message

As a CLI:

npx zenclaim-recoverpubkey --message="your_signed_message_here" --zenAddress="source_address_here" --signature="signature_here" --network="testnet"

As a module:

import { recoverPubKey } from 'zenclaim-recoverpubkey';

const options = { 
  message: "your_signed_message_here",
  zenAddress: "source_address_here",
  signature: "signature_here",
  network: "testnet"
};

recoverPubKey(options).then(result => {
  if (result.error) {
    console.error(result.error);
  } else {
    console.log(result);
  }
}).catch(error => {
  console.error(error.message);
});

Arguments/Options:

The signed message, ZEN address and signature are required.
Drop the dashes when creating an options object for module use.

 --message="" (mandatory) 
 --zenAddress="" (mandatory)
 --signature="" (mandatory)
 --network="mainnet||testnet" (optional, default "mainnet")
 --help  display this help
 --verbose display arguments received
// Short forms of arguments for command line 
  -ms="" -za="" -sg="" -h -v 

zenclaim-claimzenaddress

Submit a claim for a standard ZEN transparent address.
This validates the claim and sends a transaction to the smart contract on Base. The call requires access to the internet and uses the sender's private key.

The sender does not have to be the destination address. Be sure there are funds in the sender's address to cover gas fees. It will be checked prior to sending.

The ZEN address source, destination address on Base, message signature, and sender's private key are all required.

Returns the transaction hash on success or an object with an error message.

As a CLI:

npx zenclaim-claimzenaddress --zenAddress="source_address_here" --destinationAddress="base_address_here" --signature="from_signed_message" --senderAddressPrivKey="base_senders_private_key" --network="testnet"

As a module:

import { claimZenAddress } from 'zenclaim-claimzenaddress';

const options = { 
  zenAddress: "source_zen_address",
  destinationAddress: "base_destination_address",
  signature: "signature_from signed_message",
  senderAddressPrivKey: "base_senders_private_key",
  network: "testnet"
};

claimZenAddress(options).then(result => {
  if (result.error) {
    console.error(result.error);
  } else {
    console.log(result);
  }
}).catch(error => {
  console.error(error.message);
});

Arguments/Options:

The ZEN address, Base destination address, signature, and sender address private key are required. Defaults are for ZEN mainnet.
Drop the dashes when creating an options object for module use.

 --zenAddress="" (mandatory, Horizen 1 Mainchain address) 
 --destinationAddress="0x.." (mandatory, claim destination Ethereum address on Base L2 starting with 0x) 
 --signature="" (mandatory signed message signature from zenAddress) 
 --senderAddressPrivKey="" (mandatory, private key of Ethereum address sending the transaction and paying the fee)  
 --maxFeePerGas=int (optional, wei, overrides provider estimate) 
 --maxPriorityFeePerGas=int (optional, wei, overrides provider estimate) 
 --network="mainnet||testnet" (optional, default "mainnet")
 --help  display this help
 --verbose  display additional values to help check for errors
// Short forms of arguments for command line 
  -za="" -da="" -sg="" -pk="" -gf= -pf= -nt="" -h -v

The message to sign should consist of the word HBETACLAIM and the destination address (starting with 0x) on Base and should be signed with the public key of the ZEN address of the funds. Example: "HBETACLAIM0x0Fd343F9a263906bD6AfebfDD4011579979E8aeC"

zenclaim-claimmultisigaddress

Submit a claim for a ZEN multisig address. This tool helps you create and submit a claim for ZEN funds from a multisig address to a Base destination address. It also can generate the message to sign for multisig claims.

As a CLI:

npx zenclaim-claimmultisigaddress --zenMultisigAddress="multisig_address_here" --destinationAddress="base_address_here" --redeemScript="your_redeem_script_here" --signatures="[\"signature1\",\"signature2\",\"...\"]" --senderAddressPrivKey="base_senders_private_key" 

Note: adjust the quotes for the operating system you are using.

As a module:

import { claimMultisigAddress } from 'zenclaim-claimmultisigaddress';

const options = {
  zenMultisigAddress:"multisig_address_here",
  destinationAddress: "base_destination_address",
  redeemScript: "redeem_script_here", 
  signatures: ["signature1", "signature2", "..."],
  senderAddressPrivKey: "base_senders_private_key"
};

claimMultisigAddress(options).then(result => {
  if (result.error) {
    console.error(result.error);
  } else {
    console.log(result);
  }
}).catch(error => {
  console.error(error.message);
});

Arguments/Options:

The ZEN multisig address, Base destination address, redeem script, signatures, and sender private key are required.
Drop the dashes when creating an options object for module use.

 --zenMultisigAddress="" (mandatory, Horizen 1 Mainchain P2SH-Multisig address) 
 --destinationAddress="0x.." (mandatory, claim destination Ethereum address on Base L2 in EIP-55 mixed-case checksum address encoding)
 --redeemScript="" (mandatory, Horizen 1 Mainchain P2SH-Multisig address redeemScript) 
 --signatures='["",""]' (mandatory, n signatures of a n-of-m multisig address) 
 --senderAddressPrivKey="" (mandatory, private key of Base address sending the transaction and paying the fee. must have enough funds for gas)  
 --maxFeePerGas=int (optional, wei, overrides provider estimate) 
 --maxPriorityFeePerGas=int (optional, wei, overrides provider estimate) 
 --network="mainnet||testnet" (optional, default "mainnet")
 --help  display this help
 --verbose  display additional values to help check for errors
 --buildmessage  build the message to sign. If present zenMultisigAddress, destinationAddress are required (include testnet if needed). Only the  message is returned, no transaction is sent.
// Short forms of arguments for command line
  -ma="" -da="" -ra="" -sg="" -pk="" -gf= -pf= -nt="" -h -v -b

The message to sign should consist of the word “HBETACLAIM” the base58check-decoded representation of the multisig address and the destination Ethereum address on Base L2 in EIP-55 mixed-case checksum address encoding. The addresses must be in the format 0x{hex}. Example "HBETACLAIM0x7caa11b3e0cdf22e9af9a4c5ac1cdc80938c34180x1448283357e8FB6EA763a78836FFD5517149BF70"
Use the --buildmessage option to create the message to sign.

Signatures must be created with the private key of each zenAddress used to create the multisig address. Only use the required number of signatures, e.g. a 3 of 5 multisig expects 3 of the signatures. Any other quantity will throw an error. The signatures may be in any order in the array.

zenclaim-deriveclaimdirectaddress

Deterministically generate a P2PKH ZEN address from a Base ETH address.

As a CLI:

npx zenclaim-deriveclaimdirectaddress --baseEthAddress="<base_eth_address>" --network="testnet" 

Note: adjust the quotes for the operating system you are using.

As a module:

import { deriveClaimDirectAddress } from 'zenclaim-deriveclaimdirectaddress';

const options = {
  baseEthAddress: "<base_eth_address>",
  network: "testnet"
};

deriveClaimDirectAddress(options).then(result => {
  if (result.error) {
    console.error(result.error);
  } else {
    console.log(result);
  }
}).catch(error => {
  console.error(error.message);
});

Arguments/Options:

The Base ETH address is required.
Drop the dashes when creating an options object for module use.

 --baseEthAddress="" (mandatory, Ethereum address on Base) 
 --network="mainnet||testnet" (optional, default "mainnet")
 --verbose  display additional values to help check for errors

// Short forms of arguments for command line
  -a="" -nt="" -v

zenclaim-claimdirect

This method distributes a balance from a derived ZEN address to the ETH address on Base. Derive a P2PKH ZEN address from the ETH address prior to the snapshot (use zenclaim-deriveclaimdirectaddress), and send the balance to this derived ZEN address.

The balance would be unspendable on Horizen 1 as no private key corresponding with the ZEN address exists, but funds would be locked in this address until distributed on Base.

As a CLI:

npx zenclaim-claimdirect --baseEthAddress="<base_eth_address>" --senderAddressPrivKey="<sender_private_key>" --network="testnet" 

Note: adjust the quotes for the operating system you are using.

As a module:

import { claimDirect } from 'zenclaim-claimdirect';

const options = {
  baseEthAddress: "<base_eth_address>",
  senderAddressPrivKey: "<sender_private_key>",
  network: "testnet"
};

claimDirect(options).then(result => {
  if (result.error) {
    console.error(result.error);
  } else {
    console.log(result);
  }
}).catch(error => {
  console.error(error.message);
});

Arguments/Options:

The Base ETH address and sender private key are required.
Drop the dashes when creating an options object for module use.

 --baseEthAddress="" (mandatory, Ethereum address on Base) 
 --senderAddressPrivKey="" (mandatory, private key of Horizen 2 address sending the transaction and paying the fee)
 --maxFeePerGas=int (optional, wei) 
 --maxPriorityFeePerGas=int (optional, wei) 
 --network="mainnet||testnet" (optional, default "mainnet")
 --help  display this help
 --verbose  display additional values to help check for errors

// Short forms of arguments for command line
  -a="" -pk="" -gf= -pf= -nt="" -h -v

zenclaim-deriveclaimdirectmultisig

Deterministically generate a P2SH ZEN multisig address and redeem script from a Base ETH address and ZEN public key.

As a CLI:

npx zenclaim-deriveclaimdirectmultisig --zenAddressPubKey="<zen_public_key>" --baseEthAddress="<base_eth_address>" --network="testnet" 

Note: adjust the quotes for the operating system you are using.

As a module:

import { deriveClaimDirectMultisig } from 'zenclaim-deriveclaimdirectmultisig';

const options = {
  zenAddressPubKey: "<zen_public_key>",
  baseEthAddress: "<base_eth_address>",
  network: "testnet"
};

deriveClaimDirectMultisig(options).then(result => {
  if (result.error) {
    console.error(result.error);
  } else {
    console.log(result);
  }
}).catch(error => {
  console.error(error.message);
});

Arguments/Options:

The Base ETH address and ZEN public key are required.
Drop the dashes when creating an options object for module use.

 --zenAddressPubKey="" (mandatory, compressed or uncompressed public key of a ZEN P2PKH address)
 --baseEthAddress="" (mandatory, Ethereum address on Base) 
 --network="mainnet||testnet" (optional, default "mainnet")
 --verbose  display additional values to help check for errors

// Short forms of arguments for command line
  pk="" -a="" -nt="" -v

zenclaim-claimdirectmultisigaddress

This method distributes a balance from a derived ZEN multisig address to the ETH address on Base. Derive a P2SH ZEN multisig address from the ETH address prior to the snapshot (use zenclaim-deriveclaimdirectmultisig), and send the balance to this derived ZEN multisig address.

Funds sent to the derived ZEN multisig address are spendable on Horizen 1 prior to the snapshot with the ZEN public/private key pair used to derive the ZEN multisig address.

As a CLI:

npx zenclaim-claimdirectmultisigaddress
 --redeemScript="<redeem_script>" --baseEthAddress="<base_eth_address>" --senderAddressPrivKey="<sender_private_key>" --network="testnet" 

Note: adjust the quotes for the operating system you are using.

As a module:

import { claimDirectMultisig } from 'zenclaim-claimdirectmultisig';

const options = {
  redeemScript: "<redeem_script>",
  baseEthAddress: "<base_eth_address>",
  senderAddressPrivKey: "<sender_private_key>",
  network: "testnet"
};

claimDirectMultisig(options).then(result => {
  if (result.error) {
    console.error(result.error);
  } else {
    console.log(result);
  }
}).catch(error => {
  console.error(error.message);
});

Arguments/Options:

The redeem script, Base ETH address and sender private key are required.
Drop the dashes when creating an options object for module use.

 --redeemScript="" (mandatory, Horizen 1 Mainchain P2SH-Multisig address redeemScript) 
 --baseEthAddress="" (mandatory, Ethereum address on Base)
 --senderAddressPrivKey="" (mandatory, private key of Base address sending the transaction and paying the fee. must have enough funds for gas)  
 --maxFeePerGas=int (optional, wei, overrides provider estimate) 
 --maxPriorityFeePerGas=int (optional, wei, overrides provider estimate) 
 --network="mainnet||testnet" (optional, default "mainnet")
 --help  display this help
 --verbose  display additional values to help check for errors

// Short forms of arguments for command line
  -rs="" -a="" -pk="" -gf= -pf= -nt="" -h -v

---

Submitting a Claim For a ZEN Address

Quick Start Example (Transparent Address)

1. Create Message: HBETACLAIM0xYourBaseAddressHere
2. Sign Message: npx zenclaim-signtool --privKey="YourPrivateKey" --message="HBETACLAIM0xYourBaseAddressHere"
3. Claim ZEN: npx zenclaim-claimzenaddress --zenAddress="YourZenAddress" --destinationAddress="0xYourBaseAddressHere" --signature="YourMessageSignature" --senderAddressPrivKey="SendersBasePrivateKey"

Below are the basic steps to submit a claim for ZEN transparent addresses using zenclaim-claimzenaddress.

1. Prepare the Destination Address: Identify the Base network address where you want to receive the ZEN. Ensure it is in the correct format (starting with 0x and in checksum format).
2. Create the Message to Sign:
   • Construct the message by combining the word "HBETACLAIM" with your Base destination address.
   • Example: HBETACLAIM0x0Fd343F9a263906bD6AfebfDD4011579979E8aeC
3. Sign the Message Using zenclaim-signtool:
   • Use the zenclaim-signtool to sign the message created in the previous step.
   • Provide your ZEN private key and the message to sign as arguments or options.
   • Command Line Example: npx zenclaim-signtool --privKey="your_zen_private_key_here" --message="HBETACLAIM0x0Fd343F9a263906bD6AfebfDD4011579979E8aeC" --network="testnet"
   • This step will provide you with a signature.
4. Submit the Claim Using zenclaim-claimzenaddress:
   • Use the zenclaim-claimzenaddress command to submit the claim.
   • Provide the source ZEN address, the destination Base address, the signature obtained from the previous step, and the sender's private key for the Base network.
   • The sender's private key should be associated with an address that has sufficient funds to cover gas fees.
   • Command Line Example (all on one line):
     • npx zenclaim-claimzenaddress --zenAddress="source_address_here" --destinationAddress="base_address_here" --signature="from_signed_message" --senderAddressPrivKey="base_senders_private_key" --network="testnet"
   • This tool will validate the claim and send a transaction to the smart contract on Base.
   • The transaction hash is returned when successful.
5. Verify the Transaction: After submitting the claim, verify the transaction using the transaction hash returned in the previous step on the Base network using a block explorer (https://sepolia.basescan.org/)[https://sepolia.basescan.org/]. Check that the ZEN has been transferred to your destination Base address.

Alternatives

No Private Key Access

If you don’t have the private key to sign the message, the owner/holder of the address private key may sign the message using another method available in the ZEN ecosystem, such as using the Sphere application.
In this case:

• Either create and provide the message to the owner or instruct them what the message must contain.
• Have the owner sign the message and return the signature.
• Use the zenclaim-message tool to verify the message.
• If the message valid, continue with Submit the Claim Using zenclaim-claimzenaddress

Submitting a Claim for a Multisig Address

This example is for a 3 of 5 multisig. Only submit the required number of signatures.

Quick Start Example (Multisig Address)

1. Build Message: npx zenclaim-claimmultisigaddress --zenMultisigAddress="YourMultisigAddress" --destinationAddress="YourBaseAddress" --network="testnet" --buildmessage
2. Sign Message: Each required key holder signs the message returned from the previous step using their private key (e.g., with npx zenclaim-signtool).
3. Claim ZEN: npx zenclaim-claimmultisigaddress --zenMultisigAddress="YourMultisigAddress" --redeemScript="YourRedeemScript" --destinationAddress="YourBaseAddress" --senderAddressPrivKey="SendersBasePrivateKey" --signatures="[\"Signature1\",\"Signature2\",\"Signature3\"]" --network="testnet"

Submitting a claim for a multisig address requires coordination with the holders of the private keys. The following steps detail the process for a multisig address requiring three signatures using the zenclaim-claimmultisigaddress tool.

1. Identify the Destination Address: Determine the Base network address where you want to receive the ZEN. Ensure it is in the correct format, starting with 0x and in checksum format.
2. Gather Multisig Address and Redeem Script Information:
   • Obtain the ZEN multisig address for which you are claiming funds.
   • Retrieve the corresponding redeem script for this multisig address.
3. Build the Message to Sign:

   • Use the zenclaim-claimmultisigaddress tool with the --buildmessage option to create the message each key holder must sign. This step requires the multisig address and the destination address.

   • Command Line Example:

     npx zenclaim-claimmultisigaddress --zenMultisigAddress="multisig_address_here" --destinationAddress="base_address_here" --network="testnet" --buildmessage

   • The tool will return the exact message that must be signed by each key holder. This message will be in the format HBETACLAIM{multisig_address_decoded}{destination_address}.

4. Interact with Key Holders:
   • Share the message generated in the previous step with each of the three key holders.
   • Instruct each key holder to sign the message using their respective private key and any appropriate tool (e.g., zenclaim-signtool or another signing method like the Sphere application).
   • Request each key holder to provide you with their signature.
5. Collect Signatures: Gather all three signatures from the respective key holders. Ensure each signature is correct. Optionally use the zenclaim-verifymessage tool to validate each message.
6. Submit the Multisig Claim:

   • Use the zenclaim-claimmultisigaddress tool to submit the claim.

   • Provide the multisig address, the redeem script, the destination address, the three collected signatures in an array, and the sender's private key for the Base network (this address must have sufficient funds to cover gas fees).

   • Command Line Example (all on one line):

     npx zenclaim-claimmultisigaddress --zenMultisigAddress="multisig_address_here" --redeemScript="your_redeem_script_here" --destinationAddress="base_address_here" --senderAddressPrivKey="base_senders_private_key" --signatures="[\"signature1\",\"signature2\",\"signature3\"]" --network="testnet"

   • Note: Adjust the quotes for the operating system you are using (the backslash escape character may not be needed). In module use, signatures must be an array.

7. Verify the Transaction:
   • After submitting the claim, the tool will return a transaction hash if successful.
   • Use this transaction hash to verify the transaction on the Base network using a block explorer like https://sepolia.basescan.org/.
   • Confirm that the ZEN has been transferred to the destination Base address.

Troubleshooting

If referencing the aliases of the modules does not resolve, the modules may be loaded by file names. The full path may be needed depending on where they were downloaded.

Locations relative to the repository folder:

zenclaim-seedtool: "bin/seedtool.js",
zenclaim-signtool: "bin/signtool.js",
zenclaim-verifymessage: "bin/verifymessage.js",
zenclaim-claimzenaddress: "bin/claimzenaddress.js",
zenclaim-recoverpubkey: "bin/recoverpubkey.js",
zenclaim-claimmultisigaddress: "bin/claimmultisigaddress.js",
zenclaim-deriveclaimdirectaddress: "bin/deriveclaimdirectaddress.js",
zenclaim-deriveclaimdirectmultisig: "bin/deriveclaimdirectmultisig.js",
zenclaim-claimdirect: "bin/claimdirect.js",
zenclaim-claimdirectmultisig: "bin/claimdirectmultisig.js"