@knuth/js-wasm 2.3.0 → 2.6.0

package/types/WalletData.d.ts

@@ -0,0 +1,11 @@
+import { WalletDataNative } from './wasm/glue';
+import { EncryptedSeed } from './Hash';
+import { HdPublic } from './HdPublic';
+export declare class WalletData {
+    mnemonics?: Array<string>;
+    encryptedSeed?: EncryptedSeed;
+    xpub?: HdPublic;
+    static fromNative(native: WalletDataNative, destroy?: boolean): WalletData;
+    constructor(mnemonics?: Array<string>, encryptedSeed?: EncryptedSeed, xpub?: HdPublic);
+}
+export default WalletData;

package/types/WalletManager.d.ts

@@ -0,0 +1,8 @@
+import { LongHash } from './Hash';
+import { WalletData } from './WalletData';
+import { EncryptedSeed } from './Hash';
+export declare class WalletManager {
+    static createWallet(password: string, normalizedPassphrase?: string): WalletData | undefined;
+    static decryptSeed(password: string, encryptedSeed: EncryptedSeed): LongHash | undefined;
+}
+export default WalletManager;

package/types/encoding.d.ts

@@ -0,0 +1,5 @@
+import { Hash } from './Hash';
+export declare function bytesToHexStr(bytes: Uint8Array): string;
+export declare function hexStrToBytes(hex: string): Uint8Array;
+export declare function encodeHash(bytes: Hash): string;
+export declare function decodeHash(hex: string): Hash;

package/types/main.d.ts

@@ -1,14 +1,67 @@
 import Kth from './Kth';
+import Utxo from './Utxo';
+import Opcode from './Opcode';
+import OutputPoint from './OutputPoint';
+import Output from './Output';
+import TokenData from './TokenData';
+import TokenDataFungible from './TokenDataFungible';
+import TokenDataNonFungible from './TokenDataNonFungible';
+import TokenDataBothKinds from './TokenDataBothKinds';
+import Input from './Input';
+import OutputList from './OutputList';
+import InputList from './InputList';
+import UtxoList from './UtxoList';
 import PaymentAddress from './PaymentAddress';
+import Script from './Script';
+import Transaction from './Transaction';
 import Wallet from './Wallet';
+import HdPublic from './HdPublic';
+import EcPublic from './EcPublic';
+import { EcSecret } from './Secret';
+import { SecretFunctions } from './SecretFunctions';
+import { OpcodeEnumNative, OpcodeEnumNativeToInt } from './wasm/glue';
+import { ScriptNative } from './wasm/glue';
+import Operation from './Operation';
+import OperationList from './OperationList';
+import RuleFork from './RuleFork';
+import SighashAlgorithm from './SighashAlgorithm';
+import Program from './Program';
+import { Interpreter, Debugger } from './Interpreter';
+import { bitcoinToSatoshis, satoshisToBitcoin } from './Bitcoin';
+import { RuleForkEnumNative, RuleForkEnumNativeToInt } from './wasm/glue_manual';
+import { bytesToHexStr, hexStrToBytes, encodeHash, decodeHash } from './encoding';
+import { HashFunctions, Hash, ShortHash, LongHash, EncryptedSeed } from './Hash';
+import WalletManager from './WalletManager';
+import WalletData from './WalletData';
 import loadLib from './wasm/loadLib';
 import { free, malloc } from './wasm/mem';
