Guía Rápida del SDK

import { LedgerSdk } from '@minka/ledger-sdk';

const sdk = new LedgerSdk({
    // Identificador del ledger a utilizar
    ledger: 'kamin-stg',

    // Servidor al cual conectarse, sin la barra al final
    server: 'https://ldg-stg.one/v2',

    // Opcional, tiempo de espera en milisegundos. Por defecto es 15000
    timeout: 15000,

    // Opcional, verificar automáticamente las respuestas del servidor. Esto significa que
    // el SDK realizará validaciones de todas las pruebas en los registros usando la clave pública del Ledger
    verifyResponseProofs: true,

    // Opcional, clave pública utilizada para verificar las respuestas del servidor
    signer: {
        format: 'ed25519-raw', // Único formato soportado por ahora
        public: '<clave pública del ledger>',
    },

    // Opcional, valores por defecto para la autenticación con JWT
    secure: {
        iss: '<emisor del jwt>', // identificador del firmante o clave pública
        sub: '<sujeto del jwt>', // signer:<handle>, bridge:<handle>, ...
        aud: '<audiencia objetivo del jwt>', // identificador del ledger o clave pública
        exp: 60, // Tiempo de expiración del token, en segundos
        keyPair: {
            format: 'ed25519-raw',
            public: '<clave pública>',
            secret: '<clave secreta>',
        },
    },
});

const { wallet } = await sdk.wallet.read('kamin.one');
// Salida: Datos de la billetera `kamin.one`

const { balances } = await sdk.wallet.getBalances('kamin.one');
// Salida: Arreglo vacío, sin saldos por ahora

const claim = {
    action: 'transfer',
    source: 'kamin.one',
    target: 'rail',
    symbol: 'cop',
    amount: 1000000, // Equivale a 100000.00$, porque cop tiene un factor de 100
};

await sdk.intent
    .init()
    .data({
        handle: sdk.handle.unique(), // devuelve un identificador único aleatorio
        claims: [claim],
        access: getOwnerAccessRules(keyPair.public),
    })
    .hash()
    .sign([{ keyPair }])
    .send();

const { balances } = await sdk.wallet.getBalances('kamin.one');
// Salida: [ { wallet: 'kamin.one', symbol: 'cop', amount: 10000 } ]

const { response } = await sdk.intent.read('<intent-handle>');
await sdk.intent
    .from(response.data)
    .hash()
    .sign([
        {
            keyPair,
            custom: {
                // Datos personalizados opcionales para la firma
                status: 'prepared',
            },
        },
    ])
    .send();

const { response } = await sdk.intent.read('<intent-handle>');
const record = response.data;

const verifier = sdk.proofs;

// Se puede agregar aserciones al cliente de verifiación
verifier
    .length(1) // Al menos 1 prueba presente, es el valor por defecto
    .length(2, 3) // Al menos 2 pruebas, pero menos de 3
    // Al menos una prueba realizada con el firmante configurado en el SDK
    .ledger()
    // Al menos una prueba que coincida parcialmente con el objeto
    .expect({ custom: { status: 'prepared' } });

// El método de verificación revia todas las aserciones del registro.
// También verifica que todas las proofs sean validas.
await verifier.verify(record);
await verifier.verify(record); // Las aserciones se pueden reutilizar con otros registros

// Obtener un nuevo verificador limpio con solo la aserción `length(1)`
const otherVerifier = sdk.proofs;
await otherVerifier.verify(record);

const {
    response: { data: record },
} = await sdk.intent.read('<intent-handle>');
const error = sdk.proofs.error(record);
// Salida: LedgerSdkError encontrado en la última prueba, si existe.

// Obtener el cliente
const client = sdk.wallet; // Puede ser wallet, effect, intent...

// Inicializar el registro
const record = client.init();

// Establecer los datos
record.data({
    handle: 'my-wallet',
});

// Crear el hash de la data
record.hash();

// Firmar el regustro usando el arreglo de paráetros proporcionaos
record.sign([
    { keyPair },
    {
        /**
         * Se pueden asignar datos personalizados a las firmas.
         * Estos se incluirán en el cálculo del resultado
         * para esta firma específica y deben usarse en el
         * futuro para validarla.
         */

        keyPair,
        custom: {
            identifier: 123456,
        },
    },
]);

