Registra tu Wallet y Crea Transacciones con el SDK de TypeScript

En la sección anterior, creaste y guardaste un wallet en disco (.ukey).

En esta sección, aprenderás a:

1. Cargar ese wallet desde un archivo .ukey.
2. Abrir una sesión de transacción contra un node de ULedger.
3. Usar esa sesión para:
   • registrar el wallet en la cadena (CREATE_WALLET),
   • y luego enviar transacciones DATA usando el mismo wallet.

Conceptualmente:

• Registrar wallet = crear tu identidad en la cadena (CREATE_WALLET).
• Transacciones de datos = escribir datos en la cadena (DATA).

---

1. Requisitos previos

Antes de comenzar, deberías tener:

• Un node de ULedger en ejecución (o acceso a nodes de desarrollo).
• Un archivo wallet creado en la guía anterior (p. ej. ./wallets/my_wallet.ukey).
• Un archivo de configuración con los endpoints de los nodes.

Ejemplo de config.json:

{
  "nodeEndpoints": [
    "https://tn-w-1.uledger.net/",
    "https://my.node2.uledger.io",
    "https://my.node3.uledger.io"
  ],
  "verbose": true
}

---

2. Cargar configuración y wallet

import fs from "node:fs";
import { getULedgerSDK } from "@uledgerinc/typescript-sdk";

type Config = {
  nodeEndpoints: string[];
  verbose?: boolean;
};

function loadConfig(path: string): Config {
  const raw = fs.readFileSync(path, "utf8");
  const cfg = JSON.parse(raw) as Config;

  if (!cfg.nodeEndpoints?.length) {
    throw new Error("config must contain at least one node endpoint");
  }

  return cfg;
}

async function loadWalletFromFile(walletPath: string, password = "") {
  const sdk = await getULedgerSDK();
  const raw = fs.readFileSync(walletPath, "utf8");
  const wallet = sdk.walletFromJson(raw, password);
  return { sdk, wallet };
}

---

3. Crear una sesión de transacción

Un TransactionSession se conecta a un endpoint de node, obtiene información de salud/cadena y almacena el ID del node como el suggestor.

Usa el helper del SDK:

• sdk.createSession(nodeEndpoint, wallet)

function pickRandom<T>(items: T[]): T {
  return items[Math.floor(Math.random() * items.length)];
}

async function newRandomSession(params: {
  sdk: any;
  nodeEndpoints: string[];
  wallet: any;
}) {
  const { sdk, nodeEndpoints, wallet } = params;

  const nodeEndpoint = pickRandom(nodeEndpoints);
  const session = await sdk.createSession(nodeEndpoint, wallet);

  console.log("Using node:", session.getNodeEndpoint());
  console.log("Suggestor (nodeId):", session.getSuggestor());

  return session;
}

---

4. Registrar tu wallet (registerWallet)

Antes de que un wallet pueda participar en las reglas de la cadena, generalmente debe ser creado en ella.

La sesión expone un helper de alto nivel:

• session.registerWallet(blockchainId, walletToRegister?, customAuthGroups?)

Si omites walletToRegister, registra el wallet de la sesión (auto-registro).

import { DEFAULT_ADMIN_AUTH_GROUP } from "@uledgerinc/typescript-sdk";

async function registerWallet(params: {
  session: any;
  blockchainId: string;
}) {
  const { session, blockchainId } = params;

  const tx = await session.registerWallet(
    blockchainId,
    undefined,                 // omit to self-register the session wallet
    DEFAULT_ADMIN_AUTH_GROUP,  // optional: defaults to admin full permissions
  );

  console.log("CREATE_WALLET txId:", tx.transactionId);
  console.log("status:", tx.status);
  console.log("output:", tx.output);

  return tx;
}

---

5. Enviar transacciones DATA (submitData)

Una vez que el wallet está registrado, puedes enviar transacciones de datos.

Usa:

• session.submitData({ blockchainId, to, data })

data puede ser una cadena de texto o un objeto.

async function sendDataTransaction(params: {
  session: any;
  blockchainId: string;
  to: string;
  data: string | object;
}) {
  const { session, blockchainId, to, data } = params;

  const tx = await session.submitData({
    blockchainId,
    to,
    data,
  });

  console.log("DATA txId:", tx.transactionId);
  console.log("status:", tx.status);
  console.log("output:", tx.output);
  console.log("payloadRoot:", tx.payloadRoot);

  return tx;
}

---

6. Todo junto

Este programa:

1. Carga la configuración y el wallet.
2. Crea una sesión.
3. Registra el wallet (CREATE_WALLET).
4. Envía algunas transacciones DATA.

import fs from "node:fs";
import { getULedgerSDK } from "@uledgerinc/typescript-sdk";

function pickRandom<T>(items: T[]): T {
  return items[Math.floor(Math.random() * items.length)];
}

async function main() {
  const configPath = "config.json";
  const walletPath = "./wallets/my_wallet.ukey";
  const password = "";
  const blockchainId = "your-blockchain-id-here";
  const txCount = 3;

  const cfg = JSON.parse(fs.readFileSync(configPath, "utf8")) as {
    nodeEndpoints: string[];
  };
  if (!cfg.nodeEndpoints?.length) throw new Error("Missing nodeEndpoints in config.json");

  const sdk = await getULedgerSDK();

  const walletJson = fs.readFileSync(walletPath, "utf8");
  const wallet = sdk.walletFromJson(walletJson, password);

  const nodeEndpoint = pickRandom(cfg.nodeEndpoints);
  const session = await sdk.createSession(nodeEndpoint, wallet);

  console.log("Using node:", session.getNodeEndpoint());
  console.log("Suggestor (nodeId):", session.getSuggestor());

  // 1) Register wallet (one-time per wallet/chain)
  const regTx = await session.registerWallet(blockchainId);
  console.log("Registered wallet tx:", regTx.transactionId, regTx.status, regTx.output);

  // 2) Send DATA transactions
  for (let i = 0; i < txCount; i++) {
    const tx = await session.submitData({
      blockchainId,
      to: wallet.address,
      data: { message: `hello from ${wallet.address}`, index: i + 1 },
    });

    console.log("DATA tx:", tx.transactionId, tx.status, tx.output, tx.payloadRoot);
  }
}

main().catch(console.error);

---

Notas

• registerWallet(...) crea una transacción CREATE_WALLET internamente.
• submitData(...) envía una transacción DATA y serializa los objetos automáticamente.