Saltar al contenido principal

Crear una cuenta

_Antes de comenzar a trabajar con Stellar en código, considera revisar los siguientes ejemplos usando el Stellar Lab. El laboratorio te permite crear cuentas, financiar cuentas en la red de prueba Stellar, desarrollar transacciones, ejecutar cualquier operación e inspeccionar respuestas desde Horizon a través del Explorador de Endpoints.

Las cuentas son un componente fundamental de Stellar: contienen todos tus saldos, te permiten enviar y recibir pagos, y hacer ofertas para comprar y vender activos. Dado que prácticamente todo en Stellar está vinculado a una cuenta, lo primero que generalmente necesitas hacer al comenzar a desarrollar es crear una. Este tutorial para principiantes explica los tres bloques fundamentales que necesitarás: generar claves, financiar una cuenta y consultar saldos.

Crear un par de llaves​

Stellar usa criptografía de clave pública para asegurar cada transacción: cada cuenta Stellar tiene un par de claves formado por una clave pública y una clave secreta. La clave pública siempre es segura para compartir: otras personas la necesitan para identificar tu cuenta y verificar que autorizaste una transacción. Es como una dirección de correo electrónico. Sin embargo, la clave secreta es información privada que prueba que eres el dueño y te da acceso a tu cuenta. Es como una contraseña, y nunca deberías compartirla con nadie.

Antes de crear una cuenta, necesitas generar tu propio par de claves; aprenderemos cómo hacerlo en el ejemplo completo, más abajo.

Crear una cuenta​

Un par de claves válido por sí solo no constituye una cuenta. Para evitar que las entradas no usadas inflen el ledger, Stellar requiere que cada cuenta mantenga un saldo mínimo de 1 XLM antes de que realmente exista.

En la red de prueba, puedes pedirle a Friendbot — un servicio amable de financiación — que cree y financie la cuenta por ti. En los ejemplos del SDK, abajo, verás que "descubrimos" el endpoint de Friendbot mediante la llamada getNetwork del RPC, y luego enviamos una solicitud de financiación.

En la red pública, las cosas son un poco diferentes. Adquirirías lumens en un exchange o harías que alguien cree o patrocine una cuenta en tu nombre. Este es el propósito de la operación CreateAccount. Veremos en los ejemplos posteriores que dada una cuenta financiada, luego puedes crear una cuenta secundaria en la red con un saldo inicial.

Consultar saldos​

Una vez que tus cuentas existan, puedes consultar su estado. En Stellar, los activos pueden mantenerse en varias formas diferentes:

  • tu saldo nativo es la cantidad de XLM que posees, el cual está asociado directamente a tu cuenta
  • también puedes establecer trustlines a diversos activos para mantener saldo; estos pueden obtenerse tanto mediante operaciones de pago simples como interacciones con contratos inteligentes
  • finalmente, puedes mantener tokens personalizados de contratos inteligentes, que son activos no estándar

Aprenderás sobre estos en tutoriales posteriores.

Ejemplo completo​

Combinemos estos cuatro conceptos en un ejemplo único y coherente. Ten en cuenta que siempre verás tu saldo de USDC como cero, ya que en realidad no recibimos ninguno, pero será útil en el futuro cuando poseas más que solo el token nativo.

Para cada uno de estos, asegúrate de seguir las instrucciones de instalación y configuración correspondientes a cada SDK desde su documentación.

import {
  Keypair,
  BASE_FEE,
  Networks,
  Operation,
  Asset,
  humanizeEvents,
  TransactionBuilder,
} from "@stellar/stellar-sdk";
import { Server } from "@stellar/stellar-sdk/rpc";

// See https://developers.stellar.org/docs/data/apis/rpc/providers
const server = new Server("https://soroban-testnet.stellar.org");

const testnetUsdc = new Asset(
  "USDC",
  "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5",
);

async function main() {
  //
  // Generating keypairs
  //
  const parent = Keypair.random();
  console.log("Secret:", parent.secret());
  console.log("Public:", parent.publicKey());

  //
  // Account creation via friendbot (does not work on mainnet)
  //
  const friendbotResponse = await server.requestAirdrop(parent.publicKey());
  console.log("SUCCESS! You have a new account:\n", friendbotResponse);

  const parentAccount = await server.getAccount(parent.publicKey());
  const childAccount = Keypair.random();

  //
  // Account creation via the CreateAccount operation
  //
  const createAccountTx = new TransactionBuilder(parentAccount, {
    fee: BASE_FEE,
    networkPassphrase: Networks.TESTNET,
  })
    .addOperation(
      Operation.createAccount({
        destination: childAccount.publicKey(),
        startingBalance: "5",
      }),
    )
    .addOperation(Operation.changeTrust({ asset: testnetUsdc }))
    .setTimeout(180)
    .build();

  createAccountTx.sign(parent);

  const sendTxResponse = await server.sendTransaction(createAccountTx);
  if (sendTxResponse.status !== "PENDING") {
    console.log(`There was an error: ${JSON.stringify(sendTxResponse)}`);
    throw sendTxResponse;
  }

  const txResponse = await server.pollTransaction(sendTxResponse.hash);
  if (txResponse.status !== "SUCCESS") {
    console.log(
      `Transaction status: ${txResponse.status}, events: ${humanizeEvents(
        txResponse.diagnosticEvents,
      )}`,
    );
  }

  console.log("Created the new account", childAccount.publicKey());

  //
  // Fetching native and USDC balances
  //
  const accountEntry = await server.getAccountEntry(parent.publicKey());
  console.log("Balance for account: " + parent.publicKey());
  console.log("XLM:", accountEntry.balance().toString());

  const trustlineEntry = await server.getTrustline(
    parent.publicKey(),
    testnetUsdc,
  );
  console.log("USDC:", trustlineEntry.balance().toString());
}

main().catch((err) => console.error(err));

Ahora que tienes una cuenta y puedes revisar los saldos de sus activos, puedes comenzar a enviar y recibir pagos o, si estás listo para concentrarte, puedes avanzar y desarrollar un monedero o emitir un activo Stellar.

Guías en esta categoría: