Sua Primeira Transação

Transações são a maneira fundamental de alterar dados no blockchain Aptos. Pense nelas como enviar um pacote: você precisa especificar o que está enviando, para quem está indo, e então rastrear até que a entrega seja confirmada. Em termos de blockchain, transações permitem transferir moedas, chamar funções de contratos inteligentes e atualizar estado on-chain.

Este tutorial irá guiá-lo através da criação e envio de sua primeira transação no blockchain Aptos. Você aprenderá como:

Configurar seu ambiente de desenvolvimento
Criar contas de teste e financiá-las
Construir uma transação para transferir moedas
Simular a transação para estimar custos
Assinar e enviar a transação
Verificar se a transação foi executada com sucesso

Antes de podermos criar transações, precisamos configurar nosso ambiente de desenvolvimento com as ferramentas e SDKs necessários.

Instalar o SDK TypeScript

Instale o SDK TypeScript usando seu gerenciador de pacotes preferido:
- npm
- yarn
- pnpm
Terminal window
npm install @aptos-labs/ts-sdk
Terminal window
yarn add @aptos-labs/ts-sdk
Terminal window
pnpm add @aptos-labs/ts-sdk
Criar um diretório de projeto

Crie um novo diretório para seu projeto:
Terminal window
```
mkdir minha-primeira-transacao
cd minha-primeira-transacao
```
Criar um novo arquivo

Crie um novo arquivo chamado transacao.ts:
- Mac/Linux
- Windows
Terminal window
touch transacao.ts
Terminal window
type nul > transacao.ts

Antes de podermos criar transações, precisamos configurar nosso ambiente de desenvolvimento com as ferramentas e SDKs necessários.

Instalar o SDK Python

Instale o SDK Python usando pip:
Terminal window
```
pip install aptos-sdk
```
Criar um diretório de projeto

Crie um novo diretório para seu projeto:
Terminal window
```
mkdir minha-primeira-transacao
cd minha-primeira-transacao
```
Criar um novo arquivo

Crie um novo arquivo chamado transacao.py:
- Mac/Linux
- Windows
Terminal window
touch transacao.py
Terminal window
type nul > transacao.py

2. Criando Contas de Teste

TypeScript
Python

No blockchain, todas as transações devem vir de uma conta. Vamos criar duas contas de teste: uma para enviar moedas (Alice) e uma para recebê-las (Bob).

Configurar o cliente

Primeiro, precisamos inicializar o cliente Aptos que se conectará ao blockchain. Abra transacao.ts no seu editor e adicione:
```
import {
  Account,
  Aptos,
  AptosConfig,
  Network,
} from "@aptos-labs/ts-sdk";

async function main() {
  // Inicializar o cliente Aptos
  const config = new AptosConfig({ network: Network.DEVNET });
  const aptos = new Aptos(config);

  console.log("Conectado ao devnet Aptos");

  // Mais código será adicionado aqui
}

main().catch(console.error);
```
Estamos nos conectando ao devnet Aptos, que é uma rede de teste onde você pode experimentar sem usar moedas reais. O devnet é resetado periodicamente, então não armazene nada importante lá. Você pode explorar o código fonte completo do SDK TypeScript no repositório aptos-ts-sdk.
Gerar contas

Adicione este código dentro da sua função main() para criar duas contas - Alice (remetente) e Bob (destinatário):
```
// Gerar duas contas
const alice = Account.generate();
const bob = Account.generate();

console.log("=== Endereços ===");
console.log(`Endereço da Alice: ${alice.accountAddress}`);
console.log(`Endereço do Bob: ${bob.accountAddress}`);
```
Cada conta tem um endereço único (como um número de conta bancária) e um par de chaves (como suas credenciais de login). O endereço é derivado da chave pública, enquanto a chave privada é mantida em segredo e usada para assinar transações. Para mais detalhes sobre como as contas funcionam no Aptos, veja Básicos de Conta.

Financiar as contas

Adicione este código após gerar as contas para obter moedas de teste do faucet:

// Financiar as contas com APT de teste do faucet devnet
console.log("\n=== Financiando contas ===");
await aptos.fundAccount({
  accountAddress: alice.accountAddress,
  amount: 100_000_000, // 1 APT = 100,000,000 octas
});
console.log("Contas financiadas com sucesso");

// Verificar saldos iniciais
const saldoAlice = await aptos.getAccountAPTAmount({
  accountAddress: alice.accountAddress,
});
const saldoBob = await aptos.getAccountAPTAmount({
  accountAddress: bob.accountAddress,
});

console.log(`Saldo da Alice: ${saldoAlice} octas`);
console.log(`Saldo do Bob: ${saldoBob} octas`);

No blockchain, todas as transações devem vir de uma conta. Vamos criar duas contas de teste: uma para enviar moedas (Alice) e uma para recebê-las (Bob).

import asyncio
from aptos_sdk.client import RestClient
from aptos_sdk.account import Account

async def main():
    # Inicializar o cliente Aptos
    client = RestClient("https://fullnode.devnet.aptoslabs.com/v1")

    # Gerar duas contas
    alice = Account.generate()
    bob = Account.generate()

    print("=== Endereços ===")
    print(f"Endereço da Alice: {alice.address()}")
    print(f"Endereço do Bob: {bob.address()}")

    # Financiar contas com faucet devnet
    print("\n=== Financiando contas ===")
    await client.fund_account(alice.address(), 100_000_000)
    print("Contas financiadas com sucesso")

if __name__ == "__main__":
    asyncio.run(main())

3. Construindo e Enviando a Transação

TypeScript
Python

Construir transação de transferência

Adicione o seguinte código à sua função main() para criar uma transação que transfere 1 APT da Alice para o Bob:

// Construir transação de transferência
console.log("\n=== Construindo transação ===");
const transacao = await aptos.transaction.build.simple({
  sender: alice.accountAddress,
  data: {
    function: "0x1::coin::transfer",
    typeArguments: ["0x1::aptos_coin::AptosCoin"],
    functionArguments: [bob.accountAddress, 100_000_000], // 1 APT
  },
});
console.log("Transação construída");

Simular a transação

Antes de enviar realmente, simule a transação para estimar taxas de gas:

// Simular a transação
console.log("\n=== Simulando transação ===");
const resultadoSimulacao = await aptos.transaction.simulate.simple({
  signerPublicKey: alice.publicKey,
  transaction: transacao,
});
console.log("Resultado da simulação:", resultadoSimulacao[0]);

Assinar e enviar a transação

// Assinar e enviar a transação
console.log("\n=== Enviando transação ===");
const transacaoConfirmada = await aptos.transaction.signAndSubmitTransaction({
  signer: alice,
  transaction: transacao,
});

console.log("Hash da transação:", transacaoConfirmada.hash);

// Aguardar confirmação da transação
const transacaoExecutada = await aptos.waitForTransaction({
  transactionHash: transacaoConfirmada.hash,
});
console.log("Transação executada:", transacaoExecutada.success);

# Construir e enviar transação de transferência
print("\n=== Enviando transação ===")

# Construir transação de transferência
transacao = {
    "function": "0x1::coin::transfer",
    "type_arguments": ["0x1::aptos_coin::AptosCoin"],
    "arguments": [str(bob.address()), "100000000"]  # 1 APT
}

# Enviar transação
txn_hash = await client.submit_transaction(alice, transacao)
print(f"Hash da transação: {txn_hash}")

# Aguardar confirmação da transação
await client.wait_for_transaction(txn_hash)
print("Transação confirmada!")

4. Verificando os Resultados

TypeScript
Python

Finalmente, vamos verificar os saldos após a transferência:

// Verificar saldos finais
console.log("\n=== Saldos finais ===");
const saldoFinalAlice = await aptos.getAccountAPTAmount({
  accountAddress: alice.accountAddress,
});
const saldoFinalBob = await aptos.getAccountAPTAmount({
  accountAddress: bob.accountAddress,
});

console.log(`Saldo final da Alice: ${saldoFinalAlice} octas`);
console.log(`Saldo final do Bob: ${saldoFinalBob} octas`);

# Verificar saldos finais
print("\n=== Saldos finais ===")
saldo_alice = await client.account_balance(alice.address())
saldo_bob = await client.account_balance(bob.address())

print(f"Saldo final da Alice: {saldo_alice} octas")
print(f"Saldo final do Bob: {saldo_bob} octas")

5. Executando o Código

TypeScript
Python

Execute o script no terminal:

npx ts-node transacao.ts

