@totemsdk/core 1.0.8 → 1.0.10

package/src/lease-client.ts

@@ -1,69 +0,0 @@
-/**
- * Totem <-> Axia hardened WOTS helpers (no deps on server internals).
- */
-export type PrepareArgs = {
-  txId: string;
-  rootPublicKey: string;     // 0x… (32-byte pk digest hex)
-  to: string;                // Mx…
-  amount: string;            // decimal string
-  tokenId?: string;          // default "0x00"
-  burn?: string | null;      // optional
-  digestL2?: string | null;  // optional — if you precompute trees
-  digestL3?: string | null;  // optional — if you precompute trees
-  ttlMs?: number;            // default 20000
-};
-
-export type PrepareResp = {
-  leaseToken: string;                 // JWT
-  lease: { addressIndex: number; l1: number; l2: number };
-  txId: string;
-  digestTx?: string | null;           // optional
-};
-
-export async function prepareLease(apiUrl: string, apiKey: string, args: PrepareArgs): Promise<PrepareResp> {
-  const res = await fetch(`${apiUrl}/v1/wots-hardened/prepare`, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json', 'x-api-key': apiKey },
-    body: JSON.stringify({
-      tokenId: "0x00",
-      burn: null,
-      digestL2: null,
-      digestL3: null,
-      ttlMs: 20000,
-      ...args
-    })
-  });
-  if (!res.ok) throw new Error(`prepareLease ${res.status}`);
-  const raw = await res.json() as {
-    leaseToken: string;
-    lease?: { addressIndex: number; l1: number; l2: number };
-    addressIndex?: number;
-    l1?: number;
-    l2?: number;
-    txId: string;
-    digestTx?: string | null;
-  };
-  const lease = raw.lease ?? { addressIndex: raw.addressIndex ?? 0, l1: raw.l1 ?? 0, l2: raw.l2 ?? 0 };
-  return {
-    leaseToken: raw.leaseToken,
-    lease,
-    txId: raw.txId,
-    digestTx: raw.digestTx ?? null
-  };
-}
-
-export async function finalizeLease(apiUrl: string, apiKey: string, leaseToken: string, signedHex: string) {
-  const res = await fetch(`${apiUrl}/v1/wots-hardened/finalize`, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json', 'x-api-key': apiKey },
-    body: JSON.stringify({ leaseToken, signedHex })
-  });
-  const text = await res.text();
-  return { status: res.status, body: text };
-}
-
-/** lane tuple -> flat WOTS index (64^3 space) */
-export function flatIndexFromLanes(addressIndex: number, l1: number, l2: number): number {
-  if (addressIndex|l1|l2 & ~63) throw new Error('lane out of range');
-  return (addressIndex * 64 * 64) + (l1 * 64) + l2;
-}

package/src/minima32.d.ts

@@ -1,10 +0,0 @@
-export declare function encodeMxRadix32Frame(frame: Uint8Array): string;
-export declare function decodeMxRadix32Frame(mx: string): Uint8Array;
-/** Encode raw 32 bytes to Mx address with frame and checksum */
-export declare function encodeMx(root32: Uint8Array): string;
-/** Decode Mx address to raw 32 bytes, validating frame and checksum */
-export declare function decodeMx(mx: string): Uint8Array;
-/** Make an Mx address from a hex string (legacy API compatibility) */
-export declare function makeMinimaAddress(hex: string): string;
-/** Convert an Mx address back to uppercase hex (legacy API compatibility) */
-export declare function convertMinimaAddress(mx: string): string;

package/src/minima32.js

