SDK de Go - Simulando Transacciones

Simular transacciones te permite previsualizar el costo y el efecto de enviar una transacción sin pagar comisiones. Puedes usar esto para estimar comisiones, probar una transacción, o verificar cuál podría ser el resultado.

Para simular una transacción, debes pasar una transacción y qué cuenta sería el firmante:

// transfer_coin es un ejemplo de cómo hacer una transacción de transferencia de moneda de la manera más simple posible
package main

import (
  "fmt"

  "github.com/aptos-labs/aptos-go-sdk"
  "github.com/aptos-labs/aptos-go-sdk/bcs"
)

const FundAmount = 100_000_000
const TransferAmount = 1_000

// example Este ejemplo te muestra cómo hacer una transacción de transferencia de APT de la manera más simple posible
func example(networkConfig aptos.NetworkConfig) {
  // Crear un cliente para Aptos
  client, err := aptos.NewClient(networkConfig)
  if err != nil {
    panic("Failed to create client:" + err.Error())
  }

  // Crear cuentas localmente para alice y bob
  alice, err := aptos.NewEd25519Account()
  if err != nil {
    panic("Failed to create alice:" + err.Error())
  }
  bob, err := aptos.NewEd25519Account()
  if err != nil {
    panic("Failed to create bob:" + err.Error())
  }

  fmt.Printf("\n=== Direcciones ===\n")
  fmt.Printf("Alice: %s\n", alice.Address.String())
  fmt.Printf("Bob:%s\n", bob.Address.String())

  // Financiar al remitente con el faucet para crearlo en la cadena
  err = client.Fund(alice.Address, FundAmount)
  if err != nil {
    panic("Failed to fund alice:" + err.Error())
  }

  aliceBalance, err := client.AccountAPTBalance(alice.Address)
  if err != nil {
    panic("Failed to retrieve alice balance:" + err.Error())
  }
  bobBalance, err := client.AccountAPTBalance(bob.Address)
  if err != nil {
    panic("Failed to retrieve bob balance:" + err.Error())
  }
  fmt.Printf("\n=== Saldos Iniciales ===\n")
  fmt.Printf("Alice: %d\n", aliceBalance)
  fmt.Printf("Bob:%d\n", bobBalance)

  // 1. Construir transacción
  accountBytes, err := bcs.Serialize(&bob.Address)
  if err != nil {
    panic("Failed to serialize bob's address:" + err.Error())
  }

  amountBytes, err := bcs.SerializeU64(TransferAmount)
  if err != nil {
    panic("Failed to serialize transfer amount:" + err.Error())
  }
  rawTxn, err := client.BuildTransaction(alice.AccountAddress(), aptos.TransactionPayload{
    Payload: &aptos.EntryFunction{
      Module: aptos.ModuleId{
        Address: aptos.AccountOne,
        Name:    "aptos_account",
      },
      Function: "transfer",
      ArgTypes: []aptos.TypeTag{},
      Args: [][]byte{
        accountBytes,
        amountBytes,
      },
    }},
  )

  if err != nil {
    panic("Failed to build transaction:" + err.Error())
  }

  // 2. Simular transacción
  // Esto es útil para entender cuánto costará la transacción
  // y para asegurar que la transacción es válida antes de enviarla a la red
  // Esto es opcional, pero recomendado
  simulationResult, err := client.SimulateTransaction(rawTxn, alice)
  if err != nil {
    panic("Failed to simulate transaction:" + err.Error())
  }
  fmt.Printf("\n=== Simulación ===\n")
  fmt.Printf("Precio unitario de gas: %d\n", simulationResult[0].GasUnitPrice)
  fmt.Printf("Gas usado: %d\n", simulationResult[0].GasUsed)
  fmt.Printf("Comisión total de gas: %d\n", simulationResult[0].GasUsed*simulationResult[0].GasUnitPrice)
  fmt.Printf("Estado: %s\n", simulationResult[0].VmStatus)
}

func main() {
  example(aptos.DevnetConfig)
}

Mira aquí para ver el ejemplo completo de cómo construir, simular y enviar una transacción.

También puedes aprender cómo simular transacciones más avanzadas mirando las siguientes guías: