DEV Community: Cardumen

Tutorial: Midnight Wallet SDK - Guía Completa para Desarrolladores

Cardumen — Wed, 17 Dec 2025 18:17:32 +0000

Índice

Introducción
Instalación
Conceptos Clave
Crear Instancias de Billetera
Gestión de Direcciones
Trabajar con Transacciones
Conectar con DApps
Ejemplos Prácticos

Introducción
Midnight Wallet SDK es un conjunto de herramientas que permite integrar funcionalidad de billetera en aplicaciones blockchain. El SDK proporciona abstracciones de alto nivel para gestionar operaciones comunes como:

Derivación de claves - Generar claves criptográficas a partir de una semilla
Balance de tokens - Obtener el saldo de tokens desde datos de la cadena
Gestión de monedas - Administrar monedas y datos para pruebas de conocimiento cero
Conexión con indexadores - Sincronizar estado con servidores indexadores
Creación de transacciones - Preparar y enviar transferencias de tokens

Paquetes Principales
PaqueteDescripción@midnight-ntwrk/wallet-apiInterfaces de alto nivel para billeteras@midnight-ntwrk/walletImplementación de wallet-api con herramientas adicionales@midnight-ntwrk/zswapConstrucción de bloques de Zswap@midnight-ntwrk/wallet-sdk-hdSoporte para billeteras jerárquico-determinísticas (HD)@midnight-ntwrk/wallet-sdk-address-formatSoporte para formato de dirección Bech32m

Instalación
Requisitos Previos

Node.js instalado
Yarn o npm como gestor de paquetes

Instalación del SDK
Usa Yarn para instalar el paquete:
bashyarn add @midnight-ntwrk/wallet/
Reemplaza con la versión requerida según la matriz de compatibilidad de versiones.
⚠️ Importante: A partir de la versión 4.0.0 hay cambios significativos. Consulta la matriz de compatibilidad para asegurar que usas la versión correcta.
Información Crítica sobre v4.0.0

Cambio importante: Las claves secretas ya no se incluyen en el estado serializado de la billetera
Restauración: Si restauras una billetera desde una instantánea, debes proporcionar la semilla original
Seguridad: Asegúrate de gestionar datos sensibles de forma segura

Conceptos Clave
Semilla de Billetera (Wallet Seed)
La semilla es un valor aleatorio (usualmente 256 bits) que se usa para derivar todas las claves criptográficas de tu billetera. Es esencial para:

Recuperar una billetera
Generar direcciones determinísticas
Restaurar estado desde instantáneas

Billeteras HD (Jerárquico-Determinísticas)
El SDK utiliza derivación BIP-32 siguiendo la ruta:
m / 44' / 2400' / account' / role / index
Donde:

account - Número de cuenta (recomendación BIP-44)
role - Tipo de rol (3 para Zswap)
index - Índice específico (recomendación BIP-44)

Ciclo de Vida de la Billetera

Crear instancia → 2. Iniciar sincronización → 3. Usar billetera → 4. Cerrar NetworkId (Identificador de Red) Define la red blockchain objetivo:

NetworkId.TestNet - Red de prueba
NetworkId.MainNet - Red principal
NetworkId.DevNet - Red de desarrollo

Crear Instancias de Billetera
Paso 1: Importar el Constructor
javascriptimport { WalletBuilder } from '@midnight-ntwrk/wallet';
import { NetworkId } from '@midnight-ntwrk/zswap';
Paso 2: Generar una Semilla
Para testing, puedes generar una semilla aleatoria:
javascriptimport { generateRandomSeed } from '@midnight-ntwrk/wallet-sdk-hd';

const semillaAleatoria = generateRandomSeed();
console.log('Semilla generada:', semillaAleatoria);
Para producción, usa derivación HD:
javascriptimport {
generateRandomSeed,
HDWallet,
Roles,
} from "@midnight-ntwrk/wallet-sdk-hd";

const semilla = generateRandomSeed();

function derivarSemillaDerivacion(semilla) {
const billetera = HDWallet.fromSeed(semilla);

if (billetera.type != "seedOk") {
throw new Error("Error inicializando HD Wallet");
}

const zswapKey = billetera.hdWallet
.selectAccount(0)
.selectRole(Roles.Zswap)
.deriveKeyAt(0);

if (zswapKey.type === "keyDerived") {
return zswapKey.key;
} else {
throw new Error("Error derivando clave");
}
}

const semillaFinal = derivarSemillaDerivacion(semilla);
console.log('Semilla derivada:', semillaFinal);
Paso 3: Construir la Instancia
Opción A: Desde una Semilla Específica
javascriptimport { WalletBuilder } from '@midnight-ntwrk/wallet';
import { NetworkId } from '@midnight-ntwrk/zswap';

const billetera = await WalletBuilder.build(
'https://indexer.testnet-02.midnight.network/api/v1/graphql', // URL del Indexador
'wss://indexer.testnet-02.midnight.network/api/v1/graphql/ws', // WebSocket del Indexador
'http://localhost:6300', // URL del Servidor de Pruebas
'https://rpc.testnet-02.midnight.network', // URL del Nodo
'0000000000000000000000000000000000000000000000000000000000000000', // Semilla
NetworkId.TestNet, // Red
'error' // Nivel de Log (opcional)
);
Opción B: Con Semilla Aleatoria (Testing)
javascriptimport { WalletBuilder } from '@midnight-ntwrk/wallet';
import { NetworkId } from '@midnight-ntwrk/zswap';
import { generateRandomSeed } from '@midnight-ntwrk/wallet-sdk-hd';

const semillaAleatoria = generateRandomSeed();

const billetera = await WalletBuilder.build(
'https://indexer.testnet-02.midnight.network/api/v1/graphql',
'wss://indexer.testnet-02.midnight.network/api/v1/graphql/ws',
'http://localhost:6300',
'https://rpc.testnet-02.midnight.network',
semillaAleatoria, // Semilla aleatoria
NetworkId.TestNet,
'error'
);
Paso 4: Iniciar la Sincronización
javascript// Inicia la sincronización con la cadena
billetera.start();

console.log('Billetera iniciada y sincronizando...');
Paso 5: Cerrar la Billetera
javascript// Cuando termines, cierra la billetera adecuadamente
await billetera.close();

console.log('Billetera cerrada y recursos liberados');

Instantáneas de Estado (State Snapshots)
Las instantáneas permiten guardar y restaurar el estado de una billetera rápidamente, ideal para extensiones de navegador o aplicaciones móviles.
Crear una Instantánea
javascriptconst estadoSerializado = await billetera.serialize();

console.log('Instantánea creada:', estadoSerializado);
Restaurar desde una Instantánea
⚠️ Importante: Debes proporcionar la semilla original para restaurar.
javascriptconst billetera_restaurada = await WalletBuilder.restore(
'https://indexer.testnet-02.midnight.network/api/v1/graphql',
'wss://indexer.testnet-02.midnight.network/api/v1/graphql/ws',
'http://localhost:6300',
'https://rpc.testnet-02.midnight.network',
'0000000000000000000000000000000000000000000000000000000000000000', // DEBES proporcionar la semilla
estadoSerializado,
'error'
);

billetera_restaurada.start();

Gestión de Direcciones
Formato Bech32m
Midnight utiliza direcciones en formato Bech32m con el prefijo personalizado mn_.
La estructura del prefijo es:
mn__
Ejemplos:

mn_shield-addr_test1... - Dirección de pago en TestNet
mn_shield-addr_test1... - Dirección escudada en TestNet (ESK para indexador)

Codificar una Dirección
javascriptimport {
ShieldedAddress,
ShieldedCoinPublicKey,
ShieldedEncryptionPublicKey,
MidnightBech32m,
} from "@midnight-ntwrk/wallet-sdk-address-format";
import { NetworkId } from "@midnight-ntwrk/zswap";
import { Buffer } from "buffer";

// Crear claves públicas
const claveCoinPublica = new ShieldedCoinPublicKey(
Buffer.from(
"064e092a80b33bee23404c46cfc48fec75a2356a9b01178dd6a62c29f5896f67",
"hex"
)
);

const claveEncriptacionPublica = new ShieldedEncryptionPublicKey(
Buffer.from(
"0300063c7753854aea18aa11f04d77b3c7eaa0918e4aa98d5eaf0704d8f4c2fc272899efbb8a71275f2a1aedd29f879021e0962b4730f9b47e1a",
"hex"
)
);

