Your First Transaction

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

touch transaction.ts

pip install aptos-sdk

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

touch transaction.py

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);

// 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}`);

// Fund the accounts
console.log("\n=== Funding accounts ===");
await aptos.fundAccount({
  accountAddress: alice.accountAddress,
  amount: 100_000_000, // 1 APT = 100,000,000 octas
});
await aptos.fundAccount({
  accountAddress: bob.accountAddress,
  amount: 0, // Bob starts with 0 APT
});
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`);

npx ts-node transaction.ts

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

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())

# 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()}")

# Fund the accounts
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)
await faucet_client.fund_account(bob.address(), bob_amount)
print("Accounts 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")

python transaction.py

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. 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()}`);

# 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)}")

// 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"}`);

# 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'}")

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

// 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}`);

# 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

# 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}")

// 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}`);

// 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)`);

npx ts-node transaction.ts

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)

# 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}")

# 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)")

python transaction.py

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)