// Enviar el registro al backend
await record.send();

/**
 * También se pueden agregar todos los datos del registro directamente en el método `.init`.
 * Esto significa se puede pasar el hash y las pruebas manualmente en lugar de usar
 * los métodos `hash` y `sign` respectivamente, o simplemente pasar los datos en lugar de usar el método `.data`.
 */

await client
    .init({
        data: {
            handle: 'my-wallet',
        },
        hash: '<valid-hash>',
        meta: {
            proofs: [
                {},
                // Más proofs
            ],
        },
    })
    .send();

// Obtener el cliente
const client = sdk.wallet;

// Obtener la data de la billetera con el handle `my-wallet`
const walletResponse = await client.read('my-wallet');

const record = {
    hash: walletResponse.hash, // Has del registro
    meta: walletResponse.meta, // Metadata del registro, incluyendo las proof
    data: walletResponse.wallet, // Data del registro
};

/**
 * Al actualizar, leer o crear registros usando el SDK, el valor devuelto
 * incluirá la propiedad `response`, que es una instancia de la respuesta de axios.
 * Esto significa que también se puede obtener el registro completo desde el cuerpo de esa respuesta.
 */

const record = walletResponse.response.data;

const client = sdk.wallet;

const record = (await client.read('my-wallet')).response.data;

await client
    .from(record)
    .data({
        handle: 'my-wallet',
    })
    .hash() // El hash del registre cambiara con nueva data
    .sign([{ keyPair }]) // El  nuevo hash tiene que ser firmado
    .send();

// Actualizar el regustro completo
await client
    .from(record)
    .data(
        {
            ...record.data, // Expandir todos los datos del registro anterior

            factor: 10,
        },
        true // Pasar true (reemplazar) como segundo argumento
    )
    .hash()
    .sign([{ keyPair }])
    .send();

// Obtener el cliente
const client = sdk.wallet;

// Obtener las primeras 20 billeteras (Default)
const { wallets } = await client.list();

// Obtener las primeras 10 billeteras
const { wallets: firstTen } = await client.list({
    page: {
        index: 0,
        limit: 10,
    },
});

// Obtener las siguientes 10 billeteras
const { wallets: nextTen } = await client.list({
    page: {
        index: 1,
        limit: 10,
    },
});

/**
 * Tener en cuenta que el resultado de `wallets` contendrá solo los datos del registro.
 * Si se desea obtener el registro completo (incluyendo las propiedades `hash` y `meta`),
 * puede que se necesite obtener la lista directamente desde la propiedad `response`.
 */

const listResponse = await client.list();
const walletRecords = listResponse.response.data;

// Obtener los primero 10 topup intents
const { intents } = await client.list({
    page: {
        index: 0,
        limit: 10,
    },
    'data.schema.$eq': 'topup',
});

// Crear una billetera
await sdk.wallet
    .init()
    .data(...)
    .hash()
    .sign(...)
    .send();

// Actualizar una billetera
await sdk.wallet
    .from(...)
    .data(...)
    .hash()
    .sign(...)
    .send();

// Obtener los datos de una billetera específica
await sdk.wallet.read('<handle>')

// Obtener los saldos de una billetera específica
await sdk.wallet.getBalances('<handle>')

// Obtener los anclajes de una billetera específica
await sdk.wallet.getAnchors('<handle>')

// Obtener los anchors de una billetera específica mediante lookup. Permite pasar
// argumentos adicionales
await sdk
    .wallet
    .with('<handle>')
    .anchor.lookup()
    .data(...)
    .hash()
    .sign(...)
    .send();

// Crear un intent
await sdk.intent
	.init()
	.data(...)
	.hash()
	.sign(...)
	.send()

// Firmar un intent
await sdk.intent
	.from(...)
	.hash()
	.sign(...)
	.send()

// Obtener datos de un intent específico
await sdk.intent.read('<handle>')

// Obtener lista de intents
await sdk.intent.list(...)

// Crear un effect
await sdk.effect
	.init()
	.data(...)
	.hash()
	.sign(...)
	.send()

// Actualizar un effect
await sdk.effect
	.from(...)
	.data(...)
	.hash()
	.sign(...)
	.send()

// Obtener datos de un effect específico
await sdk.effect.read('<handle>')

// Obtener lista de effects
await sdk.effect.list(...)