// Crear dirección
const direccion = new ShieldedAddress(claveCoinPublica, claveEncriptacionPublica);

// Codificar en Bech32m
const direccionCodificada = ShieldedAddress.codec
.encode(NetworkId.TestNet, direccion)
.asString();

console.log('Dirección codificada:', direccionCodificada);
// Salida: mn_shield-addr_test1qe8qj25qkva7ug6qf3rvl3y0a366ydt2nvq30rwk5ckznavfdansxqqx83m48p22agv25y0sf4mm83l25zgcuj4f34027pcymr6v9lp89zv7lwu2wyn472s6ahfflpusy8sfv268xrumgls62hqz4u
Decodificar una Dirección
javascriptconst direccionCodificada = "mn_shield-addr_test1qe8qj25qkva7ug6qf3rvl3y0a366ydt2nvq30rwk5ckznavfdansxqqx83m48p22agv25y0sf4mm83l25zgcuj4f34027pcymr6v9lp89zv7lwu2wyn472s6ahfflpusy8sfv268xrumgls62hqz4u";

// Parsear
const direccionParseada = MidnightBech32m.parse(direccionCodificada);

// Decodificar
const direccionDecodificada = ShieldedAddress.codec.decode(
NetworkId.TestNet,
direccionParseada
);

console.log('Clave pública de coin:', direccionDecodificada.coinPublicKeyString());
console.log('Clave pública de encriptación:', direccionDecodificada.encryptionPublicKeyString());

Trabajar con Transacciones
Ciclo de Vida de una Transacción

Preparar transacción sin prueba ↓
Calcular pruebas de conocimiento cero ↓
Enviar transacción comprobada Acceder al Estado de la Billetera El estado se proporciona a través de un observable de RxJS: javascriptimport { Observable } from 'rxjs';

// Suscribirse a cambios de estado
billetera.state().subscribe((estado) => {
console.log('Estado actual:', estado);
console.log('Saldo:', estado.coins);
console.log('Historial de transacciones:', estado.transactionHistory);
});
Paso 1: Preparar una Transferencia
javascriptimport { nativeToken } from '@midnight-ntwrk/zswap';

// ⚠️ IMPORTANTE: Asegúrate que la billetera haya sincronizado completamente
// antes de preparar una transacción. De lo contrario, podrías intentar gastar
// una moneda que ya fue gastada pero tu billetera aún no lo sabe.

const recetaTransferencia = await billetera.transferTransaction([
{
amount: 1n, // Cantidad en satoshis (BigInt)
type: nativeToken(), // Tipo de token (tDUST)
receiverAddress: 'mn_shield-addr_test1kj...' // Dirección del receptor
}
]);

console.log('Receta de transferencia preparada');
Paso 2: Balancear una Transacción Existente
Balancear una transacción significa ajustarla para cubrir las comisiones y equilibrar entradas/salidas:
javascriptconst transaccionBalanceada = await billetera.balanceTransaction(
transaccionExistente,
[] // newCoins (opcional) - para monedas nuevas creadas por DApps
);

console.log('Transacción balanceada');
Paso 3: Generar Pruebas de Conocimiento Cero
Este paso es computacionalmente intensivo y puede tomar varios segundos:
javascriptimport { TRANSACTION_TO_PROVE } from '@midnight-ntwrk/wallet-api';

// Crear la receta (wrapper) de la transacción
const receta = {
type: TRANSACTION_TO_PROVE,
transaction: recetaTransferencia
};

// Generar pruebas (⚠️ Esto es MUY lento - puede tomar decenas de segundos)
console.time('Generación de pruebas');
const transaccionComprobada = await billetera.proveTransaction(receta);
console.timeEnd('Generación de pruebas');

console.log('Pruebas generadas exitosamente');
Paso 4: Enviar la Transacción
javascript// La transacción debe estar:
// 1. Balanceada (entradas ≥ salidas + comisiones)
// 2. Comprobada (pruebas generadas)

const transaccionEnviada = await billetera.submitTransaction(
transaccionComprobada
);

console.log('Transacción enviada:', transaccionEnviada);
console.log('Hash de transacción:', transaccionEnviada.id);

