How FUSION Achieved the World's First Distributed-Signature Cross-Chain Transaction

FUSION recently announced the world's first distributed-signature cross-chain transaction, achieved via DCRM technology.

Transaction address: https://etherscan.io/tx/0x72584366019dfefb80c5f52becf7c4545c160537e5bf257b4cab809e8dc99884

We can see this transaction is on Ethereum:

Block height: 5986859 Time: Jul-18-2018 02:31:39 PM +UTC Transfer: 0.123456789 Ether Tx data: Powered by FUSION DCRM: The world's first decentralized signature transaction. https://github.com/FUSIONFoundation/dcrm

The transaction is real, but questions remain: is this genuine? What is a distributed-signature transaction? How is it different from an ordinary one? How was it done? And why call it the world's first distributed-signature cross-chain transaction?

1. What Is Distributed Signature

FUSION's DCRM distributed-signature technology lets users cross-chain Lock-in their digital assets to a single blockchain platform, and Lock-out to a designated account at any time. It supports all digital assets controlled by Bitcoin-like cryptography, including over 90% of mainstream crypto assets: BTC, ETH, USDT, ERC-20 tokens, and so on.

Distributed signature is built on blockchain's most core cryptography, solving decentralized cross-chain trust from the lowest cryptographic layer. It combines distributed key generation, secret sharing, threshold signatures, commitment schemes, homomorphic encryption, and zero-knowledge proofs — algorithms that are provably secure, just like Bitcoin's. After Lock-in, the assets are managed by thousands of decentralized nodes worldwide across the FUSION network using distributed-key algorithms; the asset ledger is publicly recorded on-chain and tamper-proof, so users can safely trust the open-source code and cryptography.

Comparison of signature technologies

For both Bitcoin and Ethereum, an ordinary transaction is signed by the user with their private key via a wallet, whereas a distributed-signature transaction is signed jointly by the decentralized nodes of the blockchain network. For more detail, see the author's companion piece: FUSION: DCRM Distributed Signature Technology

2. How This Transaction Was Done

This transaction was done via FUSION's DCRM technology; the code is at FUSION's official GitHub: https://github.com/FUSIONFoundation/dcrm. DCRM's core function is to generate distributed private and public keys and to complete distributed signing.

To complete a transaction with Ethereum, a transaction program is also needed; the author's Go test code is at: https://github.com/zhaojun-sh/dcrm-test. Its main job is to construct a transaction and send it to the Ethereum network.

Since DCRM is still in a testing phase with no wallet yet supporting distributed-signature transactions, the flow is demonstrated through the above code:

A. Generate a DCRM address controlled by a distributed private key

Running the DCRM code produces the following, representing 4 nodes distributedly generating 4 private-key shares and one public key, from which an address can be derived (4 nodes simulated on one server).

--Info: User 0 generate Private Key Share PrivateKey Share: 84985294175903376931445795015467894006937990435985966931354507719444581255012 --Info: User 1 generate Private Key Share PrivateKey Share: 84940305801941904466664650218833612629672900930983791755864604768328058215142 --Info: User 2 generate Private Key Share PrivateKey Share: 48301921624326365388572144770320542374756243070409113696101196017150962650950 --Info: User 3 generate Private Key Share PrivateKey Share: 74476474800750184490014153736266688989328133924980580120573080366704112843538 --Info: Calculate the Encrypted Private Key EncPrivateKey: 17332973071375919563215820804881320411467745592167577530425814425237117981543096114123… (full value omitted for brevity) --Info: Calculate the Public Key PublicKey:(69569e08f0a701b880002b6437bd7ec73248d7487c04afc0698fe1bdcf6184a9,ac288eceaf75478ff73d325447f3791a5c5ef3d8979cb5b6e02bebb9e6802c6,cf3a739c665c0c242ebee6cf7d15aeddd7612934ad91090d0aabb7ec08fae58a,0)

B. The user manually transfers ETH to this address

The newly generated DCRM address needs the user to send some ETH to it for testing.

address := common.BytesToAddress(crypto.Keccak256([]byte(PublicKey)[1:])[12:]).Hex()

C. Construct an Ethereum transaction

The code sets the amount, recipient, gas, etc., and generates the transaction's RLP hash as input to the distributed-signature sign interface.

