Transacciones Multi-Agente

Las transacciones multi-agente permiten que múltiples cuentas participen en la lógica de un contrato Move.

Esto se puede usar para requerir que múltiples partes estén de acuerdo con una transacción antes de ejecutarla o para usar recursos de múltiples cuentas.

Crear y ejecutar una transacción multi-agente sigue un flujo similar al flujo de transacción simple, pero con varias diferencias notables.

1. Construir la transacción incluyendo secondarySignerAddresses con una lista de cada agente adicional.

   const transaction = await aptos.transaction.build.multiAgent({
     sender: alice.accountAddress,
     secondarySignerAddresses: [bob.accountAddress],
     data: {
       // REEMPLAZA CON TU FUNCIÓN MULTI-AGENTE AQUÍ
       function:
         "<REEMPLAZA CON TU FUNCIÓN DE ENTRADA MOVE MULTI-AGENTE> (Sintaxis {address}::{module}::{function})",
       // Pasa argumentos para la función que especificas arriba
       functionArguments: [],
     },
   });

2. (Opcional) Simular la transacción.

   Puedes simular la transacción multi-agente para previsualizar el resultado antes de enviarla de la siguiente manera:

   const [userTransactionResponse] = await aptos.transaction.simulate.multiAgent(
     {
       signerPublicKey: alice.publicKey,
       secondarySignersPublicKeys: [bob.publicKey],
       transaction,
     },
   );

   Las entradas signerPublicKey y secondarySignersPublicKeys son opcionales y se pueden omitir para saltar las verificaciones de clave de autenticación para los firmantes durante la simulación. Si quieres saltar la verificación de clave de autenticación solo para algunos de los firmantes secundarios, puedes proporcionar secondarySignersPublicKeys con las claves públicas de los firmantes específicos que quieres verificar, usando undefined como marcador de posición para los otros.

   Por ejemplo, si bob y carol son firmantes secundarios y solo quieres verificar la clave de autenticación de carol, puedes establecer secondarySignersPublicKeys: [undefined, carol.publicKey], dejando undefined como marcador de posición para bob.

3. Firmar una vez para cada agente.

   Combinarás estas firmas en el siguiente paso.

   const aliceSenderAuthenticator = aptos.transaction.sign({
     signer: alice,
     transaction,
   });
   // Bob es un firmante secundario para esta transacción
   const bobSenderAuthenticator = aptos.transaction.sign({
     signer: bob,
     transaction,
   });

4. Enviar la transacción combinando todas las firmas de agentes a través del parámetro additionalSignerAuthenticators.

   const committedTransaction = await aptos.transaction.submit.multiAgent({
     transaction,
     senderAuthenticator: aliceSenderAuthenticator,
     additionalSignersAuthenticators: [bobSenderAuthenticator],
   });

5. Finalmente, esperar a que la transacción se resuelva.

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

1. Instalar @aptos-labs/ts-sdk ejecutando pnpm i @aptos-labs/ts-sdk o usando el gestor de paquetes que te sea más cómodo.
2. Actualizar el fragmento de abajo para construir una transacción que requiera firma multi-agente.

/**
 * This example shows how to use the Aptos SDK to send a transaction.
 */

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();
  let carol = Account.generate();

  console.log("=== Addresses ===\n");
  console.log(`Alice's address is: ${alice.accountAddress}`);
  console.log(`Bob's address is: ${bob.accountAddress}`);
  console.log(`Carol's address is: ${carol.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_000_000,
  });
  await aptos.fundAccount({
    accountAddress: carol.accountAddress,
    amount: 100_000_000,
  });
  console.log("Done funding Alice, Bob, and Carol's accounts.");

  // 1. Build
  console.log("\n=== 1. Building the transaction ===\n");
  const transaction = await aptos.transaction.build.multiAgent({
    sender: alice.accountAddress,
    secondarySignerAddresses: [bob.accountAddress],
    data: {
      // REPLACE WITH YOUR MULTI-AGENT FUNCTION HERE
      function:
        "<REPLACE WITH YOUR MULTI AGENT MOVE ENTRY FUNCTION> (Syntax {address}::{module}::{function})",
      functionArguments: [],
    },
  });
  console.log("Transaction:", transaction);

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

  // 3. Sign
  console.log("\n=== 3. Signing transaction ===\n");
  const aliceSenderAuthenticator = aptos.transaction.sign({
    signer: alice,
    transaction,
  });
  const bobSenderAuthenticator = aptos.transaction.sign({
    signer: bob,
    transaction,
  });
  console.log(aliceSenderAuthenticator);
  console.log(bobSenderAuthenticator);

  // 4. Submit
  console.log("\n=== 4. Submitting transaction ===\n");
  const committedTransaction = await aptos.transaction.submit.multiAgent({
    transaction,
    senderAuthenticator: aliceSenderAuthenticator,
    additionalSignersAuthenticators: [bobSenderAuthenticator],
  });
  console.log("Submitted transaction hash:", committedTransaction.hash);

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

example();

NUMBER_OF_SIGNER_ARGUMENTS_MISMATCH - Esto ocurre cuando estás intentando hacer una firma multi-agente para una función que no requiere ese número de cuentas. Por ejemplo, si intentas usar múltiples firmas para una función 0x1::aptos_account::transfer - solo espera una dirección, y por lo tanto produce un error cuando se proporcionan más de una.