Conectar con DApps
Las aplicaciones descentralizadas se conectan a la billetera a través del API de DApp Connector. La billetera se inyecta en el contexto del navegador, permitiendo que las DApps soliciten operaciones como:

Obtener dirección del usuario
Firmar transacciones
Enviar tokens
Ejecutar contratos inteligentes

Consulta:

DApp Connector Overview
Wallet Provider para más detalles técnicos

Ejemplos Prácticos
Ejemplo 1: Transferencia Básica de tDUST
Este ejemplo crea una billetera, sincroniza con la cadena y envía 1 tDUST a otra dirección:
javascriptimport { WalletBuilder } from '@midnight-ntwrk/wallet';
import { NetworkId, nativeToken } from '@midnight-ntwrk/zswap';

async function transferirTDUST() {
try {
// 1. Crear billetera
console.log('📱 Creando billetera...');
const billetera = await WalletBuilder.build(
'https://indexer.testnet-02.midnight.network/api/v1/graphql',
'wss://indexer.testnet-02.midnight.network/api/v1/graphql/ws',
'http://localhost:6300',
'https://rpc.testnet-02.midnight.network',
'0000000000000000000000000000000000000000000000000000000000000000',
NetworkId.TestNet
);

// 2. Iniciar sincronización
console.log('🔄 Iniciando sincronización...');
billetera.start();

// Esperar a que sincronice (en producción, implementa mejor lógica de espera)
await new Promise(resolve => setTimeout(resolve, 5000));

// 3. Preparar transferencia
console.log('💸 Preparando transferencia...');
const recetaTransferencia = await billetera.transferTransaction([
  {
    amount: 1n,
    type: nativeToken(),
    receiverAddress: 'mn_shield-addr_test1kjwksfp8x2tachehsfvufsdl35ljg5cxzdcysjdn6ntadspyxn3qxqrxypgjm055c2azrpuyn7un0ge2vm25vkfv38d24rj3ewcku5wmdc94gjr9'
  }
]);

// 4. Generar pruebas
console.log('⚙️ Generando pruebas de conocimiento cero (esto puede tomar un tiempo)...');
const transaccionComprobada = await billetera.proveTransaction(recetaTransferencia);

// 5. Enviar transacción
console.log('📤 Enviando transacción...');
const resultado = await billetera.submitTransaction(transaccionComprobada);

console.log('✅ ¡Transacción enviada exitosamente!');
console.log('ID de transacción:', resultado.id);

// 6. Cerrar billetera
await billetera.close();
console.log('🔐 Billetera cerrada');

} catch (error) {
console.error('❌ Error:', error.message);
}
}

// Ejecutar
transferirTDUST();
Ejemplo 2: Guardar y Restaurar Billetera
javascriptimport { WalletBuilder } from '@midnight-ntwrk/wallet';
import { NetworkId } from '@midnight-ntwrk/zswap';
import { generateRandomSeed } from '@midnight-ntwrk/wallet-sdk-hd';
import * as fs from 'fs';

async function guardarYRestaurarBilletera() {
const ruutaArchivo = './billetera_snapshot.json';
const semilla = generateRandomSeed();

try {
// 1. Crear billetera original
console.log('📱 Creando billetera original...');
const billetera = await WalletBuilder.build(
'https://indexer.testnet-02.midnight.network/api/v1/graphql',
'wss://indexer.testnet-02.midnight.network/api/v1/graphql/ws',
'http://localhost:6300',
'https://rpc.testnet-02.midnight.network',
semilla,
NetworkId.TestNet
);

billetera.start();

// Esperar sincronización
await new Promise(resolve => setTimeout(resolve, 3000));

// 2. Guardar instantánea
console.log('💾 Guardando instantánea...');
const estadoSerializado = await billetera.serialize();
fs.writeFileSync(ruutaArchivo, JSON.stringify({
  estado: estadoSerializado,
  semilla: Buffer.from(semilla).toString('hex')
}, null, 2));

await billetera.close();
console.log('✅ Instantánea guardada en:', ruutaArchivo);

// 3. Restaurar desde instantánea
console.log('📂 Leyendo instantánea...');
const datos = JSON.parse(fs.readFileSync(ruutaArchivo, 'utf-8'));

console.log('🔄 Restaurando billetera...');
const billetera_restaurada = await WalletBuilder.restore(
  'https://indexer.testnet-02.midnight.network/api/v1/graphql',
  'wss://indexer.testnet-02.midnight.network/api/v1/graphql/ws',
  'http://localhost:6300',
  'https://rpc.testnet-02.midnight.network',
  Buffer.from(datos.semilla, 'hex'),
  datos.estado
);

billetera_restaurada.start();
console.log('✅ Billetera restaurada exitosamente');

// Verificar estado
billetera_restaurada.state().subscribe((estado) => {
  console.log('Estado restaurado - Monedas:', estado.coins);
});

await billetera_restaurada.close();

} catch (error) {
console.error('❌ Error:', error.message);
}
}

