Tu Primera Transacción

Before we can create transactions, we need to set up our development environment with the necessary tools and SDKs.

1. Install the TypeScript SDK

   Install the TypeScript SDK using your preferred package manager:

   • npm
   • yarn
   • pnpm

   npm install @aptos-labs/ts-sdk

2. Create a project directory

   Create a new directory for your project:

   mkdir my-first-transaction
   cd my-first-transaction

3. Create a new file

   Create a new file named transaction.ts:

   • Mac/Linux
   • Windows

   touch transaction.ts

Before we can create transactions, we need to set up our development environment with the necessary tools and SDKs.

1. Install the Python SDK

   Install the Python SDK using pip:

   pip install aptos-sdk

2. Create a project directory

   Create a new directory for your project:

   mkdir my-first-transaction
   cd my-first-transaction

3. Create a new file

   Create a new file named transaction.py:

   • Mac/Linux
   • Windows

   touch transaction.py

In blockchain, all transactions must come from an account. Let’s create two test accounts: one to send coins (Alice) and one to receive them (Bob).

1. Set up the client

   First, we need to initialize the Aptos client that will connect to the blockchain. Open transaction.ts in your editor and add:

   import {
     Account,
     Aptos,
     AptosConfig,
     Network,
   } from "@aptos-labs/ts-sdk";
   
   async function main() {
     // Initialize the Aptos client
     const config = new AptosConfig({ network: Network.DEVNET });
     const aptos = new Aptos(config);
   
     console.log("Connected to Aptos devnet");
   
     // More code will go here
   }
   
   main().catch(console.error);

2. Generate accounts

   Add this code inside your main() function to create two accounts - Alice (sender) and Bob (receiver):

   // Generate two accounts
   const alice = Account.generate();
   const bob = Account.generate();
   
   console.log("=== Addresses ===");
   console.log(`Alice's address: ${alice.accountAddress}`);
   console.log(`Bob's address: ${bob.accountAddress}`);

3. Fund the accounts

   Add this code after generating the accounts to get test coins from the faucet:

   // Fund the accounts with test APT from the devnet faucet
   console.log("\n=== Funding accounts ===");
   await aptos.fundAccount({
     accountAddress: alice.accountAddress,
     amount: 100_000_000, // 1 APT = 100,000,000 octas
   });
   console.log("Accounts funded successfully");
   
   // Check initial balances
   const aliceBalance = await aptos.getAccountAPTAmount({
     accountAddress: alice.accountAddress,
   });
   const bobBalance = await aptos.getAccountAPTAmount({
     accountAddress: bob.accountAddress,
   });
   
   console.log("\n=== Initial Balances ===");
   console.log(`Alice: ${aliceBalance} octas`);
   console.log(`Bob: ${bobBalance} octas`);

4. Run the code

   Let’s test our code so far:

   npx ts-node transaction.ts

   You should see output similar to:

   Connected to Aptos devnet
   === Addresses ===
   Alice's address: 0x978c213990c4833df71548df7ce49d54c759d6b6d932de22b24d56060b7af2aa
   Bob's address: 0x7af2d6c93a2feafc9b69b5e8ad9d6b513b260f62f23f3a384a3a2e4a84694a9b
   
   === Funding accounts ===
   Accounts funded successfully
   
   === Initial Balances ===
   Alice: 100000000 octas
   Bob: 0 octas

In blockchain, all transactions must come from an account. Let’s create two test accounts: one to send coins (Alice) and one to receive them (Bob).

1. Set up the client

   First, we need to initialize the Aptos client that will connect to the blockchain. Open transaction.py in your editor and add:

   import asyncio
   from aptos_sdk.account import Account
   from aptos_sdk.async_client import FaucetClient, RestClient
   from aptos_sdk.transactions import EntryFunction, TransactionPayload, TransactionArgument, RawTransaction
   from aptos_sdk.bcs import Serializer
   import time
   
   # Network configuration
   NODE_URL = "https://fullnode.devnet.aptoslabs.com/v1"
   FAUCET_URL = "https://faucet.devnet.aptoslabs.com"
   
   async def main():
       # Initialize the clients
       rest_client = RestClient(NODE_URL)
       faucet_client = FaucetClient(FAUCET_URL, rest_client)
   
       print("Connected to Aptos devnet")
   
       # More code will go here
   
   if __name__ == "__main__":
       asyncio.run(main())

