Construir Transacciones

Las transacciones te permiten cambiar datos en la cadena o activar eventos. Generalmente, las transacciones siguen 5 pasos desde la construcción hasta la ejecución en la cadena: construir, simular, firmar, enviar y esperar.

1. Construir

   Construir una transacción es cómo especificas:

   1. La cuenta sender.
      Esta cuenta normalmente paga las tarifas de gas por esta transacción. Ver Patrocinio de Transacciones para aprender cómo hacer que otra cuenta pague las tarifas.
   2. La function siendo llamada en la cadena.
      Este es el identificador para la función de entrada del contrato inteligente en la cadena que se activará cuando ejecutes esta transacción.
   3. Los functionArguments.
      Esto es cualquier dato que la función necesita para ejecutarse.

   Esto puede ser empaquetado en una SimpleTransaction usando aptos.transaction.build.simple(...) así:

   const transaction = await aptos.transaction.build.simple({
     sender: sender.accountAddress,
     data: {
       // Todas las transacciones en Aptos se implementan a través de contratos inteligentes.
       function: "0x1::aptos_account::transfer",
       functionArguments: [destination.accountAddress, 100],
     },
   });

   Opciones de Construcción

   Sección titulada «Opciones de Construcción»

   Puedes personalizar la forma en que tu transacción se ejecuta pasando options: {...} al construir. Algunas de las opciones más comúnmente usadas son:

   1. maxGasAmount - Esto limita la cantidad de gas que estás dispuesto a pagar para ejecutar esta transacción.
   2. gasUnitPrice - Puedes especificar un precio por gas mayor que el mínimo para ser ejecutado con mayor prioridad por la red de Aptos.
   3. expireTimestamp - Esto da un tiempo concreto en el que la transacción debe ejecutarse o será cancelada.

   El SDK proporciona valores predeterminados sensatos para estos valores si no se especifican explícitamente.

2. Simular (Opcional)

   Cada transacción en la cadena de Aptos tiene una tarifa de gas asociada con cuánto trabajo tienen que hacer las máquinas de la red al ejecutar la transacción. Para estimar el costo asociado con eso, puedes simular transacciones antes de confirmarlas.

   Puedes ejecutar la simulación usando aptos.transaction.simulate.simple(...) así:

   const [userTransactionResponse] = await aptos.transaction.simulate.simple({
     signerPublicKey: signer.publicKey,
     transaction,
   });
   // Si la tarifa se ve bien, continúa a firmar!

3. Firmar

   Una vez que la transacción está construida y las tarifas parecen razonables, puedes firmar la transacción con aptos.transaction.sign. La firma debe venir de la cuenta sender.

   // 3. Firmar
   const senderAuthenticator = aptos.transaction.sign({
     signer: sender,
     transaction,
   });

4. Enviar

   Ahora que la transacción está firmada, puedes enviarla a la red usando aptos.transaction.submit.simple así:

   // 4. Enviar
   const committedTransaction = await aptos.transaction.submit.simple({
     transaction,
     senderAuthenticator,
   });

5. Esperar

   Finalmente, puedes esperar el resultado de la transacción usando aptos.waitForTransaction y especificando el hash de la transacción que acabas de enviar así:

   // 5. Esperar
   const executedTransaction = await aptos.waitForTransaction({ transactionHash: committedTransaction.hash });

/**
 * This example shows how to use the Aptos SDK to send a transaction.
 * Don't forget to install @aptos-labs/ts-sdk before running this example!
 */

import {
    Account,
    Aptos,
    AptosConfig,
    Network,
} from "@aptos-labs/ts-sdk";

async function example() {
    console.log("This example will create two accounts (Alice and Bob) and send a transaction transfering APT to Bob's account.");

    // 0. Setup the client and test accounts
    const config = new AptosConfig({ network: Network.DEVNET });
    const aptos = new Aptos(config);

    let alice = Account.generate();
    let bob = Account.generate();

    console.log("=== Addresses ===\n");
    console.log(`Alice's address is: ${alice.accountAddress}`);
    console.log(`Bob's address is: ${bob.accountAddress}`);

    console.log("\n=== Funding accounts ===\n");
    await aptos.fundAccount({
        accountAddress: alice.accountAddress,
        amount: 100_000_000,
    });
    await aptos.fundAccount({
        accountAddress: bob.accountAddress,
        amount: 100,
    });
    console.log("Funded Alice and Bob's accounts!")

    // 1. Build
    console.log("\n=== 1. Building the transaction ===\n");
    const transaction = await aptos.transaction.build.simple({
        sender: alice.accountAddress,
        data: {
        // All transactions on Aptos are implemented via smart contracts.
        function: "0x1::aptos_account::transfer",
        functionArguments: [bob.accountAddress, 100],
        },
    });
    console.log("Built the transaction!")

    // 2. Simulate (Optional)
    console.log("\n === 2. Simulating Response (Optional) === \n")
    const [userTransactionResponse] = await aptos.transaction.simulate.simple({
        signerPublicKey: alice.publicKey,
        transaction,
    });
    console.log(userTransactionResponse)

    // 3. Sign
    console.log("\n=== 3. Signing transaction ===\n");
    const senderAuthenticator = aptos.transaction.sign({
        signer: alice,
        transaction,
    });
    console.log("Signed the transaction!")

    // 4. Submit
    console.log("\n=== 4. Submitting transaction ===\n");
    const submittedTransaction = await aptos.transaction.submit.simple({
        transaction,
        senderAuthenticator,
    });

    console.log(`Submitted transaction hash: ${submittedTransaction.hash}`);

    // 5. Wait for results
    console.log("\n=== 5. Waiting for result of transaction ===\n");
    const executedTransaction = await aptos.waitForTransaction({ transactionHash: submittedTransaction.hash });
    console.log(executedTransaction)
};

example();

Building and sending transactions on-chain involves the following 5 steps:

1. Build the transaction.
2. Simulate the cost. (Optional)
3. Sign the transaction (if the simulated cost seems ok).
4. Submit the transaction to the network.
5. Wait for the chain to validate and update.

Transactions have a couple of additional features which let them adapt to your needs which you can learn about here:

1. Multi-Agent Transactions - Allowing multiple accounts to interact with a single transaction.
2. Orderless Transactions - Allowing for transactions to be executed out of order for easier management.
3. Sponsoring Transactions - Have another account pay gas fees for this transaction.
4. Batch Submit Transactions - How to send multiple transactions quickly from a single account.
5. Binary Canonical Serialization (BCS) - The format used to serialize data for Aptos transactions.
6. Composing multiple Move calls with ScriptComposer - (Experimental) Building more complex transaction payload that calls into multiple Move functions dynamically.