@knuth/js-wasm 2.3.0 → 2.6.0

package/types/Bitcoin.d.ts

@@ -0,0 +1,2 @@
+export declare function bitcoinToSatoshis(amount: number): bigint;
+export declare function satoshisToBitcoin(satoshis: bigint): number;

package/types/DoubleList.d.ts

@@ -0,0 +1,6 @@
+import { DoubleListNative } from './wasm/glue';
+export declare class DoubleList {
+    static fromNative(native: DoubleListNative): Array<number>;
+    static toNative(numbers: Array<number>): DoubleListNative;
+}
+export default DoubleList;

package/types/EcCompressed.d.ts

@@ -0,0 +1,7 @@
+import { EcCompressedNative } from './wasm/glue';
+export declare class EcCompressed {
+    private native;
+    constructor(native: EcCompressedNative);
+    toNative(): EcCompressedNative;
+}
+export default EcCompressed;

package/types/EcPublic.d.ts

@@ -0,0 +1,13 @@
+import { EcPublicNative } from './wasm/glue';
+import { PaymentAddress } from './PaymentAddress';
+import { EcCompressed } from './EcCompressed';
+export declare class EcPublic {
+    private native;
+    constructor(native: EcPublicNative);
+    constructor(compressed: EcCompressed, compress: boolean);
+    toNative(): EcPublicNative;
+    toPaymentAddress(version: number): PaymentAddress;
+    get encoded(): string;
+    toData(): Uint8Array<ArrayBufferLike>;
+}
+export default EcPublic;

package/types/Hash.d.ts

@@ -0,0 +1,32 @@
+import { HashNative, ShortHashNative, EncryptedSeedNative, LongHashNative } from './wasm/glue';
+export type Hash = Uint8Array & {
+    length: 32;
+};
+export type ShortHash = Uint8Array & {
+    length: 20;
+};
+export type LongHash = Uint8Array & {
+    length: 64;
+};
+export type EncryptedSeed = Uint8Array & {
+    length: 96;
+};
+export declare class HashFunctions {
+    static nullHash: Hash;
+    static nullShortHash: ShortHash;
+    static nullLongHash: LongHash;
+    static nullEncryptedSeed: EncryptedSeed;
+    static fromNative(native: HashNative, destroy: boolean): Hash;
+    static fromNative(native: ShortHashNative, destroy: boolean): ShortHash;
+    static fromNative(native: LongHashNative, destroy: boolean): LongHash;
+    static fromNative(native: EncryptedSeedNative, destroy: boolean): EncryptedSeed;
+    static toNative(hash: Hash): HashNative;
+    static toNative(hash: ShortHash): ShortHashNative;
+    static toNative(hash: LongHash): LongHashNative;
+    static toNative(hash: EncryptedSeed): EncryptedSeedNative;
+    static encryptedSeedtoNative(hash: Uint8Array): EncryptedSeedNative;
+    static sha256(data: Uint8Array): Hash;
+    static sha256Reversed(data: Uint8Array): Hash;
+    static sha256ReversedStr(data: Uint8Array): string;
+}
+export default HashFunctions;

package/types/HdPublic.d.ts

@@ -0,0 +1,13 @@
+import { HdPublicNative } from './wasm/glue';
+import { EcCompressed } from './EcCompressed';
+export declare class HdPublic {
+    private native;
+    static fromString(encoded: string): HdPublic | undefined;
+    static isValid(encoded: string): boolean;
+    constructor(native: HdPublicNative);
+    toNative(): HdPublicNative;
+    derivePublic(index: number): HdPublic;
+    get encoded(): string;
+    get point(): EcCompressed;
+}
+export default HdPublic;

package/types/Input.d.ts

@@ -0,0 +1,17 @@
+import { InputNative } from './wasm/glue';
+import { Script } from './Script';
+import { OutputPoint } from './OutputPoint';
+export declare class Input {
+    previousOutput?: OutputPoint;
+    script?: Script;
+    seq?: number;
+    static fromNative(native: InputNative, destroy?: boolean): Input;
+    static fromData(data: Uint8Array): Input | undefined;
+    static isValid(previousOutput: OutputPoint, script: Script, seq: number): boolean;
+    constructor(previousOutput?: OutputPoint, script?: Script, seq?: number);
+    get valid(): boolean;
+    toNative(): InputNative;
+    serializedSize(wire: boolean): number;
+    toData(wire: boolean): Uint8Array<ArrayBufferLike>;
+}
+export default Input;