2. Generate accounts

   Add this code inside your main() function to create two accounts - Alice (sender) and Bob (receiver):

   # Generate two accounts
   alice = Account.generate()
   bob = Account.generate()
   
   print("=== Addresses ===")
   print(f"Alice's address: {alice.address()}")
   print(f"Bob's address: {bob.address()}")

3. Fund the accounts

   Add this code after generating the accounts to get test coins from the faucet:

   # Fund the accounts with test APT from the devnet faucet
   print("\n=== Funding accounts ===")
   alice_amount = 100_000_000  # 1 APT = 100,000,000 octas
   bob_amount = 0  # Bob starts with 0 APT
   
   await faucet_client.fund_account(alice.address(), alice_amount)
   print("Account funded successfully")
   
   # Check initial balances
   alice_balance = await rest_client.account_balance(alice.address())
   bob_balance = await rest_client.account_balance(bob.address())
   
   print("\n=== Initial Balances ===")
   print(f"Alice: {alice_balance} octas")
   print(f"Bob: {bob_balance} octas")

4. Run the code

   Let’s test our code so far:

   python transaction.py

   You should see output similar to:

   Connected to Aptos devnet
   === Addresses ===
   Alice's address: 0x978c213990c4833df71548df7ce49d54c759d6b6d932de22b24d56060b7af2aa
   Bob's address: 0x7af2d6c93a2feafc9b69b5e8ad9d6b513b260f62f23f3a384a3a2e4a84694a9b
   
   === Funding accounts ===
   Accounts funded successfully
   
   === Initial Balances ===
   Alice: 100000000 octas
   Bob: 0 octas

Now that we have funded accounts, let’s create a transaction to transfer coins from Alice to Bob. This is like filling out a form specifying what you want to send and to whom.

1. Understand transaction structure

   A transaction in Aptos has several key components:

   1. Sender: The account initiating the transaction (Alice)
   2. Function: The on-chain function to call (in this case, a coin transfer)
   3. Arguments: Data needed by the function (recipient address and amount)
   4. Gas parameters: Maximum gas amount and gas unit price
   5. Expiration time: When the transaction is no longer valid if not executed
   6. Sequence number: A counter that prevents replay attacks

2. Build the transaction

   Let’s add code to build a transaction that transfers 1000 octas from Alice to Bob:

   Add this code to your main() function:

   // 1. Build the transaction
   console.log("\n=== 1. Building the transaction ===");
   const transaction = await aptos.transaction.build.simple({
     sender: alice.accountAddress,
     data: {
       function: "0x1::aptos_account::transfer",
       functionArguments: [bob.accountAddress, 1000], // Transfer 1000 octas
     },
   });
   console.log("Transaction built successfully");
   
   // Access transaction details from the raw transaction
   const rawTxn = transaction.rawTransaction;
   console.log(`Sender: ${rawTxn.sender}`);
   console.log(`Sequence Number: ${rawTxn.sequence_number}`);
   console.log(`Max Gas Amount: ${rawTxn.max_gas_amount}`);
   console.log(`Gas Unit Price: ${rawTxn.gas_unit_price}`);
   console.log(`Expiration Timestamp: ${new Date(Number(rawTxn.expiration_timestamp_secs) * 1000).toISOString()}`);

Now that we have funded accounts, let’s create a transaction to transfer coins from Alice to Bob. This is like filling out a form specifying what you want to send and to whom.