guardarYRestaurarBilletera();
Ejemplo 3: Monitorear Estado en Tiempo Real
javascriptimport { WalletBuilder } from '@midnight-ntwrk/wallet';
import { NetworkId } from '@midnight-ntwrk/zswap';
import { debounceTime, distinctUntilChanged } from 'rxjs/operators';

async function monitorearBilletera() {
try {
const billetera = await WalletBuilder.build(
'https://indexer.testnet-02.midnight.network/api/v1/graphql',
'wss://indexer.testnet-02.midnight.network/api/v1/graphql/ws',
'http://localhost:6300',
'https://rpc.testnet-02.midnight.network',
'0000000000000000000000000000000000000000000000000000000000000000',
NetworkId.TestNet
);

billetera.start();

// Monitorear cambios de estado con debounce
billetera.state()
  .pipe(
    debounceTime(1000),                    // Esperar 1 segundo sin cambios
    distinctUntilChanged((a, b) =>         // Solo si realmente cambió
      JSON.stringify(a) === JSON.stringify(b)
    )
  )
  .subscribe((estado) => {
    console.log('\n📊 === ESTADO ACTUALIZADO ===');
    console.log('Monedas disponibles:', estado.coins.length);
    console.log('Saldo total:', estado.coins.reduce((sum, c) => sum + c.amount, 0n));
    console.log('Transacciones procesadas:', estado.transactionHistory.length);
    console.log('Última transacción:', 
      estado.transactionHistory[0]?.date || 'Ninguna');
  });

// Mantener proceso activo
console.log('👀 Monitoreando billetera (Ctrl+C para salir)...');

} catch (error) {
console.error('❌ Error:', error.message);
}
}

monitorearBilletera();

Buenas Prácticas y Recomendaciones

Sincronización Completa Antes de Transacciones javascript// ❌ INCORRECTO const receta = await billetera.transferTransaction([...]);

// ✅ CORRECTO
// Esperar a que la billetera esté sincronizada
await new Promise(resolve =>
billetera.state()
.pipe(filter(s => s.isSynced))
.subscribe(() => resolve())
);
const receta = await billetera.transferTransaction([...]);

Gestión Segura de Semillas javascript// ❌ INCORRECTO const semilla = "0000000000..."; // Hardcodeada

// ✅ CORRECTO
const semilla = process.env.WALLET_SEED; // Variables de entorno
// O
const semilla = await obtenerDelAlfiler(); // Sistema seguro de almacenamiento

