Sending transactions

info

This flow is also described in the Construction API Overview article in the official Rosetta documentation.

The steps needed to send payment in MINA token are following:

1. Given a key pair, derive the account indentifier using /construction/derive endpoint
2. Call /construction/preprocess and /construction/metadata to construct parameters for /construction/payloads request
3. Create an unsigned transaction blob using construction/payloads endpoint
4. Call construction/parse (optional) to check if the unsigned transaction does what you expect
5. Use detached signer to sign the transaction
6. Call construction/combine to generate signed blob to be sent via /construction/submit endpoint
7. Call construction/parse again (optional) to confirm correctness of the signed transaction
8. Get a future transaction hash using /construction/hash enpoint
9. Submit the signed transaction blob via /construction/submit endpoint

For ease of readability, this sample implementation skips the sanity checks (steps 4 and 7) and combines steps 2 and 3 in a single tx_payloads function call.

Before running this sample:

• Make sure you followed Offline signer tool article and generated a key pair
• Send some test funds on the account you've generated.

The implementation is as follows:

TypeScript

async function send(privateKey: string, to: string, valueNano: number, feeNano: number) {
    const publicKey = mina.derivePublicKey(privateKey)
    const publicKeyRaw = mina.publicKeyToRaw(publicKey)
    // get transfer payload to sign
    const payloadsResponse = await txPayloads(
        publicKeyRaw, publicKey, to, feeNano, valueNano)
    
    // sign and combine transfer payload
    const combineResponse = await txCombine(payloadsResponse, privateKey)
    const blob = combineResponse.signed_transaction

    // // get future transaction hash
    const txHashResponse = await txHash(blob)
    const hash = txHashResponse.transaction_identifier.hash

    // submit transaction. this call will fail if tx is not in mempool
    await txSubmit(blob)
    // wait for transaction confirmation:
    // for that, track blocks until we meet our transaction in the last one
    let latestBlock = (await networkStatus()).current_block_identifier.index
    while (true) {
        // check if our transaction exists in the latest block
        const txs = (await waitForBlock(latestBlock)).block.transactions
        const hashes = txs.map((tx: any) => tx.transaction_identifier.hash)
        if (hashes.includes(hash))
            break

        latestBlock += 1
    }
    return hash
}

Python

def withdrawal_flow(vault_keypair, dest_address, value_nano, fee_nano=None):
    """
    Full withdrawal flow example (without sanity check)
    If fee_nano is None - fee will be suggested by Rosetta API response
    """

    vault_pubkey = vault_keypair["public"]
    vault_private_key = vault_keypair["private"]
    
    # derive vault address
    derive_response = derive_account_identifier(vault_pubkey)
    vault_address = derive_response["account_identifier"]["address"]
    
    # get transfer payload to sign
    payloads_response = tx_payloads(
        vault_pubkey, vault_address, dest_address, fee_nano, value_nano)
    
    # sign transfer payload
    signature = sign_transaction(
        SIGNER_PATH, 
        vault_private_key,
        payloads_response["unsigned_transaction"])

    # get signed transaction blob
    combine_response = tx_combine(vault_pubkey, payloads_response, signature)
    signed_transaction_blob = combine_response['signed_transaction']

    # sanity check may be performed here 
    # for that - use tx_parse function output
    # to doublecheck it corresponds what you want to do
    # parsed_tx = tx_parse(signed_transaction_blob, True)

    # get future transaction hash
    tx_hash_response = tx_hash(signed_transaction_blob)
    future_tx_hash = tx_hash_response['transaction_identifier']['hash']

    # submit transaction. this call will fail if tx is not in mempool
    tx_submit(signed_transaction_blob)
    
    # wait for transaction confirmation:
    # for that, track blocks until we meet our transaction in the last one
    latest_block = network_status()["current_block_identifier"]["index"]
    while True:
        # check if our transaction exists in the latest block
        txs = wait_for_block(latest_block)['block']['transactions']
        hashes = [tx['transaction_identifier']['hash'] for tx in txs]
        if future_tx_hash in hashes:
            break
        latest_block += 1
    
    return future_tx_hash