1. Understand transaction structure

   A transaction in Aptos has several key components:

   1. Sender: The account initiating the transaction (Alice)
   2. Function: The on-chain function to call (in this case, a coin transfer)
   3. Arguments: Data needed by the function (recipient address and amount)
   4. Gas parameters: Maximum gas amount and gas unit price
   5. Expiration time: When the transaction is no longer valid if not executed
   6. Sequence number: A counter that prevents replay attacks

2. Build the transaction

   Add the following code to your main() function to build a transaction that transfers 1000 octas from Alice to Bob:

   # 1. Build the transaction
   print("\n=== 1. Building the transaction ===")
   
   # Create the entry function payload
   # This specifies which function to call and with what arguments
   entry_function = EntryFunction.natural(
       "0x1::aptos_account",  # Module address and name
       "transfer",            # Function name
       [],                    # Type arguments (empty for this function)
       [
           # Function arguments with their serialization type
           TransactionArgument(bob.address(), Serializer.struct),  # Recipient address
           TransactionArgument(1000, Serializer.u64),              # Amount to transfer (1000 octas)
       ],
   )
   
   # Get the chain ID for the transaction
   chain_id = await rest_client.chain_id()
   
   # Get the sender's current sequence number
   account_data = await rest_client.account(alice.address())
   sequence_number = int(account_data["sequence_number"])
   
   # Create the raw transaction with all required fields
   raw_transaction = RawTransaction(
       sender=alice.address(),                                    # Sender's address
       sequence_number=sequence_number,                           # Sequence number to prevent replay attacks
       payload=TransactionPayload(entry_function),                # The function to call
       max_gas_amount=2000,                                       # Maximum gas units to use
       gas_unit_price=100,                                        # Price per gas unit in octas
       expiration_timestamps_secs=int(time.time()) + 600,         # Expires in 10 minutes
       chain_id=chain_id,                                         # Chain ID to ensure correct network
   )
   
   print("Transaction built successfully")
   print(f"Sender: {raw_transaction.sender}")
   print(f"Sequence Number: {raw_transaction.sequence_number}")
   print(f"Max Gas Amount: {raw_transaction.max_gas_amount}")
   print(f"Gas Unit Price: {raw_transaction.gas_unit_price}")
   print(f"Expiration Timestamp: {time.ctime(raw_transaction.expiration_timestamps_secs)}")

Before submitting a transaction, it’s wise to simulate it first to estimate the gas cost. This is like checking shipping costs before sending a package.

1. Simulate the transaction

   Add this code after building the transaction:

   // 2. Simulate the transaction
   console.log("\n=== 2. Simulating the transaction ===");
   const [simulationResult] = await aptos.transaction.simulate.simple({
     signerPublicKey: alice.publicKey,
     transaction,
   });
   
   const gasUsed = parseInt(simulationResult.gas_used);
   const gasUnitPrice = parseInt(simulationResult.gas_unit_price);
   console.log(`Estimated gas units: ${gasUsed}`);
   console.log(`Estimated gas cost: ${gasUsed * gasUnitPrice} octas`);
   console.log(`Transaction would ${simulationResult.success ? "succeed" : "fail"}`);

Before submitting a transaction, it’s wise to simulate it first to estimate the gas cost. This is like checking shipping costs before sending a package.

1. Simulate the transaction

   Add this code after building the transaction:

   # 2. Simulate the transaction
   print("\n=== 2. Simulating the transaction ===")
   
   # Create a BCS transaction for simulation
   # This doesn't actually submit the transaction to the blockchain
   simulation_transaction = await rest_client.create_bcs_transaction(alice, TransactionPayload(entry_function))
   
   # Simulate the transaction to estimate gas costs and check for errors
   simulation_result = await rest_client.simulate_transaction(simulation_transaction, alice)
   
   # Extract and display the simulation results
   gas_used = int(simulation_result[0]['gas_used'])
   gas_unit_price = int(simulation_result[0]['gas_unit_price'])
   success = simulation_result[0]['success']
   
   print(f"Estimated gas units: {gas_used}")
   print(f"Estimated gas cost: {gas_used * gas_unit_price} octas")
   print(f"Transaction would {'succeed' if success else 'fail'}")

