@totemsdk/core 1.0.9 → 1.0.10

package/src/mmr.ts

@@ -1,429 +0,0 @@
-// packages/totem-sdk/packages/core/src/mmr.ts
-// Full MMR implementation matching Minima's MMR.java, MMRData.java, and TreeKeyNode.java
-import { sha3_256 as nobleSha3 } from '@noble/hashes/sha3.js';
-import { serializeMiniNumber, serializeMiniData, writeHashToStream, javaHashAllObjects } from "./javaStreamables.js";
-
-// Import canonical wire serialization from Streamable.ts (single source of truth)
-import { writeMMRProof, type MMRProof as StreamableMMRProof } from "./Streamable.js";
-
-// Re-export for API compatibility (existing code imports from mmr.ts)
-// Using a wrapper function for better compatibility with dynamic imports
-export function serializeMMRProof(proof: { chunks: Array<{ isLeft: boolean; mmrData: { data: Bytes; value: bigint } }> }, blockTime: bigint = 0n): Bytes {
-  // Convert to Streamable format and serialize
-  const streamableProof: StreamableMMRProof = {
-    blockTime: blockTime,
-    chunks: proof.chunks.map(c => ({
-      isLeft: c.isLeft,
-      mmrData: { data: c.mmrData.data, value: c.mmrData.value }
-    }))
-  };
-  return writeMMRProof(streamableProof);
-}
-
-export const serializeRealMMRProof = serializeMMRProof;
-
-export type Bytes = Uint8Array;
-
-/** SHA3-256 helper returning 32 bytes */
-function sha3(data: Bytes): Bytes {
-  return nobleSha3(data);
-}
-
-/** concat utility */
-function concat(...parts: Bytes[]): Bytes {
-  const total = parts.reduce((n, p) => n + p.length, 0);
-  const out = new Uint8Array(total);
-  let off = 0;
-  for (const p of parts) { out.set(p, off); off += p.length; }
-  return out;
-}
-
-/** big-endian u32 */
-const u32be = (n: number) => new Uint8Array([(n>>>24)&0xff,(n>>>16)&0xff,(n>>>8)&0xff,n&0xff]);
-
-/**
- * EXACT MiniNumber.ZERO wire format from Java:
- *   scale (1 byte) = 0x00
- *   length (1 byte) = 0x01
- *   unscaled bytes (length=1) = 0x00
- * => 00 01 00
- */
-function encodeMiniNumberZERO(): Bytes {
-  return new Uint8Array([0x00, 0x01, 0x00]);
-}
-
-/**
- * EXACT MiniString wire format (MiniData of UTF-8):
- *   4-byte big-endian length
- *   raw UTF-8 bytes
- */
-function encodeMiniStringUTF8(text: string): Bytes {
-  const utf8 = new TextEncoder().encode(text);
-  const len = u32be(utf8.length);
-  return concat(len, utf8);
-}
-
-/**
- * Byte-exact one-leaf MMR leaf used by Minima Address.java path:
- *   sha3( MiniNumber.ZERO || MiniString(script) || MiniNumber.ZERO )
- */
-export function mmrLeafExact(script: string): Bytes {
-  const zero = encodeMiniNumberZERO();
-  const mstr = encodeMiniStringUTF8(script);
-  const all  = concat(zero, mstr, zero);
-  return sha3(all); // 32-byte leaf hash
-}
-
-/** In a single-leaf MMR the root equals the leaf commitment. */
-export function mmrRootFromSingleLeaf(script: string): Bytes {
-  return mmrLeafExact(script);
-}
-
-// ============================================================================
-// MMR Tree Implementation matching Minima's MMR.java and MMRData.java
-// Used by TreeKeyNode for computing wallet public key from 64 Winternitz keys
-// ============================================================================
-
-/**
- * MMRData structure matching Minima's MMRData.java
- * Contains hash and value (for sum tree functionality)
- */
-export interface MMRData {
-  data: Bytes;    // 32-byte hash
-  value: bigint;  // Sum value (always 0n for TreeKeyNode)
-}
-
-/**
- * MMREntry structure matching Minima's MMREntry.java
- * Represents a node in the MMR at a specific row and position
- */
-export interface MMREntry {
-  row: number;           // Tree level (0 = leaves)
-  entryNumber: bigint;   // Position within the row
-  mmrData: MMRData;
-}
-
-/**
- * MMRProofChunk - one step in the proof path
- * Matches Minima's MMRProof structure
- */
-export interface MMRProofChunk {
-  isLeft: boolean;   // Is this sibling on the left?
-  mmrData: MMRData;  // Sibling's data
-}
-
-/**
- * MMRProof structure matching Minima's MMRProof.java
- * Contains proof chunks to verify leaf membership in the tree
- */
-export interface MMRProof {
-  chunks: MMRProofChunk[];
-}
-
-/**
- * Create MMRData leaf node matching Minima's MMRData.CreateMMRDataLeafNode
- * 
- * From MMRData.java:
- *   MiniData hash = Crypto.getInstance().hashAllObjects(MiniNumber.ZERO, zData, zSumValue);
- * 
- * CRITICAL: Crypto.hashAllObjects uses writeDataStream for Streamables:
- * - MiniNumber: scale + len + data (see serializeMiniNumber)
- * - MiniData: 4-byte length + data (see serializeMiniData)
- * 
- * For TreeKeyNode, zData is the Winternitz public key (MiniData) and zSumValue is ZERO
- * 
- * Serialization order:
- * 1. MiniNumber.ZERO: [0x00, 0x01, 0x00]
- * 2. MiniData (pubkey): [4-byte length] + [bytes] (writeDataStream, NOT writeHashToStream)
- * 3. MiniNumber.ZERO: [0x00, 0x01, 0x00]
- */
-export function createMMRDataLeafNode(pubkey: Bytes, sumValue: bigint = 0n): MMRData {
-  // Use cached ZERO serialization for efficiency
-  const zero = new Uint8Array([0x00, 0x01, 0x00]); // MiniNumber.ZERO
-  
-  // IMPORTANT: hashAllObjects uses writeDataStream which is 4-byte length prefixed
-  const pubkeySerialized = serializeMiniData(pubkey);
-  
-  // For sumValue, serialize as MiniNumber
-  let sumSerialized: Uint8Array;
-  if (sumValue === 0n) {
-    sumSerialized = new Uint8Array([0x00, 0x01, 0x00]); // MiniNumber.ZERO
-  } else {
-    sumSerialized = serializeMiniNumber(Number(sumValue));
-  }
-  
-  const hash = javaHashAllObjects(zero, pubkeySerialized, sumSerialized);
-  return { data: hash, value: sumValue };
-}
-
-/**
- * Create MMRData parent node matching Minima's MMRData.CreateMMRDataParentNode
- * 
- * From MMRData.java:
- *   MiniNumber sumvalue = zLeft.getValue().add(zRight.getValue());
- *   MiniData combinedhash = Crypto.getInstance().hashAllObjects(
- *     MiniNumber.ONE, zLeft.getData(), zRight.getData(), sumvalue);
- * 
- * CRITICAL: The getData() returns MiniData (the hash), which is serialized
- * with writeDataStream (4-byte length) in hashAllObjects.
- * 
- * Serialization order:
- * 1. MiniNumber.ONE: [0x00, 0x01, 0x01]
- * 2. MiniData (left.data): [4-byte length] + [bytes]
- * 3. MiniData (right.data): [4-byte length] + [bytes]
- * 4. MiniNumber (sumvalue): serialized MiniNumber
- */
-export function createMMRDataParentNode(left: MMRData, right: MMRData): MMRData {
-  const sumValue = left.value + right.value;
-  
-  // MiniNumber.ONE: [0x00, 0x01, 0x01]
-  const one = new Uint8Array([0x00, 0x01, 0x01]);
-  
-  // Serialize left and right data as MiniData (4-byte length-prefixed)
-  const leftDataSerialized = serializeMiniData(left.data);
-  const rightDataSerialized = serializeMiniData(right.data);
-  
-  // Serialize sum value
-  let sumSerialized: Uint8Array;
-  if (sumValue === 0n) {
-    sumSerialized = new Uint8Array([0x00, 0x01, 0x00]); // MiniNumber.ZERO
-  } else {
-    sumSerialized = serializeMiniNumber(Number(sumValue));
-  }
-  
-  const hash = javaHashAllObjects(one, leftDataSerialized, rightDataSerialized, sumSerialized);
-  return { data: hash, value: sumValue };
-}
-
-/**
- * Simple MMR Tree for TreeKeyNode
- * Builds a perfect binary tree from N entries (N must be power of 2 for simplicity)
- * 
- * This matches TreeKeyNode.java which always uses 64 leaves (2^6)
- */
-export class MMRTree {
-  private entries: Map<string, MMREntry> = new Map();
-  private leafCount: number = 0;
-  private maxRow: number = 0;
-  
-  private getKey(row: number, entryNumber: bigint): string {
-    return `${row}:${entryNumber}`;
-  }
-  
-  private setEntry(row: number, entryNumber: bigint, data: MMRData): MMREntry {
-    const entry: MMREntry = { row, entryNumber, mmrData: data };
-    this.entries.set(this.getKey(row, entryNumber), entry);
-    if (row > this.maxRow) this.maxRow = row;
-    return entry;
-  }
-  
-  private getEntry(row: number, entryNumber: bigint): MMREntry | undefined {
-    return this.entries.get(this.getKey(row, entryNumber));
-  }
-  
-  /**
-   * Add a leaf entry to the MMR
-   * Matches MMR.java addEntry() but simplified for power-of-2 trees
-   */
-  addLeaf(data: MMRData): MMREntry {
-    const entryNumber = BigInt(this.leafCount);
-    const entry = this.setEntry(0, entryNumber, data);
-    this.leafCount++;
-    
-    // Propagate up the tree
-    let current = entry;
-    while (current.entryNumber % 2n === 1n) { // Is right child
-      const siblingNumber = current.entryNumber - 1n;
-      const sibling = this.getEntry(current.row, siblingNumber);
-      if (!sibling) break;
-      
-      // Create parent node
-      const parentData = createMMRDataParentNode(sibling.mmrData, current.mmrData);
-      const parentRow = current.row + 1;
-      const parentEntry = current.entryNumber / 2n;
-      current = this.setEntry(parentRow, parentEntry, parentData);
-    }
-    
-    return entry;
-  }
-  
-  /**
-   * Build tree from array of Winternitz public keys
-   * Used by TreeKeyNode to compute wallet public key
-   */
-  static fromPublicKeys(pubkeys: Bytes[]): MMRTree {
-    const tree = new MMRTree();
-    for (const pk of pubkeys) {
-      const leafData = createMMRDataLeafNode(pk, 0n);
-      tree.addLeaf(leafData);
-    }
-    return tree;
-  }
-  
-  /**
-   * Get the root of the tree
-   * For a perfect binary tree with N leaves, root is at row log2(N), entry 0
-   */
-  getRoot(): MMRData | null {
-    if (this.leafCount === 0) return null;
-    
-    // For power of 2 leaves, there's exactly one peak at the top
-    const topRow = Math.floor(Math.log2(this.leafCount));
-    const root = this.getEntry(topRow, 0n);
-    return root?.mmrData || null;
-  }
-  
-  /**
-   * Get proof for a leaf at given index
-   * Matches MMR.java getProofToPeak()
-   */
-  getProof(leafIndex: number): MMRProof {
-    const chunks: MMRProofChunk[] = [];
-    let row = 0;
-    let entryNumber = BigInt(leafIndex);
-    
-    // Walk up the tree collecting siblings
-    while (row < this.maxRow) {
-      const siblingNumber = entryNumber % 2n === 0n 
-        ? entryNumber + 1n  // Current is left, sibling is right
-        : entryNumber - 1n; // Current is right, sibling is left
-      
-      const sibling = this.getEntry(row, siblingNumber);
-      if (!sibling) break;
-      
-      const isLeft = siblingNumber < entryNumber;
-      chunks.push({ isLeft, mmrData: sibling.mmrData });
-      
-      // Move to parent
-      row++;
-      entryNumber = entryNumber / 2n;
-    }
-    
-    return { chunks };
-  }
-  
-  /**
-   * Get the leaf MMRData at a specific index
-   */
-  getLeaf(index: number): MMRData | null {
-    const entry = this.getEntry(0, BigInt(index));
-    return entry?.mmrData || null;
-  }
-}
-
-/**
- * Calculate root from leaf data and proof
- * Matches SignatureProof.getRootPublicKey() in Java
- * 
- * From SignatureProof.java:
- *   MMRData pubentry = MMRData.CreateMMRDataLeafNode(mPublicKey, MiniNumber.ZERO);
- *   return mProof.calculateProof(pubentry).getData();
- */
-export function calculateProofRoot(leafData: MMRData, proof: MMRProof): Bytes {
-  let current = leafData;
-  
-  for (const chunk of proof.chunks) {
-    if (chunk.isLeft) {
-      // Sibling is on the left, current is on the right
-      current = createMMRDataParentNode(chunk.mmrData, current);
-    } else {
-      // Sibling is on the right, current is on the left
-      current = createMMRDataParentNode(current, chunk.mmrData);
-    }
-  }
-  
-  return current.data;
-}
-
-/**
- * Verify a proof: check that leaf + proof computes to expected root
- */
-export function verifyMMRProof(leafPubkey: Bytes, proof: MMRProof, expectedRoot: Bytes): boolean {
-  const leafData = createMMRDataLeafNode(leafPubkey, 0n);
-  const computedRoot = calculateProofRoot(leafData, proof);
-  
-  if (computedRoot.length !== expectedRoot.length) return false;
-  for (let i = 0; i < computedRoot.length; i++) {
-    if (computedRoot[i] !== expectedRoot[i]) return false;
-  }
-  return true;
-}
-
-// NOTE: serializeMMRProof is now imported from minimaWireSerializer.ts and re-exported above
-// This consolidates wire format serialization into a single source of truth.
-
-/**
- * Deserialize MMRProof from bytes matching Minima's MMRProof.readDataStream()
- * 
- * Format:
- *   1. blockTime (MiniNumber)
- *   2. chain length (MiniNumber)
- *   3. Each chunk: isLeft (1 byte) + MMRData (hash with 4-byte length prefix + value MiniNumber)
- * 
- * CRITICAL: Java MMRData.readDataStream uses mData.readHashFromStream() which reads
- * a 4-byte big-endian length prefix followed by the hash bytes.
- * 
- * @returns { proof: MMRProof, blockTime: bigint }
- */
-export function parseMMRProofFromHex(data: Bytes): { proof: MMRProof; blockTime: bigint; bytesRead: number } {
-  let offset = 0;
-  
-  // Read blockTime as MiniNumber
-  const { value: blockTime, bytesRead: btRead } = readMiniNumber(data, offset);
-  offset += btRead;
-  
-  // Read chain length as MiniNumber
-  const { value: numChunks, bytesRead: ncRead } = readMiniNumber(data, offset);
-  offset += ncRead;
-  
-  const chunks: MMRProofChunk[] = [];
-  for (let i = 0; i < Number(numChunks); i++) {
-    // isLeft flag (1 byte)
-    const isLeft = data[offset] === 1;
-    offset += 1;
-    
-    // MMRData: hash (4-byte length prefix + hash bytes) + value (MiniNumber)
-    // Read 4-byte big-endian length
-    const hashLength = (data[offset] << 24) | (data[offset + 1] << 16) | (data[offset + 2] << 8) | data[offset + 3];
-    offset += 4;
-    const hashData = data.slice(offset, offset + hashLength);
-    offset += hashLength;
-    
-    const { value: chunkValue, bytesRead: cvRead } = readMiniNumber(data, offset);
-    offset += cvRead;
-    
-    chunks.push({ isLeft, mmrData: { data: hashData, value: chunkValue } });
-  }
-  
-  return { proof: { chunks }, blockTime, bytesRead: offset };
-}
-
-/**
- * Read a MiniNumber from bytes at the given offset
- * Format: [scale: 1 byte] [length: 1 byte] [data: N bytes]
- */
-function readMiniNumber(data: Bytes, offset: number): { value: bigint; bytesRead: number } {
-  const scale = data[offset];
-  const length = data[offset + 1];
-  
-  if (length === 0) {
-    // Zero value (shouldn't happen with proper serialization)
-    return { value: 0n, bytesRead: 2 };
-  }
-  
-  const dataBytes = data.slice(offset + 2, offset + 2 + length);
-  
-  // Convert bytes to bigint
-  let value = 0n;
-  for (let i = 0; i < dataBytes.length; i++) {
-    value = (value << 8n) | BigInt(dataBytes[i]);
-  }
-  
-  // Apply scale if non-zero (for decimal numbers)
-  // For TreeKey MMR, scale is always 0
-  
-  return { value, bytesRead: 2 + length };
-}
-
-/** @deprecated Use parseMMRProofFromHex */
-export const deserializeMMRProof = parseMMRProofFromHex;

package/src/mx.test.ts

@@ -1,25 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { makeMinimaAddress, convertMinimaAddress } from "../src/mx";
-
-describe("Mx address compat", () => {
-  it("roundtrips fixed vector", () => {
-    const hex = "0x01E41FCB7F956F510CA1F656C8CF991594BEE6F3A05F489EDA5798F485F21026";
-    const mx  = "MxG0801SGFSMVSYDT8GP8FMAR4CV68YWWVEDST0BT49TMWNJ3Q8BSGG4PT3A5RW";
-
-    expect(makeMinimaAddress(hex)).toBe(mx);
-    expect(convertMinimaAddress(mx)).toBe(hex.toUpperCase());
-  });
-
-  it("various lengths behave like Java tests", () => {
-    const samples = [
-      "0xFFFF",
-      "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
-      "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
-    ];
-    for (const h of samples) {
-      const mx = makeMinimaAddress(h);
-      const back = convertMinimaAddress(mx);
-      expect(back).toBe(h.toUpperCase());
-    }
-  });
-});

package/src/mx.ts

@@ -1 +0,0 @@
-export { hexToMx, mxToHex, makeMinimaAddress, convertMinimaAddress, encodeMx, decodeMx } from './minima32.js';

package/src/params.d.ts

@@ -1,29 +0,0 @@
-/**
- * WOTS Parameter Set - BouncyCastle Compatible (w=8)
- *
- * Matches Minima Java implementation which uses BouncyCastle:
- * - Winternitz.java: WINTERNITZ_VALUE = 8
- * - WinternitzOTSignature.java: w=8 means 8 BITS per digit (not base-8)
- * - SHA3-256 hash function (mdsize = 32 bytes)
- *
- * Chain count calculation (from WinternitzOTSignature constructor):
- *   messagesize = ((mdsize << 3) + w - 1) / w = (256 + 7) / 8 = 32
- *   checksumsize = getLog((messagesize << w) + 1) = getLog(8193) = 14 bits
- *   keysize = messagesize + (checksumsize + w - 1) / w = 32 + (14 + 7) / 8 = 34
- *
- * So L = 34 chains total, each chain value is 0-255 (8-bit digit)
- */
-export type ParamSet = {
-    name: 'minima';
-    n: 256;
-    w: 8;
-    L: 34;
-    messageSize: 32;
-    checksumSize: 14;
-    checksumDigits: 2;
-    maxDigit: 255;
-};
-export declare const WOTS_MINIMA: ParamSet;
-export declare const WOTS_V1_DEV: ParamSet;
-export declare const WOTS_V2_SPEC: ParamSet;
-export declare function getParamSet(_env?: string): ParamSet;

package/src/params.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"params.d.ts","sourceRoot":"","sources":["params.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAC;IAC3B,CAAC,EAAE,GAAG,CAAC;IACP,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,QAMzB,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,QAM1B,CAAC;AAEF,wBAAgB,WAAW,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,QAAQ,CAGlD"}

package/src/params.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WOTS_V2_SPEC = exports.WOTS_V1_DEV = exports.WOTS_MINIMA = void 0;
-exports.getParamSet = getParamSet;
-exports.WOTS_MINIMA = {
-    name: 'minima',
-    n: 256,
-    w: 8,
-    L: 34,
-    messageSize: 32,
-    checksumSize: 14,
-    checksumDigits: 2,
-    maxDigit: 255,
-};
-// Legacy aliases for backwards compatibility during migration
-exports.WOTS_V1_DEV = exports.WOTS_MINIMA;
-exports.WOTS_V2_SPEC = exports.WOTS_MINIMA;
-function getParamSet(_env) {
-    return exports.WOTS_MINIMA;
-}

package/src/params.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"params.js","sourceRoot":"","sources":["params.ts"],"names":[],"mappings":";;;AAwBA,kCAGC;AAnBY,QAAA,WAAW,GAAa;IACnC,IAAI,EAAE,QAAQ;IACd,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,CAAC;IACJ,CAAC,EAAE,EAAE;IACL,GAAG,EAAE,eAAe;CACrB,CAAC;AAEW,QAAA,YAAY,GAAa;IACpC,IAAI,EAAE,SAAS;IACf,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,EAAE;IACL,GAAG,EAAE,eAAe;CACrB,CAAC;AAEF,SAAgB,WAAW,CAAC,GAAY;IACtC,MAAM,GAAG,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,OAAO,KAAK,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC,CAAC,WAAW,EAAE,CAAC;IAC1H,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,mBAAW,CAAC,CAAC,CAAC,oBAAY,CAAC;AACvD,CAAC"}