package/types/InputList.d.ts

@@ -0,0 +1,7 @@
+import { InputListNative } from './wasm/glue';
+import { Input } from './Input';
+export declare class InputList {
+    static fromNative(native: InputListNative): Array<Input>;
+    static toNative(inputs: Array<Input>): InputListNative;
+}
+export default InputList;

package/types/Interpreter.d.ts

@@ -0,0 +1,17 @@
+import { Program } from './Program';
+import { Operation } from './Operation';
+export declare class Debugger {
+    stepNumber?: number;
+    programHistory: Map<number, Program>;
+    get lastProgram(): Program | undefined;
+    start(program: Program): number;
+    get stepsAvailable(): boolean;
+    stepForward(): number;
+    end(): number;
+}
+export declare class Interpreter {
+    static run(program: Program): number;
+    static runOperation(operation: Operation, program: Program): number;
+    static debug(program: Program): Debugger | number;
+}
+export default Interpreter;

package/types/Kth.d.ts

@@ -8,6 +8,7 @@ export declare class Kth {
         optimizationLevel: string;
         cppapiBuildTimestamp: number;
         capiBuildTimestamp: number;
+        capiBuildGitHash: string;
         wasmBuildTimestamp: number;
         typeSizesInt: number;
         typeSizesLong: number;

package/types/ListHelper.d.ts

@@ -0,0 +1,5 @@
+import { ListNative } from './ListNative';
+export declare function fromNative<T, N, L extends ListNative<N>>(nativeList: L, fromNativeFunc: (nativeItem: N) => T): Array<T>;
+export declare function toNative<T, N, L extends ListNative<N>>(items: Array<T>, toNativeFunc: (item: T) => N, NativeConstructor: new () => L): L;
+export declare function fromNativePrimitive<T, L extends ListNative<T>>(nativeList: L): Array<T>;
+export declare function toNativePrimitive<T, L extends ListNative<T>>(items: Array<T>, NativeConstructor: new () => L): L;

package/types/ListNative.d.ts

@@ -0,0 +1,5 @@
+export interface ListNative<T> {
+    count(): number;
+    nth(index: number): T;
+    pushBack(item: T): void;
+}

package/types/Opcode.d.ts

@@ -0,0 +1,9 @@
+import { OpcodeEnumNative } from './wasm/glue';
+export declare class Opcode {
+    static toInt(value: OpcodeEnumNative): number;
+    static toString(value: OpcodeEnumNative, activeForks: number): string;
+    static fromString(value: string): OpcodeEnumNative | undefined;
+    static toHexadecimal(code: OpcodeEnumNative): string;
+    static fromHexadecimal(value: string): OpcodeEnumNative | undefined;
+}
+export default Opcode;

package/types/Operation.d.ts

@@ -0,0 +1,47 @@
+import { OperationNative, OpcodeEnumNative } from './wasm/glue';
+export declare class Operation {
+    private opcode;
+    private encoded;
+    private minimal;
+    private rawData;
+    static fromNative(native: OperationNative, destroy?: boolean): Operation;
+    static fromData(encoded: Uint8Array): Operation | undefined;
+    static fromString(str: string): Operation | undefined;
+    static isValid(encoded: Uint8Array, minimal: boolean): boolean;
+    constructor();
+    constructor(opcode: OpcodeEnumNative);
+    constructor(encoded: Uint8Array, minimal?: boolean);
+    toNative(): OperationNative;
+    toString(activeForks: number): string;
+    toData(): Uint8Array<ArrayBufferLike>;
+    get isValid(): boolean;
+    get serializedSize(): number;
+    get code(): "push_size_0" | "push_size_1" | "push_size_2" | "push_size_3" | "push_size_4" | "push_size_5" | "push_size_6" | "push_size_7" | "push_size_8" | "push_size_9" | "push_size_10" | "push_size_11" | "push_size_12" | "push_size_13" | "push_size_14" | "push_size_15" | "push_size_16" | "push_size_17" | "push_size_18" | "push_size_19" | "push_size_20" | "push_size_21" | "push_size_22" | "push_size_23" | "push_size_24" | "push_size_25" | "push_size_26" | "push_size_27" | "push_size_28" | "push_size_29" | "push_size_30" | "push_size_31" | "push_size_32" | "push_size_33" | "push_size_34" | "push_size_35" | "push_size_36" | "push_size_37" | "push_size_38" | "push_size_39" | "push_size_40" | "push_size_41" | "push_size_42" | "push_size_43" | "push_size_44" | "push_size_45" | "push_size_46" | "push_size_47" | "push_size_48" | "push_size_49" | "push_size_50" | "push_size_51" | "push_size_52" | "push_size_53" | "push_size_54" | "push_size_55" | "push_size_56" | "push_size_57" | "push_size_58" | "push_size_59" | "push_size_60" | "push_size_61" | "push_size_62" | "push_size_63" | "push_size_64" | "push_size_65" | "push_size_66" | "push_size_67" | "push_size_68" | "push_size_69" | "push_size_70" | "push_size_71" | "push_size_72" | "push_size_73" | "push_size_74" | "push_size_75" | "push_one_size" | "push_two_size" | "push_four_size" | "push_negative_1" | "reserved_80" | "push_positive_1" | "push_positive_2" | "push_positive_3" | "push_positive_4" | "push_positive_5" | "push_positive_6" | "push_positive_7" | "push_positive_8" | "push_positive_9" | "push_positive_10" | "push_positive_11" | "push_positive_12" | "push_positive_13" | "push_positive_14" | "push_positive_15" | "push_positive_16" | "nop" | "reserved_98" | "if" | "notif" | "disabled_verif" | "disabled_vernotif" | "else" | "endif" | "verify" | "return" | "toaltstack" | "fromaltstack" | "drop2" | "dup2" | "dup3" | "over2" | "rot2" | "swap2" | "ifdup" | "depth" | "drop" | "dup" | "nip" | "over" | "pick" | "roll" | "rot" | "swap" | "tuck" | "cat" | "split" | "num2bin" | "bin2num" | "size" | "disabled_invert" | "and" | "or" | "xor" | "equal" | "equalverify" | "reserved_137" | "reserved_138" | "add1" | "sub1" | "disabled_mul2" | "disabled_div2" | "negate" | "abs" | "not" | "nonzero" | "add" | "sub" | "mul" | "div" | "mod" | "disabled_lshift" | "disabled_rshift" | "booland" | "boolor" | "numequal" | "numequalverify" | "numnotequal" | "lessthan" | "greaterthan" | "lessthanorequal" | "greaterthanorequal" | "min" | "max" | "within" | "ripemd160" | "sha1" | "sha256" | "hash160" | "hash256" | "codeseparator" | "checksig" | "checksigverify" | "checkmultisig" | "checkmultisigverify" | "nop1" | "nop2" | "checklocktimeverify" | "nop3" | "checksequenceverify" | "nop4" | "nop5" | "nop6" | "nop7" | "nop8" | "nop9" | "nop10" | "checkdatasig" | "checkdatasigverify" | "reverse_bytes" | "available1" | "available2" | "available3" | "input_index" | "active_bytecode" | "tx_version" | "tx_input_count" | "tx_output_count" | "tx_locktime" | "utxo_value" | "utxo_bytecode" | "outpoint_tx_hash" | "outpoint_index" | "input_bytecode" | "input_sequence_number" | "output_value" | "output_bytecode" | "utxo_token_category" | "utxo_token_commitment" | "utxo_token_amount" | "output_token_category" | "output_token_commitment" | "output_token_amount" | "reserved_212" | "reserved_213" | "reserved_214" | "first_undefined_op_value" | "reserved_215" | "reserved_216" | "reserved_217" | "reserved_218" | "reserved_219" | "reserved_220" | "reserved_221" | "reserved_222" | "reserved_223" | "reserved_224" | "reserved_225" | "reserved_226" | "reserved_227" | "reserved_228" | "reserved_229" | "reserved_230" | "reserved_231" | "reserved_232" | "reserved_233" | "reserved_234" | "reserved_235" | "reserved_236" | "reserved_237" | "reserved_238" | "reserved_239" | "special_token_prefix" | "reserved_240" | "reserved_241" | "reserved_242" | "reserved_243" | "reserved_244" | "reserved_245" | "reserved_246" | "reserved_247" | "reserved_248" | "reserved_249" | "reserved_250" | "reserved_251" | "reserved_252" | "reserved_253" | "reserved_254" | "reserved_255" | "invalidopcode";
+    get data(): Uint8Array<ArrayBufferLike>;
+    get isPush(): boolean;
+    get isCounted(): boolean;
+    get isVersion(): boolean;
+    get isPositive(): boolean;
+    isDisabled(activeForks: number): void;
+    get isConditional(): boolean;
+    get isRelaxedPush(): boolean;
+    isOversized(maxSize: number): boolean;
+    get isMinimalPush(): boolean;
+    get isNominalPush(): boolean;
+    static opcodeFromSize(size: number): OpcodeEnumNative;
+    static minimalOpcodeFromData(data: Uint8Array): OpcodeEnumNative;
+    static nominalOpcodeFromData(data: Uint8Array): OpcodeEnumNative;
+    static opcodeFromPositive(value: number): OpcodeEnumNative;
+    static opcodeToPositive(code: OpcodeEnumNative): number;
+    static opcodeIsPush(code: OpcodeEnumNative): boolean;
+    static opcodeIsPayload(code: OpcodeEnumNative): boolean;
+    static opcodeIsCounted(code: OpcodeEnumNative): boolean;
+    static opcodeIsVersion(code: OpcodeEnumNative): boolean;
+    static opcodeIsNumeric(code: OpcodeEnumNative): boolean;
+    static opcodeIsPositive(code: OpcodeEnumNative): boolean;
+    static opcodeIsReserved(code: OpcodeEnumNative): boolean;
+    static opcodeIsDisabled(code: OpcodeEnumNative, activeForks: number): boolean;
+    static opcodeIsConditional(code: OpcodeEnumNative): boolean;
+    static opcodeIsRelaxedPush(code: OpcodeEnumNative): boolean;
+}
+export default Operation;

package/types/OperationList.d.ts

@@ -0,0 +1,7 @@
+import { OperationListNative } from './wasm/glue';
+import { Operation } from './Operation';
+export declare class OperationList {
+    static fromNative(native: OperationListNative): Array<Operation>;
+    static toNative(operations: Array<Operation>): OperationListNative;
+}
+export default OperationList;

package/types/Output.d.ts

@@ -0,0 +1,18 @@
+import { OutputNative } from './wasm/glue';
+import { Script } from './Script';
+import { TokenData } from './TokenData';
+export declare class Output {
+    value?: bigint;
+    script?: Script;
+    tokenData?: TokenData;
+    static fromNative(native: OutputNative, destroy?: boolean): Output;
+    static fromData(data: Uint8Array): Output | undefined;
+    static isValid(value: bigint, script: Script, tokenData?: TokenData): boolean;
+    private static validU64Int;
+    constructor(value?: bigint, script?: Script, tokenData?: TokenData);
+    get valid(): boolean;
+    toNative(): OutputNative;
+    serializedSize(wire: boolean): number;
+    toData(wire: boolean): Uint8Array<ArrayBufferLike>;
+}
+export default Output;

package/types/OutputList.d.ts

@@ -0,0 +1,7 @@
+import { OutputListNative } from './wasm/glue';
+import { Output } from './Output';
+export declare class OutputList {
+    static fromNative(native: OutputListNative): Array<Output>;
+    static toNative(operations: Array<Output>): OutputListNative;
+}
+export default OutputList;

package/types/OutputPoint.d.ts

@@ -0,0 +1,14 @@
+import { OutputPointNative } from './wasm/glue';
+import { Hash } from './Hash';
+import Output from './Output';
+export declare class OutputPoint {
+    hash?: Hash;
+    index?: number;
+    cachedOutput?: Output;
+    static fromNative(native: OutputPointNative, destroy?: boolean): OutputPoint;
+    static isValid(hash: Hash, index: number): boolean;
+    constructor(hash?: Hash, index?: number);
+    get valid(): boolean;
+    toNative(): OutputPointNative;
+}
+export default OutputPoint;

package/types/PaymentAddress.d.ts

@@ -1,18 +1,33 @@
 import { PaymentAddressNative } from './wasm/glue';
+import { Hash, ShortHash } from './Hash';
+import { Script } from './Script';
 export declare class PaymentAddress {
     private addressStr;
     private tokenAware;
     private legacy;
+    static mainnetP2kh: number;
+    static mainnetP2sh: number;
+    static testnetP2kh: number;
+    static testnetP2sh: number;
     static fromNative(native: PaymentAddressNative, destroy?: boolean): PaymentAddress;
+    static fromHash(hash: Hash, version: number): PaymentAddress;
+    static fromShortHash(hash: ShortHash, version: number): PaymentAddress;
     static fromString(addressStr: string): PaymentAddress | undefined;
     static isValid(addressStr: string): boolean;
     constructor(addressStr: string, tokenAware?: boolean, legacy?: boolean);
+    static fromScript(script: Script, version: number): PaymentAddress;
+    static fromPayPublicKeyHashScript(script: Script, version: number): PaymentAddress;
     toNative(): PaymentAddressNative;
-    get hash(): import("./wasm/glue").ShortHashNative;
+    get hash20(): ShortHash;
+    get hash32(): Hash;
+    get hash(): ShortHash;
     get version(): number;
     encoded(): string;
     encodedCashAddr(): string;
     encodedCashTokens(): string;
     encodedLegacy(): string;
+    static extract(script: Script, p2khVersion: number, p2shVersion: number): PaymentAddress[];
+    static extractInput(script: Script, p2khVersion: number, p2shVersion: number): PaymentAddress[];
+    static extractOutput(script: Script, p2khVersion: number, p2shVersion: number): PaymentAddress[];
 }
 export default PaymentAddress;

package/types/PaymentAddressList.d.ts

@@ -0,0 +1,7 @@
+import { PaymentAddressListNative } from './wasm/glue';
+import { PaymentAddress } from './PaymentAddress';
+export declare class PaymentAddressList {
+    static fromNative(native: PaymentAddressListNative): Array<PaymentAddress>;
+    static toNative(paymentAddresses: Array<PaymentAddress>): PaymentAddressListNative;
+}
+export default PaymentAddressList;

package/types/Program.d.ts

@@ -0,0 +1,15 @@
+import { ProgramNative } from './wasm/glue';
+import { Script } from './Script';
+import { Transaction } from './Transaction';
+export declare class Program {
+    private native;
+    constructor(native: ProgramNative);
+    constructor(script?: Script, programOrTransaction?: Program | Transaction, inputIndex?: number, forks?: number);
+    toNative(): ProgramNative;
+    get valid(): boolean;
+    evaluate(): number;
+    stackResult(clean: boolean): boolean;
+    get size(): number;
+    item(index: number): Uint8Array;
+}
+export default Program;

package/types/RuleFork.d.ts

@@ -0,0 +1,38 @@
+export declare class RuleFork {
+    static forkMinYear: number;
+    static forkMaxYear: number;
+    static noRules: number;
+    static easyBlocks: number;
+    static bip16Rule: number;
+    static bip30Rule: number;
+    static bip34Rule: number;
+    static bip66Rule: number;
+    static bip65Rule: number;
+    static bip90Rule: number;
+    static allowCollisions: number;
+    static bip68Rule: number;
+    static bip112Rule: number;
+    static bip113Rule: number;
+    static bchUahf: number;
+    static bchDaaCw144: number;
+    static bchPythagoras: number;
+    static bchEuclid: number;
+    static bchPisano: number;
+    static bchMersenne: number;
+    static bchFermat: number;
+    static bchEuler: number;
+    static bchGauss: number;
+    static bchDescartes: number;
+    static bchLobachevski: number;
+    static bchGalois: number;
+    static bchLeibniz: number;
+    static retarget: number;
+    static unverified: number;
+    static bip34Activations: number;
+    static allRules: number;
+    static baseForks(easyBlocks?: boolean): number;
+    static allForks(easyBlocks?: boolean): number;
+    static enabledForksByDate(year: number, month: number, easyBlocks?: boolean): number;
+    static enabledForksByYear(year: number, easyBlocks?: boolean): number;
+}
+export default RuleFork;

package/types/Script.d.ts

@@ -0,0 +1,51 @@
+import { ScriptNative, EndorsementType } from './wasm/glue';
+import { Operation } from './Operation';
+import { Transaction } from './Transaction';
+import { ShortHash } from './Hash';
+import { EcSecret } from './Secret';
+export declare class Script {
+    private encoded;
+    private prefix;
+    static fromNative(native: ScriptNative, destroy?: boolean): Script;
+    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>;
+    static isPushOnly(ops: Array<Operation>): boolean;
+    static isRelaxedPush(ops: Array<Operation>): boolean;
+    static isCoinbasePattern(ops: Array<Operation>, height: number): boolean;
+    static isNullDataPattern(ops: Array<Operation>): boolean;
+    static isPayPublicKeyPattern(ops: Array<Operation>): boolean;
+    static isPayPublicKeyHashPattern(ops: Array<Operation>): boolean;
+    static isPayScriptHashPattern(ops: Array<Operation>): boolean;
+    static isSignMultisigPattern(ops: Array<Operation>): boolean;
+    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 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";
+    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;
+}
+export default Script;

package/types/Secret.d.ts

@@ -0,0 +1,4 @@
+export type EcSecret = Uint8Array & {
+    length: 32;
+};
+export default EcSecret;

package/types/SecretFunctions.d.ts

@@ -0,0 +1,8 @@
+import { EcSecretNative } from './wasm/glue';
+import { EcSecret } from './Secret';
+export declare class SecretFunctions {
+    static nullSecret: EcSecret;
+    static fromNative(native: EcSecretNative, destroy?: boolean): EcSecret;
+    static toNative(secret: EcSecret): EcSecretNative;
+}
+export default SecretFunctions;

package/types/SighashAlgorithm.d.ts

@@ -0,0 +1,19 @@
+export declare class SighashAlgorithm {
+    static all: number;
+    static none: number;
+    static single: number;
+    static utxos: number;
+    static utxos_all: number;
+    static utxos_none: number;
+    static utxos_single: number;
+    static forkid: number;
+    static forkid_all: number;
+    static forkid_none: number;
+    static forkid_single: number;
+    static anyone_can_pay: number;
+    static anyone_can_pay_all: number;
+    static anyone_can_pay_none: number;
+    static anyone_can_pay_single: number;
+    static mask: number;
+}
+export default SighashAlgorithm;

package/types/StringList.d.ts

@@ -0,0 +1,6 @@
+import { StringListNative } from './wasm/glue';
+export declare class StringList {
+    static fromNative(native: StringListNative): Array<string>;
+    static toNative(strings: Array<string>): StringListNative;
+}
+export default StringList;

package/types/TokenData.d.ts

@@ -0,0 +1,18 @@
+import { TokenDataNative } from './wasm/glue';
+import { Hash } from './Hash';
+import { TokenDataFungible } from './TokenDataFungible';
+import { TokenDataNonFungible } from './TokenDataNonFungible';
+import { TokenDataBothKinds } from './TokenDataBothKinds';
+export type TokenDataInternal = TokenDataFungible | TokenDataNonFungible | TokenDataBothKinds;
+export declare class TokenData {
+    category?: Hash;
+    data?: TokenDataInternal;
+    static fromNative(native: TokenDataNative, destroy?: boolean): TokenData;
+    constructor(category?: Hash, data?: TokenDataInternal);
+    get valid(): boolean;
+    get kind(): 'fungible' | 'non_fungible' | 'both' | undefined;
+    toNative(): TokenDataNative;
+    serializedSize(): number;
+    toData(): Uint8Array<ArrayBufferLike>;
+}
+export default TokenData;

package/types/TokenDataBothKinds.d.ts

@@ -0,0 +1,9 @@
+import { TokenDataFungible } from './TokenDataFungible';
+import { TokenDataNonFungible } from './TokenDataNonFungible';
+import { TokenCapability } from './wasm/glue';
+export declare class TokenDataBothKinds {
+    fungible: TokenDataFungible;
+    nonFungible: TokenDataNonFungible;
+    constructor(amount: bigint, capability: TokenCapability, commitment: Uint8Array);
+}
+export default TokenDataBothKinds;

package/types/TokenDataFungible.d.ts

@@ -0,0 +1,5 @@
+export declare class TokenDataFungible {
+    amount: bigint;
+    constructor(amount: bigint);
+}
+export default TokenDataFungible;

package/types/TokenDataNonFungible.d.ts

@@ -0,0 +1,7 @@
+import { TokenCapability } from './wasm/glue';
+export declare class TokenDataNonFungible {
+    capability: TokenCapability;
+    commitment: Uint8Array;
+    constructor(capability: TokenCapability, commitment: Uint8Array);
+}
+export default TokenDataNonFungible;

package/types/Transaction.d.ts

@@ -0,0 +1,30 @@
+import { TransactionNative, CoinSelectionAlgorithm } from './wasm/glue';
+import { Hash } from './Hash';
+import { Input } from './Input';
+import { Output } from './Output';
+import { PaymentAddress } from './PaymentAddress';
+import { Utxo } from './Utxo';
+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>;
+    clone(): Transaction | undefined;
+    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/U32List.d.ts

@@ -0,0 +1,6 @@
+import { U32ListNative } from './wasm/glue';
+export declare class U32List {
+    static fromNative(native: U32ListNative): Array<number>;
+    static toNative(numbers: Array<number>): U32ListNative;
+}
+export default U32List;

package/types/U64List.d.ts

@@ -0,0 +1,6 @@
+import { U64ListNative } from './wasm/glue';
+export declare class U64List {
+    static fromNative(native: U64ListNative): Array<bigint>;
+    static toNative(numbers: Array<bigint>): U64ListNative;
+}
+export default U64List;

package/types/Utxo.d.ts

@@ -0,0 +1,17 @@
+import { UtxoNative } from './wasm/glue';
+import { Hash } from './Hash';
+import Output from './Output';
+import TokenData from './TokenData';
+export declare class Utxo {
+    hash?: Hash;
+    index?: number;
+    amount?: bigint;
+    cachedOutput?: Output;
+    tokenData?: TokenData;
+    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;
+}
+export default Utxo;

package/types/UtxoList.d.ts

@@ -0,0 +1,7 @@
+import { UtxoListNative } from './wasm/glue';
+import { Utxo } from './Utxo';
+export declare class UtxoList {
+    static fromNative(native: UtxoListNative): Array<Utxo>;
+    static toNative(utxos: Array<Utxo>): UtxoListNative;
+}
+export default UtxoList;

package/types/Wallet.d.ts

@@ -1,18 +1,31 @@
-import { LongHashNative } from './wasm/glue';
 import { PaymentAddress } from './PaymentAddress';
+import { EcSecret } from './Secret';
+import { EcPublic } from './EcPublic';
+import { LongHash } from './Hash';
 export declare class Wallet {
     private mnemonic;
     private derivationPath;
     private network;
-    seed: LongHashNative;
+    private seed;
     private master;
     private lastDerived;
-    constructor(mnemonic: string[], derivationPath: string, network?: string);
-    get rootKey(): string;
-    get extendedPrivateKey(): string;
-    get extendedPublicKey(): string;
+    constructor(seed: LongHash, derivationPath: string, network: string);
+    constructor(mnemonic: string[], derivationPath: string, network: string);
+    getSecret(index: number): EcSecret;
+    getTripleOf(address: PaymentAddress, maxLoops?: number): {
+        secret: EcSecret;
+        publicKey: EcPublic;
+        address: PaymentAddress;
+    } | undefined;
+    getPublicKey(index: number): EcPublic;
+    getPublicKeys(count?: number, from?: number): EcPublic[];
     getAddress(index: number): PaymentAddress;
     getAddresses(count?: number, from?: number): PaymentAddress[];
+    getTriple(index: number): {
+        secret: EcSecret;
+        publicKey: EcPublic;
+        address: PaymentAddress;
+    };
     deriveAccount(derivationPath: string): Wallet;
 }
 export default Wallet;