Now that we’ve built and simulated the transaction, we need to sign it with Alice’s private key and submit it to the blockchain.

1. Sign the transaction

   Signing proves that Alice authorized this transaction:

   Add this code after simulating the transaction:

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

2. Submit the transaction

   Add this code after signing the transaction to submit the signed transaction to the blockchain:

   // 4. Submit the transaction
   console.log("\n=== 4. Submitting the transaction ===");
   const pendingTransaction = await aptos.transaction.submit.simple({
     transaction,
     senderAuthenticator,
   });
   console.log(`Transaction submitted with hash: ${pendingTransaction.hash}`);

Now that we’ve built and simulated the transaction, we need to sign it with Alice’s private key and submit it to the blockchain.

1. Sign the transaction

   Signing proves that Alice authorized this transaction:

   Add this code after simulating the transaction:

   # 3. Sign the transaction
   print("\n=== 3. Signing the transaction ===")
   
   # Sign the raw transaction with the sender's private key
   # This creates a cryptographic signature that proves the sender authorized this transaction
   signed_transaction = await rest_client.create_bcs_signed_transaction(
       alice,                           # Account with the private key
       TransactionPayload(entry_function),  # The payload from our transaction
       sequence_number=sequence_number  # Use the same sequence number as before
   )
   
   print("Transaction signed successfully")
   # We can't easily extract the signature from the signed transaction object,
   # but we can confirm it was created

2. Submit the transaction

   Add this code after signing the transaction to submit the signed transaction to the blockchain:

   # 4. Submit the transaction
   print("\n=== 4. Submitting the transaction ===")
   
   # Submit the signed transaction to the blockchain
   # This broadcasts the transaction to the network for processing
   tx_hash = await rest_client.submit_bcs_transaction(signed_transaction)
   
   print(f"Transaction submitted with hash: {tx_hash}")

After submitting a transaction, we need to wait for it to be processed by the blockchain. This is like waiting for a package to be delivered.

1. Wait for transaction completion

   Add this code after submitting the transaction:

   // 5. Wait for the transaction to complete
   console.log("\n=== 5. Waiting for transaction completion ===");
   const txnResult = await aptos.waitForTransaction({
     transactionHash: pendingTransaction.hash,
   });
   console.log(`Transaction completed with status: ${txnResult.success ? "SUCCESS" : "FAILURE"}`);
   
   // If you want to see more details about the transaction:
   console.log(`VM Status: ${txnResult.vm_status}`);
   console.log(`Gas used: ${txnResult.gas_used}`);

2. Verify the results

   Add this code after waiting for the transaction to check the balances and confirm the transfer worked:

   // Check final balances
   const aliceFinalBalance = await aptos.getAccountAPTAmount({
     accountAddress: alice.accountAddress,
   });
   const bobFinalBalance = await aptos.getAccountAPTAmount({
     accountAddress: bob.accountAddress,
   });
   
   console.log("\n=== Final Balances ===");
   console.log(`Alice: ${aliceFinalBalance} octas (spent ${aliceBalance - aliceFinalBalance} octas on transfer and gas)`);
   console.log(`Bob: ${bobFinalBalance} octas (received 1000 octas)`);

