@knuth/js-wasm 2.11.0 → 4.0.0

package/types/Program.d.ts

@@ -1,11 +1,24 @@
-import { ProgramNative } from './wasm/glue';
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 import { Script } from './Script';
 import { Transaction } from './Transaction';
+import { ProgramNative } from './wasm/glue';
+export declare const UNKNOWN_SPENT_VALUE = 18446744073709551615n;
 export declare class Program {
     private native;
+    private ownsNative;
+    private readonly lifetime;
+    private disposed;
+    constructor(script?: Script, programOrTransaction?: Program | Transaction, inputIndex?: number, flags?: bigint, value?: bigint);
+    constructor(script?: Script, programOrTransaction?: Program | Transaction);
     constructor(native: ProgramNative);
-    constructor(script?: Script, programOrTransaction?: Program | Transaction, inputIndex?: number, forks?: number);
+    static adopt(native: ProgramNative, dependsOn?: Array<Program>): Program;
+    private live;
+    dispose(): void;
     toNative(): ProgramNative;
+    copy(): Program;
     get valid(): boolean;
     evaluate(): number;
     stackResult(clean: boolean): boolean;

package/types/RuleFork.d.ts

@@ -1,3 +1,7 @@
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 export declare class RuleFork {
     static forkMinYear: number;
     static forkMaxYear: number;

package/types/Script.d.ts

@@ -1,27 +1,41 @@
-import { ScriptNative, EndorsementType } from './wasm/glue';
-import { Operation } from './Operation';
-import { Transaction } from './Transaction';
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 import { ShortHash } from './Hash';
+import { Operation } from './Operation';
 import { EcSecret } from './Secret';
+import { Transaction } from './Transaction';
+import { EndorsementType, ScriptNative, ScriptPattern } from './wasm/glue';
+export type EndorsementResult = {
+    success: true;
+    errorCode: 0;
+    data: Uint8Array;
+} | {
+    success: false;
+    errorCode: number;
+};
+export declare class EndorsementError extends Error {
+    readonly errorCode: number;
+    constructor(errorCode: number);
+}
 export declare class Script {
     private encoded;
     private prefix;
     static fromNative(native: ScriptNative, destroy?: boolean): Script;
+    constructor(encoded: Uint8Array, prefix: boolean);
+    toNative(): ScriptNative;
     static fromData(encoded: Uint8Array, prefix: boolean): Script | undefined;
     static fromString(str: string): Script | undefined;
     static fromOperations(operations: Array<Operation>): Script | undefined;
     static isValid(encoded: Uint8Array, prefix: boolean): boolean;
-    constructor(encoded: Uint8Array, prefix: boolean);
-    toNative(): ScriptNative;
     get valid(): boolean;
     get isValidOperations(): boolean;
-    get satoshiContentSize(): number;
     get serializedSize(): number;
-    get type(): string;
-    get operations(): Operation[];
-    toString(activeForks: number): string;
-    toData(prefix: boolean): Uint8Array<ArrayBufferLike>;
-    toBytes(): Uint8Array<ArrayBufferLike>;
+    get operations(): Array<Operation>;
+    toString(activeFlags: bigint): string;
+    toData(prefix: boolean): Uint8Array;
+    toBytes(): Uint8Array;
     static isPushOnly(ops: Array<Operation>): boolean;
     static isRelaxedPush(ops: Array<Operation>): boolean;
     static isCoinbasePattern(ops: Array<Operation>, height: number): boolean;
@@ -33,19 +47,20 @@ export declare class Script {
     static isSignPublicKeyPattern(ops: Array<Operation>): boolean;
     static isSignPublicKeyHashPattern(ops: Array<Operation>): boolean;
     static isSignScriptHashPattern(ops: Array<Operation>): boolean;
-    static toNullDataPattern(data: Uint8Array): Array<Operation>;
-    static toPayPublicKeyPattern(point: Uint8Array): Array<Operation>;
+    static toNullDataPattern(data: Uint8Array): Array<Operation> | undefined;
+    static toPayPublicKeyPattern(point: Uint8Array): Array<Operation> | undefined;
     static toPayPublicKeyHashPattern(hash: ShortHash): Array<Operation>;
     static toPayScriptHashPattern(hash: ShortHash): Array<Operation>;
-    pattern(): "null_data" | "pay_multisig" | "pay_public_key" | "pay_public_key_hash" | "pay_script_hash" | "sign_multisig" | "sign_public_key" | "sign_public_key_hash" | "sign_script_hash" | "witness_reservation" | "non_standard";
-    outputPattern(): "null_data" | "pay_multisig" | "pay_public_key" | "pay_public_key_hash" | "pay_script_hash" | "sign_multisig" | "sign_public_key" | "sign_public_key_hash" | "sign_script_hash" | "witness_reservation" | "non_standard";
-    inputPattern(): "null_data" | "pay_multisig" | "pay_public_key" | "pay_public_key_hash" | "pay_script_hash" | "sign_multisig" | "sign_public_key" | "sign_public_key_hash" | "sign_script_hash" | "witness_reservation" | "non_standard";
+    pattern(): ScriptPattern;
+    outputPattern(): ScriptPattern;
+    inputPattern(): ScriptPattern;
     get sigops(): number;
     get sigopsAccurate(): number;
     get isUnspendable(): boolean;
     reset(): void;
-    static createEndorsement(secret: EcSecret, prevoutScript: Script, tx: Transaction, inputIndex: number, sighashType: number, activeForks: number, value: bigint, endorsementType: EndorsementType): Uint8Array;
-    static verify(tx: Transaction, input: number, forks: number, inputScript: Script, prevoutScript: Script, value: bigint): number;
-    static verifyTransaction(tx: Transaction, input: number, forks: number): number;
+    static createEndorsementResult(secret: EcSecret, prevoutScript: Script, tx: Transaction, inputIndex: number, sighashType: number, activeFlags: bigint, value: bigint, endorsementType: EndorsementType): EndorsementResult;
+    static createEndorsement(secret: EcSecret, prevoutScript: Script, tx: Transaction, inputIndex: number, sighashType: number, activeFlags: bigint, value: bigint, endorsementType: EndorsementType): Uint8Array;
+    static verify(tx: Transaction, input: number, flags: bigint, inputScript: Script, prevoutScript: Script, value: bigint): number;
+    static verifyTransaction(tx: Transaction, input: number, flags: bigint): number;
 }
 export default Script;

package/types/ScriptFlags.d.ts

@@ -0,0 +1,67 @@
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+export declare const ScriptFlags: Readonly<{
+    noRules: 0n;
+    easyBlocks: 1n;
+    bip16Rule: 2n;
+    bip30Rule: 4n;
+    bip34Rule: 8n;
+    bip66Rule: 16n;
+    bip65Rule: 32n;
+    bip90Rule: 64n;
+    allowCollisions: 128n;
+    bip68Rule: 256n;
+    bip112Rule: 512n;
+    bip113Rule: 1024n;
+    bchStrictenc: 2048n;
+    bchSighashForkid: 4096n;
+    bchLowS: 8192n;
+    bchNullfail: 16384n;
+    bchReactivatedOpcodes: 32768n;
+    bchSigpushonly: 65536n;
+    bchCleanstack: 131072n;
+    bchSchnorrMultisig: 262144n;
+    bchMinimaldata: 524288n;
+    bchEnforceSigchecks: 1048576n;
+    bch64bitIntegers: 2097152n;
+    bchNativeIntrospection: 4194304n;
+    bchP2sh32: 8388608n;
+    bchTokens: 16777216n;
+    bchVmLimits: 33554432n;
+    bchBigint: 67108864n;
+    bchLoops: 134217728n;
+    bchSubroutines: 268435456n;
+    bchBitwiseOps: 536870912n;
+    bchP2s: 1073741824n;
+    bch2027May: 2147483648n;
+    bchVmLimitsStandard: 144115188075855872n;
+    bchMinimalif: 288230376151711744n;
+    bchInputSigchecks: 576460752303423488n;
+    bchDiscourageUpgradableNops: 1152921504606846976n;
+    bchDisallowSegwitRecovery: 2305843009213693952n;
+    retarget: 4611686018427387904n;
+    unverified: 9223372036854775808n;
+    allPolicyFlags: 4467570830351532032n;
+    allRules: 144115188075855871n;
+    allBits: 18446744073709551615n;
+    standardPolicyFlags: 4467570830351532032n;
+}>;
+export declare const ScriptUpgrades: Readonly<{
+    bip34Activations: 56n;
+    bchUahf: 6144n;
+    bchDaaCw144: 30720n;
+    bchPythagoras: 63488n;
+    bchEuclid: 260096n;
+    bchPisano: 260096n;
+    bchMersenne: 1046528n;
+    bchFermat: 2095104n;
+    bchEuler: 2095104n;
+    bchGauss: 8386560n;
+    bchDescartes: 33552384n;
+    bchLobachevski: 33552384n;
+    bchGalois: 134215680n;
+    bchLeibniz: 2147481600n;
+    bchCantor: 4294965248n;
+}>;

package/types/Secret.d.ts

@@ -1,3 +1,7 @@
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 export type EcSecret = Uint8Array & {
     length: 32;
 };

package/types/SecretFunctions.d.ts

@@ -1,3 +1,7 @@
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 import { EcSecretNative } from './wasm/glue';
 import { EcSecret } from './Secret';
 export declare class SecretFunctions {

package/types/SighashAlgorithm.d.ts

@@ -1,3 +1,7 @@
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 export declare class SighashAlgorithm {
     static all: number;
     static none: number;

package/types/SighashGuard.d.ts

@@ -0,0 +1,10 @@
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+import type { Transaction } from './Transaction';
+export type SighashRefusal = {
+    success: false;
+    errorCode: number;
+};
+export declare function refuseSighashUtxos(tx: Transaction, sighashType: number, activeFlags: bigint): SighashRefusal | undefined;

package/types/StringList.d.ts

@@ -1,6 +1,7 @@
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 import { StringListNative } from './wasm/glue';
-export declare class StringList {
-    static fromNative(native: StringListNative): Array<string>;
-    static toNative(strings: Array<string>): StringListNative;
-}
+export declare const StringList: import("./ListHelper").ListAdapter<string, StringListNative>;
 export default StringList;

package/types/TokenData.d.ts

@@ -1,8 +1,12 @@
-import { TokenDataNative } from './wasm/glue';
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 import { Hash } from './Hash';
+import { TokenDataBothKinds } from './TokenDataBothKinds';
 import { TokenDataFungible } from './TokenDataFungible';
 import { TokenDataNonFungible } from './TokenDataNonFungible';
-import { TokenDataBothKinds } from './TokenDataBothKinds';
+import { TokenDataNative } from './wasm/glue';
 export type TokenDataInternal = TokenDataFungible | TokenDataNonFungible | TokenDataBothKinds;
 export declare class TokenData {
     category?: Hash;
@@ -11,8 +15,9 @@ export declare class TokenData {
     constructor(category?: Hash, data?: TokenDataInternal);
     get valid(): boolean;
     get kind(): 'fungible' | 'non_fungible' | 'both' | undefined;
+    private tryToNative;
     toNative(): TokenDataNative;
     serializedSize(): number;
-    toData(): Uint8Array<ArrayBufferLike>;
+    toData(): Uint8Array;
 }
 export default TokenData;

package/types/TokenDataBothKinds.d.ts

@@ -1,9 +1,12 @@
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 import { TokenDataFungible } from './TokenDataFungible';
-import { TokenDataNonFungible } from './TokenDataNonFungible';
-import { TokenCapability } from './wasm/glue';
+import { TokenCapabilityName, TokenDataNonFungible } from './TokenDataNonFungible';
 export declare class TokenDataBothKinds {
     fungible: TokenDataFungible;
     nonFungible: TokenDataNonFungible;
-    constructor(amount: bigint, capability: TokenCapability, commitment: Uint8Array);
+    constructor(amount: bigint, capability: TokenCapabilityName, commitment: Uint8Array);
 }
 export default TokenDataBothKinds;

package/types/TokenDataFungible.d.ts

@@ -1,3 +1,7 @@
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 export declare class TokenDataFungible {
     amount: bigint;
     constructor(amount: bigint);

package/types/TokenDataNonFungible.d.ts

@@ -1,7 +1,14 @@
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 import { TokenCapability } from './wasm/glue';
+export type TokenCapabilityName = 'none' | 'mutable' | 'minting';
+export declare function capabilityToNative(value: TokenCapabilityName): TokenCapability;
+export declare function capabilityFromNative(value: TokenCapability): TokenCapabilityName;
 export declare class TokenDataNonFungible {
-    capability: TokenCapability;
+    capability: TokenCapabilityName;
     commitment: Uint8Array;
-    constructor(capability: TokenCapability, commitment: Uint8Array);
+    constructor(capability: TokenCapabilityName, commitment: Uint8Array);
 }
 export default TokenDataNonFungible;

package/types/Transaction.d.ts

@@ -1,30 +1,32 @@
-import { TransactionNative, CoinSelectionAlgorithm } from './wasm/glue';
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 import { Hash } from './Hash';
 import { Input } from './Input';
 import { Output } from './Output';
-import { PaymentAddress } from './PaymentAddress';
-import { Utxo } from './Utxo';
+import { TransactionNative } from './wasm/glue';
 export declare class Transaction {
     version?: number;
     locktime?: number;
     inputs?: Array<Input>;
     outputs?: Array<Output>;
     static fromNative(native: TransactionNative, destroy?: boolean): Transaction;
-    static fromData(data: Uint8Array): Transaction | undefined;
-    static isValid(data: Uint8Array): boolean;
     constructor(version?: number, locktime?: number, inputs?: Array<Input>, outputs?: Array<Output>);
-    get valid(): boolean;
     toNative(): TransactionNative;
-    serializedSize(wire: boolean): number;
-    toData(wire: boolean): Uint8Array<ArrayBufferLike>;
+    get valid(): boolean;
+    serializedSize(wire?: boolean): number;
+    toData(wire: boolean): Uint8Array;
+    private static decode;
+    static fromData(data: Uint8Array): Transaction | undefined;
+    static isValid(data: Uint8Array): boolean;
     clone(): Transaction | undefined;
+    static hasSameSigningStructure(template: Transaction, signed: Transaction): boolean;
     get hash(): Hash;
     get isCoinbase(): boolean;
     get totalInputValue(): bigint;
     get totalOutputValue(): bigint;
     get fees(): bigint;
     isMature(targetHeight: number): boolean;
-    static createTemplateWithChangeRatios(availableUtxos: Array<Utxo>, amountToSend: bigint, destinationAddress: PaymentAddress, changeAddresses: Array<PaymentAddress>, changeRatios: Array<number>, selectionAlgo: CoinSelectionAlgorithm): [number, Transaction | undefined, Array<number> | undefined, Array<PaymentAddress> | undefined, Array<bigint> | undefined];
-    static createTemplate(availableUtxos: Array<Utxo>, amountToSend: bigint, destinationAddress: PaymentAddress, changeAddresses: Array<PaymentAddress>, selectionAlgo: CoinSelectionAlgorithm): [number, Transaction | undefined, Array<number> | undefined, Array<PaymentAddress> | undefined, Array<bigint> | undefined];
 }
 export default Transaction;

package/types/TransactionHelpers.d.ts

@@ -0,0 +1,14 @@
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+import { Transaction } from './Transaction';
+export declare function cloneTransaction(transaction: Transaction): Transaction | undefined;
+/**
+ * Validate that a wallet response only changed input unlocking scripts.
+ *
+ * Wallets are allowed to populate each input script while signing, but they
+ * must not change the transaction version, locktime, input outpoints,
+ * sequences, outputs, BCH amounts, locking bytecode, or token data.
+ */
+export declare function hasSameSigningStructure(template: Transaction, signed: Transaction): boolean;

package/types/U32List.d.ts

@@ -1,6 +1,7 @@
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 import { U32ListNative } from './wasm/glue';
-export declare class U32List {
-    static fromNative(native: U32ListNative): Array<number>;
-    static toNative(numbers: Array<number>): U32ListNative;
-}
+export declare const U32List: import("./ListHelper").ListAdapter<number, U32ListNative>;
 export default U32List;

package/types/U64List.d.ts

@@ -1,6 +1,7 @@
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 import { U64ListNative } from './wasm/glue';
-export declare class U64List {
-    static fromNative(native: U64ListNative): Array<bigint>;
-    static toNative(numbers: Array<bigint>): U64ListNative;
-}
+export declare const U64List: import("./ListHelper").ListAdapter<bigint, U64ListNative>;
 export default U64List;

package/types/Utxo.d.ts

@@ -1,17 +1,21 @@
-import { UtxoNative } from './wasm/glue';
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 import { Hash } from './Hash';
-import Output from './Output';
-import TokenData from './TokenData';
+import { Output } from './Output';
+import { TokenData } from './TokenData';
+import { UtxoNative } from './wasm/glue';
 export declare class Utxo {
     hash?: Hash;
     index?: number;
     amount?: bigint;
-    cachedOutput?: Output;
     tokenData?: TokenData;
+    cachedOutput?: Output;
     static fromNative(native: UtxoNative, destroy?: boolean): Utxo;
-    static isValid(hash: Hash, index: number, amount: bigint): boolean;
     constructor(hash?: Hash, index?: number, amount?: bigint, tokenData?: TokenData);
-    get valid(): boolean;
     toNative(): UtxoNative;
+    static isValid(hash: Hash, index: number, amount: bigint): boolean;
+    get valid(): boolean;
 }
 export default Utxo;

package/types/UtxoList.d.ts

@@ -1,7 +1,8 @@
-import { UtxoListNative } from './wasm/glue';
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 import { Utxo } from './Utxo';
-export declare class UtxoList {
-    static fromNative(native: UtxoListNative): Array<Utxo>;
-    static toNative(utxos: Array<Utxo>): UtxoListNative;
-}
+import { UtxoListNative } from './wasm/glue';
+export declare const UtxoList: import("./ListHelper").ListAdapter<Utxo, UtxoListNative>;
 export default UtxoList;

package/types/Wallet.d.ts

@@ -1,62 +1,38 @@
-import { PaymentAddress } from './PaymentAddress';
-import { EcSecret } from './Secret';
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 import { EcPublic } from './EcPublic';
 import { LongHash } from './Hash';
+import { PaymentAddress } from './PaymentAddress';
+import { EcSecret } from './Secret';
+export type WalletTriple = {
+    secret: EcSecret;
+    publicKey: EcPublic;
+    address: PaymentAddress;
+};
 export declare class Wallet {
-    private mnemonic;
-    private derivationPath;
-    private network;
-    private seed;
+    private readonly mnemonic;
+    private readonly derivationPath;
+    private readonly network;
+    private readonly seed;
     private master;
-    private lastDerived;
-    /**
-     * Create a Wallet from a BIP39 mnemonic phrase (recommended factory method)
-     * @param mnemonic - Array of BIP39 words (12, 15, 18, 21, or 24 words)
-     * @param derivationPath - BIP32/BIP44 derivation path (e.g., "m/44'/145'/0'/0")
-     * @param network - Network type: 'MAINNET' or 'TESTNET'
-     * @returns New Wallet instance
-     * @example
-     * const wallet = Wallet.fromMnemonic(
-     *   ['word1', 'word2', ...],
-     *   "m/44'/145'/0'/0",
-     *   'MAINNET'
-     * );
-     */
-    static fromMnemonic(mnemonic: string[], derivationPath: string, network?: string): Wallet;
-    /**
-     * Create a Wallet from a raw seed (advanced usage)
-     * @param seed - 64-byte seed (LongHash/Uint8Array)
-     * @param derivationPath - BIP32/BIP44 derivation path
-     * @param network - Network type: 'MAINNET' or 'TESTNET'
-     * @returns New Wallet instance
-     * @example
-     * const wallet = Wallet.fromSeed(
-     *   new Uint8Array(64),
-     *   "m/44'/145'/0'/0",
-     *   'MAINNET'
-     * );
-     */
-    static fromSeed(seed: LongHash, derivationPath: string, network?: string): Wallet;
-    /**
-     * Private constructor - use Wallet.fromMnemonic() or Wallet.fromSeed() factory methods instead
-     */
-    private constructor();
-    private constructor();
+    private account;
+    constructor(seed: LongHash, derivationPath: string, network: string);
+    constructor(mnemonic: string[], derivationPath: string, network: string);
+    private static prefixesOf;
+    private static addressVersionOf;
+    private accountKey;
+    dispose(): void;
     getSecret(index: number): EcSecret;
-    getTripleOf(address: PaymentAddress, maxLoops?: number): {
-        secret: EcSecret;
-        publicKey: EcPublic;
-        address: PaymentAddress;
-    } | undefined;
+    private publicKeyOf;
     getPublicKey(index: number): EcPublic;
-    getPublicKeys(count?: number, from?: number): EcPublic[];
+    getPublicKeys(count?: number, from?: number): Array<EcPublic>;
+    private addressOf;
     getAddress(index: number): PaymentAddress;
-    getAddresses(count?: number, from?: number): PaymentAddress[];
-    getTriple(index: number): {
-        secret: EcSecret;
-        publicKey: EcPublic;
-        address: PaymentAddress;
-    };
+    getAddresses(count?: number, from?: number): Array<PaymentAddress>;
+    getTriple(index: number): WalletTriple;
+    getTripleOf(address: PaymentAddress, maxLoops?: number): WalletTriple | undefined;
     deriveAccount(derivationPath: string): Wallet;
 }
 export default Wallet;

package/types/WalletData.d.ts

@@ -1,6 +1,10 @@
-import { WalletDataNative } from './wasm/glue';
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 import { EncryptedSeed } from './Hash';
 import { HdPublic } from './HdPublic';
+import { WalletDataNative } from './wasm/glue';
 export declare class WalletData {
     mnemonics?: Array<string>;
     encryptedSeed?: EncryptedSeed;

package/types/WalletManager.d.ts

@@ -1,8 +1,11 @@
-import { LongHash } from './Hash';
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+import { EncryptedSeed, LongHash } from './Hash';
 import { WalletData } from './WalletData';
-import { EncryptedSeed } from './Hash';
 export declare class WalletManager {
-    static createWallet(password: string, normalizedPassphrase?: string): WalletData | undefined;
+    static createSimple(password: string, normalizedPassphrase?: string): WalletData | undefined;
     static decryptSeed(password: string, encryptedSeed: EncryptedSeed): LongHash | undefined;
 }
 export default WalletManager;

package/types/WalletUtils.d.ts

@@ -0,0 +1,53 @@
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+/**
+ * WalletUtils - Centralized wallet operations to reduce code duplication
+ * across different frontend implementations
+ */
+export declare class WalletUtils {
+    /**
+     * Fix encrypted seed format - ensures proper 96-byte length
+     * This function was duplicated in multiple places in vm-lab
+     */
+    static fixSeed(seed: Uint8Array): Uint8Array;
+    /**
+     * Create wallet from encrypted seed - consolidates the common pattern:
+     * fixSeed() -> decryptSeed() -> new Wallet()
+     */
+    static createWalletFromEncryptedSeed(kth: any, selectedWallet: any, password?: string): any;
+    /**
+     * Normalize Bitcoin Cash address - handles bitcoincash: prefix consistently
+     */
+    static normalizeAddress(address: string, withPrefix?: boolean): string;
+    /**
+     * Convert BCH to satoshis (uses existing Bitcoin utility)
+     */
+    static bitcoinToSatoshis(amount: number): bigint;
+    /**
+     * Convert satoshis to BCH (uses existing Bitcoin utility)
+     */
+    static satoshisToBitcoin(satoshis: bigint): number;
+    /**
+     * Convert token amount to token satoshis (for 2-decimal tokens like mUSD)
+     */
+    static tokenToSatoshis(amount: number, decimals?: number): number;
+    /**
+     * Convert token satoshis to token amount
+     */
+    static satoshisToToken(satoshis: number, decimals?: number): number;
+    /**
+     * Validate if a wallet is ready for transactions
+     */
+    static validateWalletForTransaction(selectedWallet: any): void;
+    /**
+     * Get first address from wallet
+     */
+    static getFirstAddress(selectedWallet: any): string;
+    /**
+     * Get change address from wallet (typically same as first address for now)
+     */
+    static getChangeAddress(selectedWallet: any, addressIndex?: number): string;
+}
+export default WalletUtils;

package/types/encoding.d.ts

@@ -1,3 +1,7 @@
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 import { Hash } from './Hash';
 export declare function bytesToHexStr(bytes: Uint8Array): string;
 export declare function hexStrToBytes(hex: string): Uint8Array;

package/types/env.d.ts

@@ -1,3 +1,7 @@
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
 export declare const IS_WORKER: boolean;
 export declare const IS_WEB_MAIN_THREAD: boolean;
 export declare const IS_NODE_MAIN_THREAD: boolean;

package/types/logger.d.ts

@@ -0,0 +1,6 @@
+// Copyright (c) 2016-present Knuth Project developers.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+export declare function debugLog(...args: unknown[]): void;
+export declare function debugWarn(...args: unknown[]): void;