Ou compile TypeScript para JavaScript e execute:

npx tsc transacao.ts && node transacao.js

Execute o script no terminal:

python transacao.py

Exemplo de Código Completo

TypeScript
Python

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

async function main() {
  // Inicializar o cliente Aptos
  const config = new AptosConfig({ network: Network.DEVNET });
  const aptos = new Aptos(config);
  console.log("Conectado ao devnet Aptos");

  // Gerar duas contas
  const alice = Account.generate();
  const bob = Account.generate();
  console.log("=== Endereços ===");
  console.log(`Endereço da Alice: ${alice.accountAddress}`);
  console.log(`Endereço do Bob: ${bob.accountAddress}`);

  // Financiar contas
  console.log("\n=== Financiando contas ===");
  await aptos.fundAccount({
    accountAddress: alice.accountAddress,
    amount: 100_000_000,
  });
  console.log("Contas financiadas com sucesso");

  // Verificar saldo inicial
  const saldoAlice = await aptos.getAccountAPTAmount({
    accountAddress: alice.accountAddress,
  });
  console.log(`Saldo da Alice: ${saldoAlice} octas`);

  // Construir transação de transferência
  console.log("\n=== Construindo transação ===");
  const transacao = await aptos.transaction.build.simple({
    sender: alice.accountAddress,
    data: {
      function: "0x1::coin::transfer",
      typeArguments: ["0x1::aptos_coin::AptosCoin"],
      functionArguments: [bob.accountAddress, 100_000_000],
    },
  });

  // Assinar e enviar transação
  console.log("\n=== Enviando transação ===");
  const transacaoConfirmada = await aptos.transaction.signAndSubmitTransaction({
    signer: alice,
    transaction: transacao,
  });
  console.log("Hash da transação:", transacaoConfirmada.hash);

  // Aguardar confirmação da transação
  await aptos.waitForTransaction({
    transactionHash: transacaoConfirmada.hash,
  });

  // Verificar saldos finais
  console.log("\n=== Saldos finais ===");
  const saldoFinalAlice = await aptos.getAccountAPTAmount({
    accountAddress: alice.accountAddress,
  });
  const saldoFinalBob = await aptos.getAccountAPTAmount({
    accountAddress: bob.accountAddress,
  });
  console.log(`Saldo final da Alice: ${saldoFinalAlice} octas`);
  console.log(`Saldo final do Bob: ${saldoFinalBob} octas`);
}

main().catch(console.error);

import asyncio
from aptos_sdk.client import RestClient
from aptos_sdk.account import Account

async def main():
    # Inicializar o cliente Aptos
    client = RestClient("https://fullnode.devnet.aptoslabs.com/v1")

    # Gerar duas contas
    alice = Account.generate()
    bob = Account.generate()
    print("=== Endereços ===")
    print(f"Endereço da Alice: {alice.address()}")
    print(f"Endereço do Bob: {bob.address()}")

    # Financiar contas
    print("\n=== Financiando contas ===")
    await client.fund_account(alice.address(), 100_000_000)
    print("Contas financiadas com sucesso")

    # Enviar transação de transferência
    print("\n=== Enviando transação ===")
    transacao = {
        "function": "0x1::coin::transfer",
        "type_arguments": ["0x1::aptos_coin::AptosCoin"],
        "arguments": [str(bob.address()), "100000000"]
    }

    txn_hash = await client.submit_transaction(alice, transacao)
    print(f"Hash da transação: {txn_hash}")

    # Aguardar confirmação da transação
    await client.wait_for_transaction(txn_hash)
    print("Transação confirmada!")

    # Verificar saldos finais
    print("\n=== Saldos finais ===")
    saldo_alice = await client.account_balance(alice.address())
    saldo_bob = await client.account_balance(bob.address())
    print(f"Saldo final da Alice: {saldo_alice} octas")
    print(f"Saldo final do Bob: {saldo_bob} octas")

if __name__ == "__main__":
    asyncio.run(main())

Próximos Passos

Parabéns! Você criou e enviou com sucesso sua primeira transação Aptos. A seguir, experimente:

Seu Primeiro Módulo Move - Crie seu próprio contrato inteligente
Indexador Aptos - Consulte dados on-chain
Construindo um dApp Completo - Construa uma aplicação completa