-export { loadLib, Kth, PaymentAddress, Wallet, free, malloc };
+export { loadLib, Kth, OutputPoint, Utxo, Output, OutputList, TokenData, TokenDataFungible, TokenDataNonFungible, TokenDataBothKinds, Input, InputList, UtxoList, PaymentAddress, Script, ScriptNative, Transaction, Wallet, HdPublic, EcPublic, EcSecret, SecretFunctions, Opcode, OpcodeEnumNative, OpcodeEnumNativeToInt, Operation, OperationList, RuleFork, RuleForkEnumNative, RuleForkEnumNativeToInt, SighashAlgorithm, Interpreter, Debugger, Program, bytesToHexStr, hexStrToBytes, encodeHash, decodeHash, bitcoinToSatoshis, satoshisToBitcoin, HashFunctions, Hash, ShortHash, LongHash, EncryptedSeed, WalletManager, WalletData, free, malloc };
 declare const _default: {
     loadLib: typeof loadLib;
     Kth: typeof Kth;
     PaymentAddress: typeof PaymentAddress;
     Wallet: typeof Wallet;
+    Script: typeof Script;
+    HdPublic: typeof HdPublic;
+    EcPublic: typeof EcPublic;
+    SecretFunctions: typeof SecretFunctions;
+    Opcode: typeof Opcode;
+    OpcodeEnumNativeToInt: typeof OpcodeEnumNativeToInt;
+    Operation: typeof Operation;
+    RuleFork: typeof RuleFork;
+    RuleForkEnumNativeToInt: typeof RuleForkEnumNativeToInt;
+    SighashAlgorithm: typeof SighashAlgorithm;
+    Utxo: typeof Utxo;
+    UtxoList: typeof UtxoList;
+    bytesToHexStr: typeof bytesToHexStr;
+    hexStrToBytes: typeof hexStrToBytes;
+    encodeHash: typeof encodeHash;
+    decodeHash: typeof decodeHash;
+    bitcoinToSatoshis: typeof bitcoinToSatoshis;
+    satoshisToBitcoin: typeof satoshisToBitcoin;
+    HashFunctions: typeof HashFunctions;
+    WalletManager: typeof WalletManager;
+    WalletData: typeof WalletData;
     free: typeof free;
     malloc: typeof malloc;
 };

package/types/wasm/exceptions.d.ts

@@ -0,0 +1 @@
+export declare function dummyFunction(): void;

package/types/wasm/glue copy.d.ts