package/src/params.ts

@@ -1,44 +0,0 @@
-/**
- * WOTS Parameter Set - BouncyCastle Compatible (w=8)
- * 
- * Matches Minima Java implementation which uses BouncyCastle:
- * - Winternitz.java: WINTERNITZ_VALUE = 8
- * - WinternitzOTSignature.java: w=8 means 8 BITS per digit (not base-8)
- * - SHA3-256 hash function (mdsize = 32 bytes)
- * 
- * Chain count calculation (from WinternitzOTSignature constructor):
- *   messagesize = ((mdsize << 3) + w - 1) / w = (256 + 7) / 8 = 32
- *   checksumsize = getLog((messagesize << w) + 1) = getLog(8193) = 14 bits
- *   keysize = messagesize + (checksumsize + w - 1) / w = 32 + (14 + 7) / 8 = 34
- * 
- * So L = 34 chains total, each chain value is 0-255 (8-bit digit)
- */
-export type ParamSet = {
-  name: 'minima';
-  n: 256;           // hash output bits
-  w: 8;             // Winternitz parameter: 8 BITS per digit
-  L: 34;            // Total chains: 32 message + 2 checksum
-  messageSize: 32;  // Number of message digits
-  checksumSize: 14; // Checksum bits
-  checksumDigits: 2; // Number of checksum digits
-  maxDigit: 255;    // Maximum digit value (2^w - 1)
-};
-
-export const WOTS_MINIMA: ParamSet = { 
-  name: 'minima', 
-  n: 256, 
-  w: 8, 
-  L: 34,
-  messageSize: 32,
-  checksumSize: 14,
-  checksumDigits: 2,
-  maxDigit: 255,
-};
-
-// Legacy aliases for backwards compatibility during migration
-export const WOTS_V1_DEV = WOTS_MINIMA;
-export const WOTS_V2_SPEC = WOTS_MINIMA;
-
-export function getParamSet(_env?: string): ParamSet {
-  return WOTS_MINIMA;
-}