@@ -1,113 +0,0 @@
-"use strict";
-// Minima "Mx" Base32 — matches org.minima.utils.BaseConverter.encode32/decode32
-// Source behavior: BigInteger radix-32, then i→w, l→y, o→z, uppercased, prefixed with "Mx".
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeMxRadix32Frame = encodeMxRadix32Frame;
-exports.decodeMxRadix32Frame = decodeMxRadix32Frame;
-exports.encodeMx = encodeMx;
-exports.decodeMx = decodeMx;
-exports.makeMinimaAddress = makeMinimaAddress;
-exports.convertMinimaAddress = convertMinimaAddress;
-function bytesToBigInt(bytes) {
-    let x = 0n;
-    for (const b of bytes)
-        x = (x << 8n) | BigInt(b);
-    return x;
-}
-function bigIntToBytes(x) {
-    if (x === 0n)
-        return new Uint8Array([0]); // not normally hit for framed addresses
-    let hex = x.toString(16);
-    if (hex.length % 2)
-        hex = '0' + hex;
-    const out = new Uint8Array(hex.length / 2);
-    for (let i = 0; i < out.length; i++) {
-        out[i] = parseInt(hex.slice(2 * i, 2 * i + 2), 16);
-    }
-    return out;
-}
-function encodeMxRadix32Frame(frame) {
-    let s = bytesToBigInt(frame).toString(32).toLowerCase();
-    // JAR swaps (avoid ambiguous letters) then uppercase and add prefix
-    s = s.replace(/i/g, 'w').replace(/l/g, 'y').replace(/o/g, 'z');
-    return 'Mx' + s.toUpperCase();
-}
-function decodeMxRadix32Frame(mx) {
-    let s = mx.trim().toLowerCase();
-    if (s.startsWith('mx'))
-        s = s.slice(2);
-    s = s.replace(/w/g, 'i').replace(/y/g, 'l').replace(/z/g, 'o'); // reverse swaps
-    // parse base-32 by hand (radix 32)
-    let x = 0n;
-    for (const ch of s) {
-        const v = parseInt(ch, 32);
-        if (Number.isNaN(v))
-            throw new Error(`Invalid base32 character: ${ch}`);
-        x = x * 32n + BigInt(v);
-    }
-    return bigIntToBytes(x);
-}
-// Import SHA3 for checksum calculation
-const sha3_1 = require("@noble/hashes/sha3");
-/** Encode raw 32 bytes to Mx address with frame and checksum */
-function encodeMx(root32) {
-    if (root32.length !== 32) {
-        throw new Error(`Expected 32 bytes, got ${root32.length}`);
-    }
-    // Build frame: [sentinel(1), length(2), data(32), checksum(4)]
-    const frame = new Uint8Array(1 + 2 + 32 + 4);
-    frame[0] = 0x01; // Sentinel byte
-    frame[1] = 0; // Length high byte
-    frame[2] = 32; // Length low byte
-    frame.set(root32, 3);
-    // Calculate checksum of the raw 32 bytes
-    const chk = sha3_1.sha3_256(root32);
-    frame.set(chk.slice(0, 4), 35);
-    return encodeMxRadix32Frame(frame);
-}
-/** Decode Mx address to raw 32 bytes, validating frame and checksum */
-function decodeMx(mx) {
-    const frame = decodeMxRadix32Frame(mx);
-    // Validate frame structure
-    if (frame[0] !== 0x01) {
-        throw new Error(`Invalid sentinel byte: ${frame[0]}`);
-    }
-    const len = (frame[1] << 8) | frame[2];
-    if (len !== 32) {
-        throw new Error(`Invalid length: ${len}, expected 32`);
-    }
-    const root32 = frame.slice(3, 35);
-    const checksum = frame.slice(35, 39);
-    // Validate checksum
-    const expectedChk = sha3_1.sha3_256(root32);
-    const expected = expectedChk.slice(0, 4);
-    for (let i = 0; i < 4; i++) {
-        if (checksum[i] !== expected[i]) {
-            throw new Error('Invalid checksum');
-        }
-    }
-    return root32;
-}
-// Aliases for backward compatibility
-function hexToBytes(hex) {
-    let h = hex.startsWith("0x") ? hex.slice(2) : hex;
-    if (h.length % 2)
-        h = "0" + h;
-    const out = new Uint8Array(h.length / 2);
-    for (let i = 0; i < out.length; i++)
-        out[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
-    return out;
-}
-function bytesToHex(bytes) {
-    return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('').toUpperCase();
-}
-/** Make an Mx address from a hex string (legacy API compatibility) */
-function makeMinimaAddress(hex) {
-    const bytes = hexToBytes(hex);
-    return encodeMx(bytes);
-}
-/** Convert an Mx address back to uppercase hex (legacy API compatibility) */
-function convertMinimaAddress(mx) {
-    const bytes = decodeMx(mx);
-    return bytesToHex(bytes);
-}

package/src/minima32.test.ts

@@ -1,11 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { encodeMxRadix32Frame, decodeMxRadix32Frame } from './minima32';
-
-describe('Minima radix-32 with swaps', () => {
-  it('roundtrips arbitrary frames', () => {
-    const frame = Uint8Array.from([0x01, 0x00, 0x02, 0xaa, 0xff, 0xde, 0xad, 0xbe, 0xef].slice(0, 6));
-    const mx = encodeMxRadix32Frame(frame);
-    const back = decodeMxRadix32Frame(mx);
-    expect([...back]).toEqual([...frame]);
-  });
-});

package/src/minima32.ts

@@ -1,127 +0,0 @@
-// Minima "Mx" Base32 — matches org.minima.utils.BaseConverter.encode32/decode32
-// Source behavior: BigInteger radix-32, then i→w, l→y, o→z, uppercased, prefixed with "Mx".
-
-function bytesToBigInt(bytes: Uint8Array): bigint {
-  let x = 0n;
-  for (const b of bytes) x = (x << 8n) | BigInt(b);
-  return x;
-}
-
-function bigIntToBytes(x: bigint): Uint8Array {
-  if (x === 0n) return new Uint8Array([0]); // not normally hit for framed addresses
-  let hex = x.toString(16);
-  if (hex.length % 2) hex = '0' + hex;
-  const out = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < out.length; i++) {
-    out[i] = parseInt(hex.slice(2 * i, 2 * i + 2), 16);
-  }
-  return out;
-}
-
-export function encodeMxRadix32Frame(frame: Uint8Array): string {
-  let s = bytesToBigInt(frame).toString(32).toLowerCase();
-  // JAR swaps (avoid ambiguous letters) then uppercase and add prefix
-  s = s.replace(/i/g, 'w').replace(/l/g, 'y').replace(/o/g, 'z');
-  return 'Mx' + s.toUpperCase();
-}
-
-export function decodeMxRadix32Frame(mx: string): Uint8Array {
-  let s = mx.trim().toLowerCase();
-  if (s.startsWith('mx')) s = s.slice(2);
-  s = s.replace(/w/g, 'i').replace(/y/g, 'l').replace(/z/g, 'o'); // reverse swaps
-
-  // parse base-32 by hand (radix 32)
-  let x = 0n;
-  for (const ch of s) {
-    const v = parseInt(ch, 32);
-    if (Number.isNaN(v)) throw new Error(`Invalid base32 character: ${ch}`);
-    x = x * 32n + BigInt(v);
-  }
-  return bigIntToBytes(x);
-}
-
-import { sha3_256 as nobleSha3 } from '@noble/hashes/sha3.js';
-
-/** Encode raw 32 bytes to Mx address with frame and checksum */
-export function makeMxAddress(root32: Uint8Array): string {
-  if (root32.length !== 32) {
-    throw new Error(`Expected 32 bytes, got ${root32.length}`);
-  }
-  
-  // Build frame: [sentinel(1), length(2), data(32), checksum(4)]
-  const frame = new Uint8Array(1 + 2 + 32 + 4);
-  frame[0] = 0x01;  // Sentinel byte
-  frame[1] = 0;     // Length high byte
-  frame[2] = 32;    // Length low byte
-  frame.set(root32, 3);
-  
-  // Calculate checksum of the raw 32 bytes
-  const chk = nobleSha3(root32);
-  frame.set(chk.slice(0, 4), 35);
-  
-  return encodeMxRadix32Frame(frame);
-}
-
-/** Decode Mx address to raw 32 bytes, validating frame and checksum */
-export function parseMxAddress(mx: string): Uint8Array {
-  const frame = decodeMxRadix32Frame(mx);
-  
-  // Validate frame structure
-  if (frame[0] !== 0x01) {
-    throw new Error(`Invalid sentinel byte: ${frame[0]}`);
-  }
-  
-  const len = (frame[1] << 8) | frame[2];
-  if (len !== 32) {
-    throw new Error(`Invalid length: ${len}, expected 32`);
-  }
-  
-  const root32 = frame.slice(3, 35);
-  const checksum = frame.slice(35, 39);
-  
-  // Validate checksum
-  const expectedChk = nobleSha3(root32);
-  const expected = expectedChk.slice(0, 4);
-  
-  for (let i = 0; i < 4; i++) {
-    if (checksum[i] !== expected[i]) {
-      throw new Error('Invalid checksum');
-    }
-  }
-  
-  return root32;
-}
-
-// Aliases for backward compatibility
-function hexToBytes(hex: string): Uint8Array {
-  let h = hex.startsWith("0x") ? hex.slice(2) : hex;
-  if (h.length % 2) h = "0" + h;
-  const out = new Uint8Array(h.length / 2);
-  for (let i = 0; i < out.length; i++) out[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
-  return out;
-}
-
-function bytesToHex(bytes: Uint8Array): string {
-  return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('').toUpperCase();
-}
-
-/** Make an Mx address from a hex string (legacy API compatibility) */
-export function hexToMx(hex: string): string {
-  const bytes = hexToBytes(hex);
-  return makeMxAddress(bytes);
-}
-
-/** Convert an Mx address back to uppercase hex (legacy API compatibility) */
-export function mxToHex(mx: string): string {
-  const bytes = parseMxAddress(mx);
-  return bytesToHex(bytes);
-}
-
-/** @deprecated Use makeMxAddress */
-export const encodeMx = makeMxAddress;
-/** @deprecated Use parseMxAddress */
-export const decodeMx = parseMxAddress;
-/** @deprecated Use hexToMx */
-export const makeMinimaAddress = hexToMx;
-/** @deprecated Use mxToHex */
-export const convertMinimaAddress = mxToHex;

package/src/minimaWireSerializer.d.ts

@@ -1,189 +0,0 @@
-/**
- * Minima Wire Format Serializer
- *
- * Byte-exact serialization matching Minima's Java Signature.java and SignatureProof.java
- *
- * Wire Format Reference:
- *
- * Signature.writeDataStream():
- *   1. MiniNumber - count of SignatureProofs
- *   2. For each SignatureProof.writeDataStream()
- *
- * SignatureProof.writeDataStream():
- *   1. MiniData (publicKey) - 4-byte big-endian length + bytes
- *   2. MiniData (signature) - 4-byte big-endian length + bytes
- *   3. MMRProof.writeDataStream()
- *
- * MMRProof.writeDataStream():
- *   1. MiniNumber (blockTime)
- *   2. MiniNumber (chain length)
- *   3. For each chunk:
- *      - MiniByte (isLeft) - 1 byte (0 or 1)
- *      - MMRData.writeDataStream():
- *        - hash (4-byte length prefix + 32 bytes via writeHashToStream)
- *        - value (MiniNumber)
- *
- * CRITICAL (2026-01): Java's writeHashToStream uses writeInt (4-byte prefix),
- * identical to writeDataStream. See MiniData.java lines 282-289.
- */
-export type Bytes = Uint8Array;
-/**
- * Serialize MiniNumber matching Java MiniNumber.writeDataStream()
- * Format: [scale: 1 byte] [length: 1 byte] [data: N bytes]
- *
- * Scale is always 0 for integers (no decimal places)
- * Length is 1 byte (NOT 4 bytes like MiniData)
- */
-export declare function serializeMiniNumber(value: bigint): Bytes;
-/**
- * Serialize MiniData matching Java MiniData.writeDataStream()
- * Format: [4-byte big-endian length] [data bytes]
- */
-export declare function serializeMiniData(data: Bytes): Bytes;
-/**
- * Write hash with 4-byte length prefix matching Java MiniData.writeHashToStream()
- *
- * From MiniData.java writeHashToStream (lines 282-289):
- *   zOut.writeInt(mData.length);  // 4-byte big-endian int
- *   zOut.write(mData);            // raw bytes
- *
- * CRITICAL: Java uses writeInt (4 bytes), same as writeDataStream!
- * The only difference is a max length check of 64 bytes (MINIMA_MAX_HASH_LENGTH).
- *
- * Used by MMRData.writeDataStream() for the hash field.
- */
-export declare function writeHashToStream(hash: Bytes): Bytes;
-/**
- * MMRData structure matching Minima's MMRData.java
- */
-export interface MMRData {
-    data: Bytes;
-    value: bigint;
-}
-/**
- * MMRProofChunk structure matching Minima's MMRProof.MMRProofChunk
- */
-export interface MMRProofChunk {
-    isLeft: boolean;
-    mmrData: MMRData;
-}
-/**
- * MMRProof structure matching Minima's MMRProof.java
- */
-export interface MMRProof {
-    chunks: MMRProofChunk[];
-}
-/**
- * Serialize MMRData matching Java MMRData.writeDataStream()
- *
- * CRITICAL FIX (2026-01): Analysis of coinexport output shows MMRData uses
- * MiniData format (4-byte length prefix + 32 bytes) for the hash field,
- * NOT raw 32 bytes. This matches what Minima's node produces.
- *
- * Format:
- *   - hash (MiniData: 4-byte length + 32 bytes)
- *   - value (MiniNumber)
- */
-export declare function serializeMMRData(mmrData: MMRData): Bytes;
-/**
- * Serialize MMRProof matching Java MMRProof.writeDataStream()
- *
- * Format:
- *   1. MiniNumber (blockTime) - always 0 for TreeKey proofs
- *   2. MiniNumber (chain length)
- *   3. For each chunk:
- *      - MiniByte (isLeft) - 1 byte
- *      - MMRData (hash + value)
- */
-export declare function serializeMMRProof(proof: MMRProof, blockTime?: bigint): Bytes;
-/**
- * SignatureProof structure matching Minima's SignatureProof.java
- */
-export interface SignatureProof {
-    publicKey: Bytes;
-    signature: Bytes;
-    proof: MMRProof;
-}
-/**
- * Serialize SignatureProof matching Java SignatureProof.writeDataStream()
- *
- * Format:
- *   1. MiniData (publicKey) - 4-byte length + bytes
- *   2. MiniData (signature) - 4-byte length + bytes
- *   3. MMRProof.writeDataStream()
- */
-export declare function serializeSignatureProof(sigProof: SignatureProof): Bytes;
-/**
- * Signature structure matching Minima's Signature.java
- */
-export interface Signature {
-    proofs: SignatureProof[];
-}
-/**
- * Serialize Signature matching Java Signature.writeDataStream()
- *
- * Format:
- *   1. MiniNumber - count of SignatureProofs
- *   2. For each SignatureProof.writeDataStream()
- *
- * From Signature.java:
- *   MiniNumber.WriteToStream(zOut, mSignatures.size());
- *   for(SignatureProof sig : mSignatures) {
- *       sig.writeDataStream(zOut);
- *   }
- */
-export declare function serializeSignature(signature: Signature): Bytes;
-/**
- * Convert hex string to bytes
- */
-export declare function fromHex(hex: string): Bytes;
-/**
- * Convert bytes to hex string with 0x prefix
- */
-export declare function toHex(bytes: Bytes): string;
-/**
- * Convert SignatureProofHex format (from TransactionService) to wire format bytes
- *
- * This is the main entry point for serializing hierarchical TreeKey signatures
- * for txnimport.
- */
-export interface SignatureProofHex {
-    leafPubkey: string;
-    signature: string;
-    mmrProof: string;
-}
-export interface HierarchicalWitnessBundle {
-    addressIndex: number;
-    l1: number;
-    l2: number;
-    rootPublicKey: string;
-    proofs: SignatureProofHex[];
-}
-/**
- * Serialize hierarchical witness bundle to Minima wire format
- *
- * This converts the HierarchicalWitnessBundle (with hex strings) to
- * the proper Witness signature format matching Witness.java → Signature.java hierarchy.
- *
- * CRITICAL FIX (2026-01): Must use double-nesting to match Java format:
- *   - Witness.writeDataStream writes: [signatureCount][Signature[0].writeDataStream()]...
- *   - Signature.writeDataStream writes: [proofCount][SignatureProof[0]]...
- *
- * So the final format is:
- *   [1] = signatureCount (we have 1 Signature object in Witness)
- *   [N] = proofCount inside that Signature (2 for address-based TreeKey)
- *   [SignatureProof[0]]
- *   [SignatureProof[1]]
- *
- * IMPORTANT: Uses pre-serialized MMR proof bytes directly to avoid
- * double-serialization (deserialize then re-serialize).
- */
-export declare function serializeHierarchicalWitness(bundle: HierarchicalWitnessBundle): Bytes;
-/**
- * @deprecated (2026-01) This function's output is NOT used in the main Totem transaction flow.
- * MinimaTransactionBuilder.serializeWitness in the extension handles actual witness serialization.
- * Kept for API compatibility and potential future direct SDK usage.
- *
- * Serialize hierarchical witness bundle to hex string for transport
- */
-export declare function serializeHierarchicalWitnessToHex(bundle: HierarchicalWitnessBundle): string;