@@ -0,0 +1,230 @@
+declare const ptrSym: unique symbol;
+declare const _CurrencyIntToKey: readonly ["bitcoin", "bitcoin_cash", "litecoin"];
+export declare type Currency = (typeof _CurrencyIntToKey)[number];
+declare const _LogLibraryIntToKey: readonly ["boost", "spdlog", "binlog"];
+export declare type LogLibrary = (typeof _LogLibraryIntToKey)[number];
+export declare class LibConfigTypeSizes {
+    private readonly [ptrSym];
+    static _create(ptr: number): LibConfigTypeSizes;
+    get size_int(): number;
+    get size_long(): number;
+    get size_pointer(): number;
+    protected _destructor(): void;
+}
+export declare class LibConfig {
+    private readonly [ptrSym];
+    static _create(ptr: number): LibConfig;
+    get log_library(): LogLibrary;
+    get use_libmdbx(): boolean;
+    get version(): string;
+    get microarchitecture_id(): string;
+    get currency(): Currency;
+    get mempool(): boolean;
+    get db_readonly(): boolean;
+    get debug_mode(): boolean;
+    get architecture(): string;
+    get os_name(): string;
+    get compiler_name(): string;
+    get compiler_version(): string;
+    get optimization_level(): string;
+    get build_timestamp(): number;
+    get endianness(): string;
+    get type_sizes(): LibConfigTypeSizes;
+    protected _destructor(): void;
+    static getLibconfig(): LibConfig;
+    static getEmscriptenVersionMajor(): number;
+    static getEmscriptenVersionMinor(): number;
+    static getEmscriptenVersionTiny(): number;
+    static getBuildTimestamp(): number;
+}
+export declare class StringListNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): StringListNative;
+    protected _destructor(): void;
+    constructor();
+    pushBack(string: string): void;
+}
+export declare class ShortHashNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): ShortHashNative;
+    get hash(): number;
+    protected _destructor(): void;
+}
+export declare class HashNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): HashNative;
+    get hash(): number;
+    protected _destructor(): void;
+}
+export declare class LongHashNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): LongHashNative;
+    get hash(): number;
+    protected _destructor(): void;
+}
+export declare class HdChainCodeNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): HdChainCodeNative;
+    get data(): number;
+    protected _destructor(): void;
+}
+export declare class HdKeyNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): HdKeyNative;
+    get data(): number;
+    protected _destructor(): void;
+}
+export declare class EcCompressedNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): EcCompressedNative;
+    get data(): number;
+    protected _destructor(): void;
+}
+export declare class EcUncompressedNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): EcUncompressedNative;
+    get data(): number;
+    protected _destructor(): void;
+}
+export declare class EcSecretNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): EcSecretNative;
+    get hash(): number;
+    protected _destructor(): void;
+}
+export declare class WifUncompressedNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): WifUncompressedNative;
+    get data(): number;
+    protected _destructor(): void;
+}
+export declare class WifCompressedNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): WifCompressedNative;
+    get data(): number;
+    protected _destructor(): void;
+}
+export declare class HdLineageNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): HdLineageNative;
+    get prefixes(): bigint;
+    get depth(): number;
+    get parent_fingerprint(): number;
+    get child_number(): number;
+    protected _destructor(): void;
+}
+export declare class EllipticCurveNative {
+    static secretToPublic(out: EcCompressedNative, secret: EcSecretNative): boolean;
+}
+export declare class HdPublicNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): HdPublicNative;
+    protected _destructor(): void;
+    constructor();
+    isValid(): boolean;
+    encoded(): string;
+    chainCode(): HdChainCodeNative;
+    lineage(): HdLineageNative;
+    point(): EcCompressedNative;
+    toHdKey(): HdKeyNative;
+    derivePublic(index: number): HdPublicNative;
+}
+export declare class HdPrivateNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): HdPrivateNative;
+    protected _destructor(): void;
+    constructor();
+    constructor(encoded: string);
+    constructor(seed: number, size: number, prefixes: bigint);
+    isValid(): boolean;
+    encoded(): string;
+    secret(): EcSecretNative;
+    chainCode(): HdChainCodeNative;
+    lineage(): HdLineageNative;
+    point(): EcCompressedNative;
+    toHdKeyNative(): HdKeyNative;
+    toPublic(): HdPublicNative;
+    derivePrivate(index: number): HdPrivateNative;
+    derivePublic(index: number): HdPublicNative;
+}
+export declare class PaymentAddressNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): PaymentAddressNative;
+    protected _destructor(): void;
+    constructor(address: string);
+    constructor(hash: ShortHashNative, version: number);
+    encodedLegacy(): string;
+    encodedCashaddr(tokenAware: boolean): string;
+    hash20(): ShortHashNative;
+    hash32(): HashNative;
+    version(): number;
+    isValid(): boolean;
+}
+export declare class EcPrivateNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): EcPrivateNative;
+    protected _destructor(): void;
+    constructor();
+    constructor(wif: string, version: number);
+    constructor(wif: WifCompressedNative, version: number);
+    constructor(wif: WifUncompressedNative, version: number);
+    constructor(secret: EcSecretNative, version: number, compress: boolean);
+    isValid(): boolean;
+    encoded(): string;
+    secret(): EcSecretNative;
+    version(): number;
+    paymentVersion(): number;
+    wifVersion(): number;
+    compressed(): boolean;
+    toPublic(): EcPublicNative;
+    toPaymentAddress(): PaymentAddressNative;
+}
+export declare class EcPublicNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): EcPublicNative;
+    protected _destructor(): void;
+    constructor();
+    constructor(base16: string);
+    constructor(secret: EcPrivateNative);
+    constructor(point: EcCompressedNative, compress: boolean);
+    isValid(): boolean;
+    encoded(): string;
+    point(): EcCompressedNative;
+    compressed(): boolean;
+    toUncompressed(outData: EcUncompressedNative): boolean;
+    toPaymentAddress(version: number): PaymentAddressNative;
+}
+export declare class WalletNative {
+    static mnemonicsToSeed(mnemonics: StringListNative): LongHashNative;
+    static hdNew(seed: LongHashNative, version: number): HdPrivateNative;
+    static hdPrivateToEc(key: HdPrivateNative): EcSecretNative;
+    static ecToPublic(secret: EcSecretNative, uncompressed: boolean): EcPublicNative;
+    static ecToAddress(point: EcPublicNative, version: number): PaymentAddressNative;
+}
+export declare class NodeInfoNative {
+    static printThreadId(): void;
+    static getThreadId(): bigint;
+    static capiVersion(): string;
+    static cppapiVersion(): string;
+    static microarchitecture(): string;
+    static marchNames(): string;
+    static currencySymbol(): string;
+    static currency(): string;
+    static cppapiBuildTimestamp(): number;
+}
+export declare class ScriptNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): ScriptNative;
+    protected _destructor(): void;
+    constructor();
+    constructor(encoded: Uint8Array, prefix: boolean);
+    isValid(): boolean;
+    isValidOperations(): boolean;
+    satoshiContentSize(): number;
+    serializedSize(prefix: boolean): number;
+    toStr(activeForks: number): string;
+    type(): string;
+    toData(prefix: boolean): Uint8Array;
+    sigops(embedded: boolean): number;
+}
+export {};