Manejo de Errores Robusto javascripttry { const transaccion = await billetera.proveTransaction(receta); } catch (error) { if (error.message.includes('insufficient')) { console.error('Saldo insuficiente'); } else if (error.message.includes('timeout')) { console.error('Servidor de pruebas no disponible'); } else { console.error('Error desconocido:', error); } }
Cierre Adecuado de Recursos javascriptasync function operacionConBilletera() { const billetera = await WalletBuilder.build(...); try { billetera.start(); // Tu código aquí } finally { await billetera.close(); // Siempre cerrar } }
Timeouts en Operaciones Largas javascriptimport { timeout } from 'rxjs/operators';

const transaccionConTimeout = billetera.proveTransaction(receta)
.pipe(timeout(60000)); // 60 segundos máximo

Parámetros de Configuración
WalletBuilder.build() - Parámetros Obligatorios
ParámetroTipoDescripciónIndexer URLStringURL del API GraphQL del indexadorIndexer WebSocket URLStringURL WebSocket del indexadorProving Server URLStringURL del servidor de pruebasNode URLStringURL del nodo RPCSeedStringSemilla de 256 bits en hexNetwork IDNetworkIdTestNet, MainNet, etc.
Parámetros Opcionales
ParámetroTipoDefaultDescripciónLog LevelLogLevelwarnerror, warn, info, debugDiscard Transaction HistoryBooleanfalseDescartar historial de transacciones

Troubleshooting
Problema: "Error derivando clave"
Solución: Verifica que la semilla sea de 256 bits (64 caracteres hex)
Problema: Transacción rechazada por "double spend"
Solución: Asegúrate de que la billetera esté completamente sincronizada
antes de preparar la transacción
Problema: Servidor de pruebas no disponible
Solución: Verifica que el servidor de pruebas esté corriendo en localhost:6300
o usa URL correcta en la configuración
Problema: "secret keys are no longer included"
Solución: Proporciona la semilla original al restaurar desde instantánea

Recursos Adicionales

Documentación Oficial: https://docs.midnight.network
GitHub: https://github.com/midnight-ntwrk
API Reference: Consulta la documentación de @midnight-ntwrk/wallet
Ejemplos: Revisa los ejemplos incluidos en el repositorio

Conclusión
El Midnight Wallet SDK proporciona una forma robusta y segura de integrar funcionalidad de billetera en aplicaciones blockchain. Recuerda siempre:

✅ Gestiona las semillas de forma segura
✅ Sincroniza completamente antes de transacciones
✅ Cierra recursos adecuadamente
✅ Implementa manejo robusto de errores
✅ Prueba ampliamente antes de producción

Kachina y el Dilema de la Composabilidad: Cuando la Privacidad Blockchain se Encuentra con la Realidad Técnica

Cardumen — Tue, 16 Dec 2025 21:56:54 +0000

Kachina y el Dilema de la Composabilidad: Cuando la Privacidad Blockchain se Encuentra con la Realidad Técnica
El Problema que Nadie Quiere Admitir
Hablemos claro: las blockchains públicas son como vivir en una casa de cristal. Cada transacción, cada saldo, cada movimiento está ahí para que cualquiera lo vea. Y aunque la transparencia es genial para la auditabilidad, es terrible para casi todo lo demás.
Imagina tener que publicar tu salario cada vez que cobras. O que tus competidores puedan ver exactamente cuánto pagas a tus proveedores. Ese es el estado actual de las blockchains públicas.
Kachina, el framework que está implementando Midnight (un sidechain de Cardano), promete resolver esto con contratos inteligentes privados. Pero como todo en cripto, la solución trae sus propios desafíos.
Cómo Funciona Kachina: La Magia de los Dos Mundos
Kachina divide la ejecución en dos capas que funcionan en paralelo:
El Mundo Público (Compact Runtime)

Vive en la blockchain
Solo ve compromisos criptográficos (hashes)
Verifica pruebas ZK
Actualiza el estado global sin saber los detalles

El Mundo Privado (Contract Runtime)

Corre en tu computadora local
Procesa la lógica real del contrato
Genera pruebas de conocimiento cero
Mantiene tus datos sensibles seguros

Es como tener un notario que certifica que hiciste algo correctamente sin necesitar ver qué hiciste exactamente. Verificación sin revelación.
El Elefante en la Habitación: La Composabilidad
Aquí es donde las cosas se ponen interesantes (y complicadas).
En blockchains tradicionales como Ethereum, la composabilidad es trivial. Un contrato puede:
solidity// En Ethereum es así de simple
uint balance = otherContract.getBalance(user);
require(balance > minAmount);
// Listo, ya tienes el dato
Los contratos se hablan entre sí como piezas de LEGO. Uniswap puede llamar a un token ERC-20, que puede llamar a un oráculo, que puede llamar a otro protocolo. Todo fluye.
El Nuevo Paradigma de Kachina
En Kachina no puedes simplemente "leer" el estado de otro contrato porque... bueno, ese estado es privado. En lugar de eso:

Contrato A genera una prueba ZK de su estado
Contrato B verifica esa prueba
Contrato B genera su propia prueba incluyendo la verificación anterior
La blockchain solo ve pruebas verificándose, nunca los datos reales

Es como si en lugar de mostrar tu saldo bancario para un préstamo, generas una prueba matemática que dice "sí, tengo más de X cantidad" sin revelar cuánto tienes exactamente.
Los Trade-offs Reales
Lo Bueno ✅

Privacidad real: No más frontrunning, no más espionaje competitivo
Cumplimiento regulatorio privado: Puedes cumplir regulaciones sin exponer datos sensibles
Votaciones verdaderamente secretas: Governance sin presión social
Finanzas corporativas viables: Las empresas pueden usar blockchain sin revelar secretos comerciales

Lo Complicado ⚠️

Complejidad de desarrollo: No es solo escribir Solidity y ya. Necesitas pensar en circuitos, pruebas, y verificaciones desde el día uno
Costos computacionales: Generar pruebas ZK no es gratis. Tu computadora trabaja más
Curva de aprendizaje empinada: ZK no es intuitivo. Requiere repensar cómo diseñas aplicaciones
Composabilidad diferente: No imposible, pero definitivamente más compleja

El Problema Técnico de Fondo
Cuando Patricio López mencionó el tema de los circuitos algebraicos, dio en el clavo. En ZK, cada operación necesita ser expresada como un circuito. Si tienes:

Prueba A: "Tengo más de 1000 tokens"
Prueba B: "He estado activo por 30 días"

Para crear una Prueba C que combine ambas condiciones, no puedes simplemente sumar A + B. Necesitas:

Un circuito que verifique la Prueba A
Un circuito que verifique la Prueba B
Un nuevo circuito que implemente tu lógica usando ambas verificaciones

Esto es lo que Kachina resuelve con "pruebas recursivas" - básicamente, pruebas que verifican otras pruebas. Pero no es magia; cada composición añade complejidad y costo computacional.
¿Qué Significa Esto para el Ecosistema?
Para Desarrolladores
Preparense para una curva de aprendizaje brutal. No es solo aprender un nuevo lenguaje; es aprender una nueva forma de pensar sobre la computación. Los que dominen ZK serán los magos del próximo ciclo.
Para Usuarios
Finalmente podrán tener privacidad real. Pero probablemente pagarán más en fees y tendrán que esperar más tiempo para las transacciones (generar pruebas toma tiempo).
Para Empresas
Es la primera vez que blockchain es viable para casos de uso corporativos reales. No más excusas sobre "no podemos exponer nuestros datos".
El Veredicto
Kachina no es una bala de plata. Es un trade-off consciente: sacrificamos algo de la simplicidad y eficiencia de las blockchains públicas a cambio de privacidad real y verificable.
La composabilidad no está muerta, solo es diferente. En lugar de un mundo donde los contratos leen libremente el estado de otros, tenemos un mundo donde los contratos prueban cosas sobre su estado sin revelarlo.
¿Es más complejo? Absolutamente.
¿Vale la pena? Para muchos casos de uso, definitivamente sí.
Mirando al Futuro
El éxito de Kachina y Midnight no dependerá solo de la tecnología, sino de:

Herramientas de desarrollo: Necesitamos abstracciones que hagan ZK más accesible
Educación: La comunidad necesita entender estos nuevos paradigmas
Casos de uso killer: Aplicaciones que solo son posibles con privacidad
Optimizaciones: Hacer la generación de pruebas más rápida y barata

La privacidad en blockchain no es un lujo; es una necesidad para la adopción masiva. Kachina es un paso importante en esa dirección, incluso si significa repensar algunas de las suposiciones fundamentales sobre cómo funcionan los contratos inteligentes.
Como siempre en cripto: no hay almuerzo gratis. Pero al menos con Kachina, nadie sabrá cuánto pagaste por él.

Cómo escribir smart contracts en Midnight

Cardumen — Sat, 13 Dec 2025 22:52:43 +0000

Una introducción práctica al desarrollo privacy-first

Midnight es una blockchain diseñada desde cero para resolver uno de los mayores problemas del ecosistema: cómo construir aplicaciones descentralizadas sin exponer datos sensibles. A diferencia de la mayoría de las blockchains —donde todo es público o todo es privado— Midnight introduce un modelo más fino: selective disclosure.

En este artículo veremos cómo se escribe un smart contract en Midnight, qué lo hace distinto y cómo pensar el desarrollo cuando la privacidad no es un parche, sino una propiedad del lenguaje.

El modelo mental: privacidad por defecto

Antes de escribir una sola línea de código, hay que cambiar el enfoque.

En Midnight:

Todo lo que viene del usuario es privado por defecto

Nada se puede hacer público “por accidente”

La privacidad se controla explícitamente, no implícitamente

Esto se logra gracias a Compact, el lenguaje de smart contracts de Midnight, y al uso de Zero-Knowledge Proofs (zkSNARKs) para validar transacciones sin revelar datos.

¿Qué es Compact?

Compact es un lenguaje declarativo diseñado específicamente para construir aplicaciones privacy-first.

Cuando escribes un contrato en Compact:

Defines la lógica de negocio

Defines qué datos son públicos

Defines qué datos permanecen privados

El compilador genera:

APIs en JavaScript / TypeScript para tu DApp

Los artefactos criptográficos necesarios para generar pruebas ZK

Todo esto ocurre localmente en el entorno del desarrollador.

Componentes básicos de un contrato en Compact

Todo contrato en Midnight se construye a partir de los mismos bloques:

Ledger state (estado público)

Datos que viven en la cadena y son visibles para todos.

export ledger value: Uint<64>;

Witnesses (entradas privadas)

Los witnesses representan datos que vienen del usuario o del frontend.
Son privados por defecto y Compact no permite que se filtren accidentalmente.

witness getSecret(): Bytes<32>;

Circuits (lógica verificable)

Los circuits definen qué puede hacer el contrato.
Solo los circuits marcados como export pueden ser llamados desde fuera.

export circuit get(): Uint<64> {
return value;
}

Constructor

Se ejecuta una sola vez, al crear el contrato.

constructor(sk: Bytes<32>, v: Uint<64>) {
value = v;
}

Selective disclosure: disclose()

Una de las reglas más importantes de Compact es esta:

No puedes hacer público un dato privado sin decirlo explícitamente.

Si intentas usar un witness directamente en el ledger o como retorno, el compilador falla.

Forma correcta:

export ledger publicData: Bytes<32>;

export circuit record(): [] {
publicData = disclose(getSecret());
}

Forma incorrecta (error de compilación):

publicData = getSecret(); // ❌

Esto elimina una clase completa de errores comunes en otros ecosistemas.

Opaque types: cuando Compact no debe “mirar” el dato

Compact permite tipos opacos como:

Opaque<'string'>

Estos tipos:

Pueden almacenarse o transferirse

No pueden ser inspeccionados dentro del contrato

Son visibles en el frontend (TypeScript), pero no manipulables en Compact

Son útiles para:

Mensajes

Metadatos

Contenido arbitrario (ej. bulletin boards)

Compromisos y hashing

Para probar propiedades sobre datos sin revelarlos, Compact incluye primitivas criptográficas:

persistentCommit(value, random);
transientCommit(value);

Estas funciones son clave para:

Votaciones privadas

Identidad verificable

Autenticación sin revelar credenciales

El rol del proof server

Toda la magia ZK ocurre fuera de la blockchain.

El proof server:

Corre localmente o en infraestructura controlada

Nunca expone datos privados a la red

Solo devuelve pruebas criptográficas válidas

Esto permite que:

La blockchain valide hechos

Sin conocer los datos subyacentes

Cómo pensar un contrato en Midnight

Al escribir en Midnight, conviene preguntarse:

¿Este dato realmente debe ser público?

¿Qué necesita verificar la red y qué no?

¿Puedo probar esta condición sin revelar el valor?

¿Quién controla el proof server?

Compact no solo te da herramientas, te obliga a pensar bien el modelo de datos.

Conclusión

Escribir smart contracts en Midnight no es solo aprender un nuevo lenguaje.
Es adoptar una forma distinta de diseñar aplicaciones descentralizadas:

Privacidad por defecto

Disclosure explícito

Separación clara entre datos, lógica y pruebas

Seguridad reforzada a nivel de compilador

Si vienes de ecosistemas como Solidity o Plutus, Compact puede sentirse distinto al principio. Pero una vez que el modelo hace clic, es difícil volver atrás.

La privacidad deja de ser un “feature” y pasa a ser parte del lenguaje.