3. Run the complete code

   npx ts-node transaction.ts

   You should see output similar to:

   Connected to Aptos devnet
   === Addresses ===
   Alice's address: 0x978c213990c4833df71548df7ce49d54c759d6b6d932de22b24d56060b7af2aa
   Bob's address: 0x7af2d6c93a2feafc9b69b5e8ad9d6b513b260f62f23f3a384a3a2e4a84694a9b
   
   === Funding accounts ===
   Accounts funded successfully
   
   === Initial Balances ===
   Alice: 100000000 octas
   Bob: 0 octas
   
   === 1. Building the transaction ===
   Transaction built successfully
   Sender: 0x978c213990c4833df71548df7ce49d54c759d6b6d932de22b24d56060b7af2aa
   Sequence Number: 0
   Max Gas Amount: 20000
   Gas Unit Price: 100
   Expiration Timestamp: 2025-03-05T22:59:21.000Z
   
   === 2. Simulating the transaction ===
   Estimated gas units: 146
   Estimated gas cost: 14600 octas
   Transaction would succeed
   
   === 3. Signing the transaction ===
   Transaction signed successfully
   
   === 4. Submitting the transaction ===
   Transaction submitted with hash: 0x3a8a3e34a1c64ad9d7636a3a827b7ec3bb12d73825b36fa06d425c5a3b42cccc
   
   === 5. Waiting for transaction completion ===
   Transaction completed with status: SUCCESS
   VM Status: Executed successfully
   Gas used: 146
   
   === Final Balances ===
   Alice: 99984400 octas (spent 15600 octas on transfer and gas)
   Bob: 1000 octas (received 1000 octas)

After submitting a transaction, we need to wait for it to be processed by the blockchain. This is like waiting for a package to be delivered.

1. Wait for transaction completion

   Add this code after submitting the transaction:

   # 5. Wait for the transaction to complete
   print("\n=== 5. Waiting for transaction completion ===")
   
   # Wait for the transaction to be processed by the blockchain
   # This polls the blockchain until the transaction is confirmed
   await rest_client.wait_for_transaction(tx_hash)
   
   # Get the transaction details to check its status
   transaction_details = await rest_client.transaction_by_hash(tx_hash)
   success = transaction_details["success"]
   vm_status = transaction_details["vm_status"]
   gas_used = transaction_details["gas_used"]
   
   print(f"Transaction completed with status: {'SUCCESS' if success else 'FAILURE'}")
   print(f"VM Status: {vm_status}")
   print(f"Gas used: {gas_used}")

2. Verify the results

   Add this code after waiting for the transaction to check the balances and confirm the transfer worked:

   # Check final balances
   alice_final_balance = await rest_client.account_balance(alice.address())
   bob_final_balance = await rest_client.account_balance(bob.address())
   
   print("\n=== Final Balances ===")
   print(f"Alice: {alice_final_balance} octas (spent {alice_balance - alice_final_balance} octas on transfer and gas)")
   print(f"Bob: {bob_final_balance} octas (received 1000 octas)")

3. Run the complete code

   python transaction.py

   You should see output similar to:

   Connected to Aptos devnet
   === Addresses ===
   Alice's address: 0x978c213990c4833df71548df7ce49d54c759d6b6d932de22b24d56060b7af2aa
   Bob's address: 0x7af2d6c93a2feafc9b69b5e8ad9d6b513b260f62f23f3a384a3a2e4a84694a9b
   
   === Funding accounts ===
   Accounts funded successfully
   
   === Initial Balances ===
   Alice: 100000000 octas
   Bob: 0 octas
   
   === 1. Building the transaction ===
   Transaction built successfully
   Sender: 0x978c213990c4833df71548df7ce49d54c759d6b6d932de22b24d56060b7af2aa
   Sequence Number: 0
   Max Gas Amount: 2000
   Gas Unit Price: 100
   Expiration Timestamp: Wed Mar 05 22:59:21 2025
   
   === 2. Simulating the transaction ===
   Estimated gas units: 146
   Estimated gas cost: 14600 octas
   Transaction would succeed
   
   === 3. Signing the transaction ===
   Transaction signed successfully
   
   === 4. Submitting the transaction ===
   === 3. Signing the transaction ===
   Transaction signed successfully
   
   === 4. Submitting the transaction ===
   Transaction submitted with hash: 0x3a8a3e34a1c64ad9d7636a3a827b7ec3bb12d73825b36fa06d425c5a3b42cccc
   
   === 5. Waiting for transaction completion ===
   Transaction completed with status: SUCCESS
   VM Status: Executed successfully
   Gas used: 146
   
   === Final Balances ===
   Alice: 99984400 octas (spent 15600 octas on transfer and gas)
   Bob: 1000 octas (received 1000 octas)