Ethereum to Binance Chain bridge demo

Through last three months we were working on a prototype for the new type of the bridge that will be able to transfer assets from an Ethereum-based chain to the Binance Chain.

Initial idea of the bridge was described in this post on the forum.

Then, through series of experiments and discussions the first MVP has been born:

This bridge is able to transfer an ERC20 tokens on an EVM-based chain to BEP2 to the Binance Chain and vice versa and uses the idea similar to the TokenBridge:

  1. There are set of contracts on the Ethereum chain side that managing main the logic of the bridge.
  2. There is an oracle that listens events on both side of the bridge.
  3. There are set of validators that keeps its own instance of the oracle run. Validators are authorized to confirm assets relay requests.
  4. To confirm a relay request from the Binance Chain to the Ethereum-based chain they needs to invoke corresponding method in the contract (multisig template).
  5. To confirm a relay request from the Etereum-based chain to the the Binance Chain they use multi-party computation approach to generate the signature (Threshold Signature Scheme implemented by for ECDSA by KZen Research team). At this moment the tool for TSS is used as is. It is assumed that later the part of TSS orchestration will be moved to the orchestration contract. So far, the orchestration contract is used as a database to keep data required by TSS parties during the signature generation.

We also provided a step-by-step manual in order to allow everyone to try the current version of the bridge:

The instructions bellow will start two EVM-based chains (ganache):

  • Home chain - it keeps an ERC20 contract (0x44c158FE850821ae69DaF37AADF5c539e9d0025B) and the bridge contract (0x94b40CC641Ed7db241A1f04C8896ba6f6cC36b85).
  • Side chain - the MPC orchestration contract (0x44c158FE850821ae69DaF37AADF5c539e9d0025B) is located here
    Both chains are run in separate docker containers.

Three validators will be run and only two validators are required to confirm the transfer. Every validator node is a set of docker containers (eth-watcher, bnc-watcher, signer, proxy, redis, rabbitmq).