tx := types.NewTransaction( 0x00, // nonce toAccDef.Address, // to address big.NewInt(123456789000000000), // amount 48000, // gasLimit big.NewInt(41000000000), // gasPrice []byte(Powered by FUSION DCRM: The world's first decentralized signature transaction. https://github.com/FUSIONFoundation/dcrm)) // data chainID := big.NewInt(CHAIN_ID) signer := types.NewEIP155Signer(chainID) fmt.Printf("\nTXRLPhash = %s\n", signer.Hash(tx).String())

D. Generate the distributed signature from the transaction's RLP hash

DCRM generates the distributed signature from the RLP-encoded transaction hash and returns the result (r, s, v). The program runs through commitment, zero-knowledge, and encrypted inner-data rounds across the 4 users (full console output omitted for brevity), finally producing:

Real DCRM ECDSA Signature is (r,s,v): (3647f23d3a6d8407862336e8536dcb8276facf7c5a69749b44dc65d2e467c2fe,64894b2469992357e3dbfcdc64ab5c31983a97531dbdb5a54787f49cb777ecb6,1)

With the distributed signature obtained, the transaction program assembles the complete RawTransaction:

    // attach signature to the transaction structure
        message, merr := hex.DecodeString(signature)
        if merr != nil {
            fmt.Println("Decode signature error:")
            panic(merr)
        }
        sigTx, signErr := tx.WithSignature(signer, message)
        if signErr != nil {
            fmt.Println("signer with signature error:")
            panic(signErr)
        }    // recover public key
        recoverpkey, perr := crypto.Ecrecover(signer.Hash(tx).Bytes(), message)
        if perr != nil {
          fmt.Println("recover signature error:")
          panic(perr)
       }
       fmt.Printf("\nrecover publickey = %s\n", hex.EncodeToString(recoverpkey))   // recover address
       recoveraddress := common.BytesToAddress(crypto.Keccak256(recoverpkey[1:])[12:]).Hex()
       fmt.Printf("\nrecover address = %s\n", recoveraddress)    // build the complete RawTransaction
        txdata, txerr := rlp.EncodeToBytes(sigTx)
        if txerr != nil {
            panic(txerr)
        }
        fmt.Printf("\nRawTransaction = %+v\n\n", common.ToHex(txdata))

E. Send the transaction to the Ethereum network

With the complete distributed-signature transaction built, it's sent to the network via Ethereum geth's JSON-RPC interface, where miners package it; on success a transaction hash ID is returned for querying status.

    // run geth locally connected to Ethereum and send the tx: ./geth --rpc console
        client, err := ethclient.Dial("http://127.0.0.1:8545") // 8545 = geth RPC port
        if err != nil {
            fmt.Println("client connection error:")
            panic(err)
        }
        fmt.Println("\nHTTP-RPC client connected")
        fmt.Println()    // send the tx to the network
        ctx   := context.Background()
        txErr := client.SendTransaction(ctx, sigTx)
        if txErr != nil {
            fmt.Println("send tx error:")
            panic(txErr)
        }
        fmt.Printf("send success tx.hash = %s\n", sigTx.Hash().String())

That completes a distributed-signature transaction. All DCRM code is open-sourced on GitHub, so developers can test or audit it anytime, and FUSION should welcome feedback and updates. Finally, a tip: set chainID=4 to test distributed-signature transactions on the testnet, to avoid losing funds due to unfamiliarity with the transaction code.

3. Why It's the "First"

FUSION's DCRM distributed-signature technology inherits Bitcoin's idea of solving decentralized trust with cryptography. Built on the most core cryptographic algorithms, it generates distributed private keys via DKG, prevents malicious attacks via commitment algorithms, processes ciphertext via homomorphic encryption, verifies privacy via zero-knowledge proofs, and achieves node redundancy via threshold signatures — finally realizing a decentralized distributed-signature algorithm. This surpasses today's common private-key and multi-signature techniques and carries genuine innovation; the FUSION Foundation has filed a PCT international patent.

The Future

Completing the first decentralized distributed-signature transaction means FUSION's DCRM technology achieved a breakthrough in its core technology — but this is only the beginning. After the FUSION mainnet launches, DCRM will meet the challenge of forming consensus across thousands of network nodes worldwide. DCRM will link all blockchain networks to embrace the coming Internet of Value!