package/src/script.d.ts

@@ -1,7 +0,0 @@
-import type { WotsKeypair } from "./wots";
-/** Produce KISSVM script that authorizes with a WOTS PK digest (32 bytes). */
-export declare function scriptFromWotsPk(pkDigest32: Uint8Array): string;
-/** Address from WOTS keypair (client-only): script -> MMR leaf -> Mx */
-export declare function wotsAddressFromKeypair(kp: WotsKeypair): string;
-/** tiny utils */
-export declare function hexToBytes(hex: string): Uint8Array;

package/src/script.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.scriptFromWotsPk = scriptFromWotsPk;
-exports.wotsAddressFromKeypair = wotsAddressFromKeypair;
-exports.hexToBytes = hexToBytes;
-const util_1 = require("./util");
-const derive_1 = require("./derive");
-/** Produce KISSVM script that authorizes with a WOTS PK digest (32 bytes). */
-function scriptFromWotsPk(pkDigest32) {
-    // Minima uses SHA3-256 in SIGNEDBY paths; here we embed the digest as hex.
-    return `RETURN SIGNEDBY(${(0, util_1.bytesToHex)(pkDigest32)})`;
-}
-/** Address from WOTS keypair (client-only): script -> MMR leaf -> Mx */
-function wotsAddressFromKeypair(kp) {
-    const script = scriptFromWotsPk(kp.pk);
-    return (0, derive_1.scriptToAddress)(script);
-}
-/** tiny utils */
-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;
-}

package/src/script.ts

@@ -1,24 +0,0 @@
-import { bytesToHex } from "./util.js";
-import { scriptToAddress } from "./derive.js";
-import type { WotsKeypair } from "./wots.js";
-
-/** Produce KISSVM script that authorizes with a WOTS PK digest (32 bytes). */
-export function scriptFromWotsPk(pkDigest32: Uint8Array): string {
-  // Minima uses SHA3-256 in SIGNEDBY paths; here we embed the digest as hex.
-  return `RETURN SIGNEDBY(${bytesToHex(pkDigest32)})`;
-}
-
-/** Address from WOTS keypair (client-only): script -> MMR leaf -> Mx */
-export function wotsAddressFromKeypair(kp: WotsKeypair): string {
-  const script = scriptFromWotsPk(kp.pk);
-  return scriptToAddress(script);
-}
-
-/** tiny utils */
-export 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;
-}