The public Binance Chain testnet will keep a BEP2 token.

  1. Preparation
    • (1.1) Download tbnbcli from
    • (1.2) Create a new account through the web-interface in the Binance testnet wallet. Copy the private key and mnemonic phrase. The private key will be used to import it in an Ethereum Wallet. The mnemonic phrase is to recover the BNB with tbnbcli.
    • (1.3) Recover the account in the console with the mnemonic.
      ./tbnbcli keys add test_account1 --recover
    • (1.4) Create few BNB accounts from the console. They will be donors to provide enough funds to issue a BEP2 tokens (500 BNB required).
      ./tbnbcli keys add test_account2
      ./tbnbcli keys add test_account3
    • (1.5) Register on the Binance site and fund the accounts from the testnet faucet.
    • (1.6) Re-arrange funds on the accounts as so the first account will have 550 BNB and others 10-20 BNBs to make transactions.
      ./tbnbcli send --from test_account2 --to <address of the first account> \ 
        --amount 18500000000:BNB --chain-id=Binance-Chain-Nile \ --memo "donate"
      ./tbnbcli send --from test_account3 --to <address of the first account> \
        --amount 18500000000:BNB --chain-id=Binance-Chain-Nile --memo "donate"
    • (1.7) Issue the BEP2 token from the first account. 3141500000000000 corresponds to 31415000.0 tokens.
      ./tbnbcli token issue --token-name "ERC20toBEP2Bridge" --total-supply 3141500000000000 \
        --symbol ETB0819 --mintable --from test_account1 --chain-id=Binance-Chain-Nile \ --trust-node
      In the real deployment most probably the token must not be mintable.
    • (1.8) Get the BEP2 token ID in denom field (in this example it is ETB0819-863).
      ./tbnbcli account <address of the first account> \
        --chain-id=Binance-Chain-Nile --trust-node
    • (1.9) Clone the repo and initialize git submodules:
      git clone --recurse-submodules
    • (1.10) Build TSS to be used in the bridge oracles:
      docker build -t tss -f ./src/tss/Dockerfile-local ./src/tss
  2. Run test environment
    • (2.1) Modify src/deploy/deploy-test/.env and specify the amount of tokens to mint in the parameter TOKEN_INITIAL_MINT.
    • (2.2) Run testnets and deploy contracts
      This command will also mint tokens, the owner of tokens is the address that corresponds to the private key specified in PRIVATE_KEY_DEV of src/deploy/deploy-test/.env.
    • (2.3) Get the Ethereum account address for the first test account from its private key (step 1.2). NiftyWallet could be used for this.
    • (2.4) Send few tokens and coins from the current token owner to the first account. Coins are needed to pay transaction fees.
      ./src/test-services/ethereumSend/ <first account Ethereum address> 5000000000000000000 0.5
    • (2.5) Check that the tokens were transferred properly:
      ./src/test-services/ethereumBalance/ <first account Ethereum address>
  3. Run validators nodes:
    • (3.1) Modify the parameter FOREIGN_ASSET in demo/validator1/.env, demo/validator2/.env and demo/validator3/.env to specify the identificator of the token (step 1.8) that the oracle will watch.
    • (3.2) Run three validators in separate terminal sessions.
      N=1 ./demo/
      N=2 ./demo/
      N=3 ./demo/
      Wait for when the line like the following appears:
      keygen_1 | Generated multisig account in binance chain: tbnb1mutgnx9n9devmrjh3d0wz332fl8ymgel6tydx6
      The line contains the address of the bridge address in the Bincance Chain.
  4. Initialize the state of the bridge account in the Binance Chain
    • (4.1) Fill the balance Fund with BNB coins as so the account will be able to make transactions:
      ./tbnbcli send --from test_account1 --to <address of the bridge account> \ 
        --amount 1000000000:BNB --chain-id=Binance-Chain-Nile \ --memo "initialization"
    • (4.2) Fund the account with bridgeable tokens. This transaction should have ‘funding’ in the memo:
      ./tbnbcli send --from test_account1 --to <address of the bridge account> \ 
        --amount 3141500000000000:ETB0819-863 --chain-id=Binance-Chain-Nile \ --memo "funding"
      The oracles should catch this transaction but will ignore it:
      bnc-watcher_1  | Fetching new transactions
      bnc-watcher_1  | Sending api transactions request
      bnc-watcher_1  | Found 1 new transactions
      To check the balance of the bridge account the Binance Testnet Explorer could be used. It should report about two assets owned by the account.
  5. Transfer tokens from Ethereum-based chain to the Binance Chain:
    • (5.1) Modify the parameter HOME_PRIVATE_KEY as so it contains the private key of the first test account (step 1.2)
    • (5.2) Send some amount of tokens to the bridge contract:
      ./src/test-services/ethereumSend/ bridge 5000000000000000000
    • (5.3) The validators will catch the event and start the process to sign the transaction.
    • (5.4) As soon as the signature is generated and sent, the balance of the bridge account in both chains will be changed:
      ./src/test-services/ethereumBalance/ 0x94b40CC641Ed7db241A1f04C8896ba6f6cC36b85
      should report non-zero balance
      ./tbnbcli account <address of the bridge account> \
        --chain-id=Binance-Chain-Nile --trust-node
      should report about the balance reduction.
      The balance and transactions related to the bridge account in the Binance Chain could be checked in Binance Testnet Explorer.
    • (5.5) Check that the tokens was transferred to the first test account either by tbnbcli or by Binance Testnet Explorer.
  6. Transfer tokens from the Binance Chain to Ethereum-based chain:
    • Use either tbnbcli or the Binance testnet wallet to send tokens to the bridge account:
      ./tbnbcli send --from test_account1 --to <address of the bridge account> \ 
        --amount 300000000:ETB0819-863 --chain-id=Binance-Chain-Nile \ --memo "any note"
    • Check the balances of the test account on both sides of the bridge to see that the funds were transferred properly.

More details about tools that can be used to manage the bridge can be found in the bridge repository.