@knuth/js-wasm 2.11.0 → 4.0.0

package/types/wasm/glue.d.ts

@@ -1,9 +1,23 @@
+// 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.
+
 declare const ptrSym: unique symbol;
+/** A native call that returns a status code reported a non-zero status. */
+export declare class NativeStatusError extends Error {
+    readonly operation: string;
+    readonly status: number;
+    constructor(operation: string, status: number);
+}
+/** True for a non-owning view (it must not be released: its parent owns the native handle). */
+export declare function isBorrowedView(obj: any): boolean;
 declare const _CurrencyIntToKey: readonly ["bitcoin", "bitcoin_cash", "litecoin"];
 export declare type Currency = (typeof _CurrencyIntToKey)[number];
 export declare function CurrencyToInt(value: Currency): number;
+export declare function CurrencyFromInt(value: number): Currency;
 export declare class LibConfigTypeSizes {
     private readonly [ptrSym];
+    private constructor();
     static _create(ptr: number): LibConfigTypeSizes;
     get size_int(): number;
     get size_long(): number;
@@ -12,6 +26,7 @@ export declare class LibConfigTypeSizes {
 }
 export declare class LibConfig {
     private readonly [ptrSym];
+    private constructor();
     static _create(ptr: number): LibConfig;
     get version(): string;
     get microarchitecture_id(): string;
@@ -35,20 +50,27 @@ export declare class LibConfig {
     static getEmscriptenVersionTiny(): number;
     static getBuildTimestamp(): number;
 }
+declare const _NetworkIntToKey: readonly ["mainnet", "testnet", "regtest", "testnet4", "scalenet", "chipnet", "tempnet"];
+export declare type Network = (typeof _NetworkIntToKey)[number];
+export declare function NetworkToInt(value: Network): number;
+export declare function NetworkFromInt(value: number): Network;
 export declare class StringListNative {
     private readonly [ptrSym];
     static _create(ptr: number): StringListNative;
     protected _destructor(): void;
     constructor();
-    pushBack(string: string): void;
+    pushBack(elem: string): void;
     count(): number;
     nth(index: number): string;
+    assignAt(index: number, elem: string): void;
+    erase(index: number): void;
 }
 export declare class ShortHashNative {
     private readonly [ptrSym];
     static _create(ptr: number): ShortHashNative;
     get hash(): number;
     protected _destructor(): void;
+    constructor();
     set(data: number): void;
 }
 export declare class HashNative {
@@ -64,6 +86,7 @@ export declare class LongHashNative {
     static _create(ptr: number): LongHashNative;
     get hash(): number;
     protected _destructor(): void;
+    constructor();
     set(data: number): void;
 }
 export declare class EncryptedSeedNative {
@@ -71,60 +94,98 @@ export declare class EncryptedSeedNative {
     static _create(ptr: number): EncryptedSeedNative;
     get hash(): number;
     protected _destructor(): void;
+    constructor();
     set(data: number): void;
 }
 export declare class HashFunctionsNative {
     static sha256(encoded: Uint8Array): HashNative;
     static sha256Reversed(encoded: Uint8Array): HashNative;
     static sha256ReversedStr(encoded: Uint8Array): string;
+    static ripemd160(encoded: Uint8Array): ShortHashNative;
+}
+export declare class HashListNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): HashListNative;
+    protected _destructor(): void;
+    constructor();
+    pushBack(elem: HashNative): void;
+    count(): number;
+    nth(index: number): HashNative;
+    assignAt(index: number, elem: HashNative): void;
+    erase(index: number): void;
 }
 export declare class DoubleListNative {
     private readonly [ptrSym];
     static _create(ptr: number): DoubleListNative;
     protected _destructor(): void;
     constructor();
-    pushBack(x: number): void;
+    pushBack(elem: number): void;
     count(): number;
     nth(index: number): number;
+    assignAt(index: number, elem: number): void;
+    erase(index: number): void;
 }
 export declare class U32ListNative {
     private readonly [ptrSym];
     static _create(ptr: number): U32ListNative;
     protected _destructor(): void;
     constructor();
-    pushBack(x: number): void;
+    pushBack(elem: number): void;
     count(): number;
     nth(index: number): number;
+    assignAt(index: number, elem: number): void;
+    erase(index: number): void;
 }
 export declare class U64ListNative {
     private readonly [ptrSym];
     static _create(ptr: number): U64ListNative;
     protected _destructor(): void;
     constructor();
-    pushBack(x: bigint): void;
+    pushBack(elem: bigint): void;
     count(): number;
     nth(index: number): bigint;
+    assignAt(index: number, elem: bigint): void;
+    erase(index: number): void;
+}
+export declare class BoolListNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): BoolListNative;
+    protected _destructor(): void;
+    constructor();
+    pushBack(elem: boolean): void;
+    count(): number;
+    nth(index: number): boolean;
+    assignAt(index: number, elem: boolean): void;
+    erase(index: number): void;
 }
+declare const _DbModeIntToKey: readonly ["pruned", "normal", "full_indexed"];
+export declare type DbMode = (typeof _DbModeIntToKey)[number];
+export declare function DbModeToInt(value: DbMode): number;
+export declare function DbModeFromInt(value: number): DbMode;
 export declare class HdChainCodeNative {
     private readonly [ptrSym];
+    private constructor();
     static _create(ptr: number): HdChainCodeNative;
     get data(): number;
     protected _destructor(): void;
 }
 export declare class HdKeyNative {
     private readonly [ptrSym];
+    private constructor();
     static _create(ptr: number): HdKeyNative;
     get data(): number;
     protected _destructor(): void;
 }
 export declare class EcCompressedNative {
     private readonly [ptrSym];
+    private constructor();
     static _create(ptr: number): EcCompressedNative;
     get data(): number;
     protected _destructor(): void;
 }
 export declare class EcUncompressedNative {
     private readonly [ptrSym];
+    private constructor();
     static _create(ptr: number): EcUncompressedNative;
     get data(): number;
     protected _destructor(): void;
@@ -139,12 +200,14 @@ export declare class EcSecretNative {
 }
 export declare class WifUncompressedNative {
     private readonly [ptrSym];
+    private constructor();
     static _create(ptr: number): WifUncompressedNative;
     get data(): number;
     protected _destructor(): void;
 }
 export declare class WifCompressedNative {
     private readonly [ptrSym];
+    private constructor();
     static _create(ptr: number): WifCompressedNative;
     get data(): number;
     protected _destructor(): void;
@@ -157,123 +220,219 @@ export declare class HdLineageNative {
     get parent_fingerprint(): number;
     get child_number(): number;
     protected _destructor(): void;
+    constructor(prefixes: bigint, depth: number, parent_fingerprint: number, child_number: number);
 }
 export declare class EllipticCurveNative {
-    static secretToPublic(out: EcCompressedNative, secret: EcSecretNative): boolean;
+    static secretToPublic(secret: Uint8Array): [boolean, Uint8Array];
 }
 export declare class HdPublicNative {
     private readonly [ptrSym];
+    private constructor();
     static _create(ptr: number): HdPublicNative;
     protected _destructor(): void;
-    constructor();
-    constructor(encoded: string);
-    isValid(): boolean;
-    encoded(): string;
-    chainCode(): HdChainCodeNative;
+    copy(): HdPublicNative;
+    static toPrefix(prefixes: bigint): number;
+    static parseFrom(encoded: string): HdPublicNative;
+    static parseFromWithPrefix(encoded: string, prefix: number): HdPublicNative;
+    static fromHdKey(key: Uint8Array): HdPublicNative;
+    static fromHdKeyWithPrefix(key: Uint8Array, prefix: number): HdPublicNative;
+    static fromSecret(secret: HashNative, chain_code: HashNative, lineage: HdLineageNative): HdPublicNative;
+    static fromVerifiedComponents(point: Uint8Array, chain_code: HashNative, lineage: HdLineageNative): HdPublicNative;
+    equals(other: HdPublicNative): boolean;
+    notEqual(other: HdPublicNative): boolean;
+    less(x: HdPublicNative): boolean;
+    greater(x: HdPublicNative): boolean;
+    lessOrEqual(x: HdPublicNative): boolean;
+    greaterOrEqual(x: HdPublicNative): boolean;
+    toStr(): string;
+    chainCode(): HashNative;
     lineage(): HdLineageNative;
-    point(): EcCompressedNative;
-    toHdKey(): HdKeyNative;
+    point(): Uint8Array;
+    toHdKey(): Uint8Array;
     derivePublic(index: number): HdPublicNative;
+    derivePath(path: string): HdPublicNative;
+    fingerprint(): number;
+    wipe(): void;
 }
 export declare class HdPrivateNative {
     private readonly [ptrSym];
+    private constructor();
     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;
+    copy(): HdPrivateNative;
+    static toPrefix(prefixes: bigint): number;
+    static parseFrom(encoded: string): HdPrivateNative;
+    static parseFromWithPublicPrefix(encoded: string, public_prefix: number): HdPrivateNative;
+    static parseFromWithPrefixes(encoded: string, prefixes: bigint): HdPrivateNative;
+    static fromSeed(seed: Uint8Array, prefixes: bigint): HdPrivateNative;
+    static fromHdKey(private_key: Uint8Array): HdPrivateNative;
+    static fromHdKeyWithPublicPrefix(private_key: Uint8Array, public_prefix: number): HdPrivateNative;
+    static fromHdKeyWithPrefixes(private_key: Uint8Array, prefixes: bigint): HdPrivateNative;
+    static fromVerifiedParts(base: HdPublicNative, secret: HashNative): HdPrivateNative;
+    equals(other: HdPrivateNative): boolean;
+    notEqual(other: HdPrivateNative): boolean;
+    less(x: HdPrivateNative): boolean;
+    greater(x: HdPrivateNative): boolean;
+    lessOrEqual(x: HdPrivateNative): boolean;
+    greaterOrEqual(x: HdPrivateNative): boolean;
+    secret(): HashNative;
+    publicKey(): HdPublicNative;
+    chainCode(): HashNative;
     lineage(): HdLineageNative;
-    point(): EcCompressedNative;
-    toHdKeyNative(): HdKeyNative;
+    point(): Uint8Array;
+    toStr(): string;
+    toHdKey(): Uint8Array;
     toPublic(): HdPublicNative;
     derivePrivate(index: number): HdPrivateNative;
+    derivePath(path: string): HdPrivateNative;
+    static fromSeedAndPath(seed: Uint8Array, path: string, prefixes: bigint): HdPrivateNative;
     derivePublic(index: number): HdPublicNative;
-}
-export declare class PaymentAddressListNative {
-    private readonly [ptrSym];
-    static _create(ptr: number): PaymentAddressListNative;
-    protected _destructor(): void;
-    constructor();
-    pushBack(utxo: PaymentAddressNative): void;
-    count(): number;
-    nth(index: number): PaymentAddressNative;
+    wipe(): void;
 }
 export declare class PaymentAddressNative {
     private readonly [ptrSym];
+    private constructor();
     static _create(ptr: number): PaymentAddressNative;
     protected _destructor(): void;
-    constructor(address: string);
-    static fromShortHash(hash: ShortHashNative, version: number): PaymentAddressNative;
-    static fromHash(hash: HashNative, version: number): PaymentAddressNative;
+    copy(): PaymentAddressNative;
+    static cashaddrPrefixFor(net: Network): string;
+    static parseFromSimple(address: string): PaymentAddressNative;
+    static parseFrom(address: string, net: Network): PaymentAddressNative;
+    static fromPayment(decoded: Uint8Array): PaymentAddressNative;
+    static fromEcPrivate(secret: EcPrivateNative): PaymentAddressNative;
+    static fromEcPublic(point: EcPublicNative, version: number): PaymentAddressNative;
     static fromScript(script: ScriptNative, version: number): PaymentAddressNative;
     static fromPayPublicKeyHashScript(script: ScriptNative, version: number): PaymentAddressNative;
+    static fromShorthash(hash: ShortHashNative, version: number): PaymentAddressNative;
+    static fromHash(hash: HashNative, version: number): PaymentAddressNative;
+    static isSupportedVersion(version: number): boolean;
+    equals(other: PaymentAddressNative): boolean;
+    notEqual(other: PaymentAddressNative): boolean;
+    less(x: PaymentAddressNative): boolean;
+    greater(x: PaymentAddressNative): boolean;
+    lessOrEqual(x: PaymentAddressNative): boolean;
+    greaterOrEqual(x: PaymentAddressNative): boolean;
+    toStr(): string;
     encodedLegacy(): string;
-    encodedCashAddr(tokenAware: boolean): string;
+    encodedCashaddr(token_aware: boolean): string;
+    encodedToken(): string;
+    version(): number;
+    hashSpan(): Uint8Array;
     hash20(): ShortHashNative;
     hash32(): HashNative;
-    version(): number;
-    isValid(): boolean;
-    static extract(script: ScriptNative, p2khVersion: number, p2shVersion: number): PaymentAddressListNative;
-    static extractInput(script: ScriptNative, p2khVersion: number, p2shVersion: number): PaymentAddressListNative;
-    static extractOutput(script: ScriptNative, p2khVersion: number, p2shVersion: number): PaymentAddressListNative;
+    toPayment(): Uint8Array;
+    static extract(script: ScriptNative, p2kh_version: number, p2sh_version: number): PaymentAddressListNative;
+    static extractInput(script: ScriptNative, p2kh_version: number, p2sh_version: number): PaymentAddressListNative;
+    static extractOutput(script: ScriptNative, p2kh_version: number, p2sh_version: number): PaymentAddressListNative;
+}
+export declare class PaymentAddressListNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): PaymentAddressListNative;
+    protected _destructor(): void;
+    constructor();
+    pushBack(elem: PaymentAddressNative): void;
+    count(): number;
+    nth(index: number): PaymentAddressNative;
+    assignAt(index: number, elem: PaymentAddressNative): void;
+    erase(index: number): void;
 }
 export declare class EcPrivateNative {
     private readonly [ptrSym];
+    private constructor();
     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;
+    copy(): EcPrivateNative;
+    static toAddressPrefix(version: number): number;
+    static toWifPrefix(version: number): number;
+    static toVersion(address: number, wif: number): number;
+    static parseFrom(wif: string, version: number): EcPrivateNative;
+    static fromCompressed(wif: Uint8Array, address_version: number): EcPrivateNative;
+    static fromUncompressed(wif: Uint8Array, address_version: number): EcPrivateNative;
+    static fromSecret(secret: HashNative, version: number, compress: boolean): EcPrivateNative;
+    static fromVerifiedSecret(secret: HashNative, version: number, compress: boolean): EcPrivateNative;
+    equals(other: EcPrivateNative): boolean;
+    notEqual(other: EcPrivateNative): boolean;
+    less(x: EcPrivateNative): boolean;
+    greater(x: EcPrivateNative): boolean;
+    lessOrEqual(x: EcPrivateNative): boolean;
+    greaterOrEqual(x: EcPrivateNative): boolean;
+    value(): HashNative;
+    secret(): HashNative;
     version(): number;
     paymentVersion(): number;
     wifVersion(): number;
     compressed(): boolean;
+    toStr(): string;
     toPublic(): EcPublicNative;
     toPaymentAddress(): PaymentAddressNative;
 }
 export declare class EcPublicNative {
     private readonly [ptrSym];
+    private constructor();
     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;
+    static fromData(decoded: Uint8Array): EcPublicNative;
+    copy(): EcPublicNative;
+    static parseFrom(base16: string): EcPublicNative;
+    static fromPrivate(secret: EcPrivateNative): EcPublicNative;
+    static fromPoint(point: Uint8Array, compress: boolean): EcPublicNative;
+    static fromVerifiedPoint(point: Uint8Array, compress: boolean): EcPublicNative;
+    equals(other: EcPublicNative): boolean;
+    notEqual(other: EcPublicNative): boolean;
+    less(x: EcPublicNative): boolean;
+    greater(x: EcPublicNative): boolean;
+    lessOrEqual(x: EcPublicNative): boolean;
+    greaterOrEqual(x: EcPublicNative): boolean;
+    value(): Uint8Array;
+    point(): Uint8Array;
     compressed(): boolean;
+    toStr(): string;
+    encoded(): string;
     toData(): Uint8Array;
-    toUncompressed(outData: EcUncompressedNative): boolean;
+    toUncompressed(): Uint8Array;
     toPaymentAddress(version: number): PaymentAddressNative;
 }
+export declare class EcCompressedListNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): EcCompressedListNative;
+    protected _destructor(): void;
+    constructor();
+    pushBack(elem: Uint8Array): void;
+    count(): number;
+    nth(index: number): Uint8Array;
+}
+export declare class DataStackNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): DataStackNative;
+    protected _destructor(): void;
+    constructor();
+    copy(): DataStackNative;
+    count(): number;
+    pushBack(data: Uint8Array): void;
+    nth(index: number): Uint8Array;
+    nthCopy(index: number): Uint8Array;
+    erase(index: number): void;
+}
 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;
+    static mnemonicsToSeedNormalizedPassphrase(mnemonics: StringListNative, normalized_passphrase: string): LongHashNative;
 }
 export declare class WalletDataNative {
     private readonly [ptrSym];
+    private constructor();
     static _create(ptr: number): WalletDataNative;
     protected _destructor(): void;
+    copy(): WalletDataNative;
     mnemonics(): StringListNative;
-    encryptedSeed(): EncryptedSeedNative;
+    setMnemonics(value: StringListNative): void;
     xpub(): HdPublicNative;
+    setXpub(value: HdPublicNative): void;
+    encryptedSeed(): Uint8Array;
+    setEncryptedSeed(value: Uint8Array): void;
+    static create(password: string, normalized_passphrase: string): WalletDataNative;
 }
 export declare class WalletManagerNative {
-    static createWallet(password: string, normalizedPassphrase: string): [number, WalletDataNative];
-    static decryptSeed(password: string, encryptedSeed: EncryptedSeedNative): [number, LongHashNative];
+    static decryptSeed(password: string, encrypted_seed: Uint8Array): LongHashNative;
 }
 export declare class NodeInfoNative {
     static printThreadId(): void;
@@ -284,39 +443,295 @@ export declare class NodeInfoNative {
     static marchNames(): string;
     static currencySymbol(): string;
     static currency(): string;
+    static dbType(mode: DbMode): string;
     static cppapiBuildTimestamp(): number;
+    static utxozReferenceMode(): boolean;
+    static embeddedBloomAvailable(): boolean;
+    static embeddedBloomCheckpointHeight(): number;
 }
+declare const _OpcodeEnumNativeIntToKey: {
+    readonly '0': "push_size_0";
+    readonly '1': "push_size_1";
+    readonly '2': "push_size_2";
+    readonly '3': "push_size_3";
+    readonly '4': "push_size_4";
+    readonly '5': "push_size_5";
+    readonly '6': "push_size_6";
+    readonly '7': "push_size_7";
+    readonly '8': "push_size_8";
+    readonly '9': "push_size_9";
+    readonly '10': "push_size_10";
+    readonly '11': "push_size_11";
+    readonly '12': "push_size_12";
+    readonly '13': "push_size_13";
+    readonly '14': "push_size_14";
+    readonly '15': "push_size_15";
+    readonly '16': "push_size_16";
+    readonly '17': "push_size_17";
+    readonly '18': "push_size_18";
+    readonly '19': "push_size_19";
+    readonly '20': "push_size_20";
+    readonly '21': "push_size_21";
+    readonly '22': "push_size_22";
+    readonly '23': "push_size_23";
+    readonly '24': "push_size_24";
+    readonly '25': "push_size_25";
+    readonly '26': "push_size_26";
+    readonly '27': "push_size_27";
+    readonly '28': "push_size_28";
+    readonly '29': "push_size_29";
+    readonly '30': "push_size_30";
+    readonly '31': "push_size_31";
+    readonly '32': "push_size_32";
+    readonly '33': "push_size_33";
+    readonly '34': "push_size_34";
+    readonly '35': "push_size_35";
+    readonly '36': "push_size_36";
+    readonly '37': "push_size_37";
+    readonly '38': "push_size_38";
+    readonly '39': "push_size_39";
+    readonly '40': "push_size_40";
+    readonly '41': "push_size_41";
+    readonly '42': "push_size_42";
+    readonly '43': "push_size_43";
+    readonly '44': "push_size_44";
+    readonly '45': "push_size_45";
+    readonly '46': "push_size_46";
+    readonly '47': "push_size_47";
+    readonly '48': "push_size_48";
+    readonly '49': "push_size_49";
+    readonly '50': "push_size_50";
+    readonly '51': "push_size_51";
+    readonly '52': "push_size_52";
+    readonly '53': "push_size_53";
+    readonly '54': "push_size_54";
+    readonly '55': "push_size_55";
+    readonly '56': "push_size_56";
+    readonly '57': "push_size_57";
+    readonly '58': "push_size_58";
+    readonly '59': "push_size_59";
+    readonly '60': "push_size_60";
+    readonly '61': "push_size_61";
+    readonly '62': "push_size_62";
+    readonly '63': "push_size_63";
+    readonly '64': "push_size_64";
+    readonly '65': "push_size_65";
+    readonly '66': "push_size_66";
+    readonly '67': "push_size_67";
+    readonly '68': "push_size_68";
+    readonly '69': "push_size_69";
+    readonly '70': "push_size_70";
+    readonly '71': "push_size_71";
+    readonly '72': "push_size_72";
+    readonly '73': "push_size_73";
+    readonly '74': "push_size_74";
+    readonly '75': "push_size_75";
+    readonly '76': "push_one_size";
+    readonly '77': "push_two_size";
+    readonly '78': "push_four_size";
+    readonly '79': "push_negative_1";
+    readonly '80': "reserved_80";
+    readonly '81': "push_positive_1";
+    readonly '82': "push_positive_2";
+    readonly '83': "push_positive_3";
+    readonly '84': "push_positive_4";
+    readonly '85': "push_positive_5";
+    readonly '86': "push_positive_6";
+    readonly '87': "push_positive_7";
+    readonly '88': "push_positive_8";
+    readonly '89': "push_positive_9";
+    readonly '90': "push_positive_10";
+    readonly '91': "push_positive_11";
+    readonly '92': "push_positive_12";
+    readonly '93': "push_positive_13";
+    readonly '94': "push_positive_14";
+    readonly '95': "push_positive_15";
+    readonly '96': "push_positive_16";
+    readonly '97': "nop";
+    readonly '98': "reserved_98";
+    readonly '99': "if_";
+    readonly '100': "notif";
+    readonly '101': "op_begin";
+    readonly '102': "op_until";
+    readonly '103': "else_";
+    readonly '104': "endif";
+    readonly '105': "verify";
+    readonly '106': "return_";
+    readonly '107': "toaltstack";
+    readonly '108': "fromaltstack";
+    readonly '109': "drop2";
+    readonly '110': "dup2";
+    readonly '111': "dup3";
+    readonly '112': "over2";
+    readonly '113': "rot2";
+    readonly '114': "swap2";
+    readonly '115': "ifdup";
+    readonly '116': "depth";
+    readonly '117': "drop";
+    readonly '118': "dup";
+    readonly '119': "nip";
+    readonly '120': "over";
+    readonly '121': "pick";
+    readonly '122': "roll";
+    readonly '123': "rot";
+    readonly '124': "swap";
+    readonly '125': "tuck";
+    readonly '126': "cat";
+    readonly '127': "split";
+    readonly '128': "num2bin";
+    readonly '129': "bin2num";
+    readonly '130': "size";
+    readonly '131': "op_invert";
+    readonly '132': "and_";
+    readonly '133': "or_";
+    readonly '134': "xor_";
+    readonly '135': "equal";
+    readonly '136': "equalverify";
+    readonly '137': "op_define";
+    readonly '138': "op_invoke";
+    readonly '139': "add1";
+    readonly '140': "sub1";
+    readonly '141': "op_lshiftnum";
+    readonly '142': "op_rshiftnum";
+    readonly '143': "negate";
+    readonly '144': "abs";
+    readonly '145': "not_";
+    readonly '146': "nonzero";
+    readonly '147': "add";
+    readonly '148': "sub";
+    readonly '149': "mul";
+    readonly '150': "div";
+    readonly '151': "mod";
+    readonly '152': "op_lshiftbin";
+    readonly '153': "op_rshiftbin";
+    readonly '154': "booland";
+    readonly '155': "boolor";
+    readonly '156': "numequal";
+    readonly '157': "numequalverify";
+    readonly '158': "numnotequal";
+    readonly '159': "lessthan";
+    readonly '160': "greaterthan";
+    readonly '161': "lessthanorequal";
+    readonly '162': "greaterthanorequal";
+    readonly '163': "min";
+    readonly '164': "max";
+    readonly '165': "within";
+    readonly '166': "ripemd160";
+    readonly '167': "sha1";
+    readonly '168': "sha256";
+    readonly '169': "hash160";
+    readonly '170': "hash256";
+    readonly '171': "codeseparator";
+    readonly '172': "checksig";
+    readonly '173': "checksigverify";
+    readonly '174': "checkmultisig";
+    readonly '175': "checkmultisigverify";
+    readonly '176': "nop1";
+    readonly '177': "nop2";
+    readonly '178': "nop3";
+    readonly '179': "nop4";
+    readonly '180': "nop5";
+    readonly '181': "nop6";
+    readonly '182': "nop7";
+    readonly '183': "nop8";
+    readonly '184': "nop9";
+    readonly '185': "nop10";
+    readonly '186': "checkdatasig";
+    readonly '187': "checkdatasigverify";
+    readonly '188': "reverse_bytes";
+    readonly '192': "input_index";
+    readonly '193': "active_bytecode";
+    readonly '194': "tx_version";
+    readonly '195': "tx_input_count";
+    readonly '196': "tx_output_count";
+    readonly '197': "tx_locktime";
+    readonly '198': "utxo_value";
+    readonly '199': "utxo_bytecode";
+    readonly '200': "outpoint_tx_hash";
+    readonly '201': "outpoint_index";
+    readonly '202': "input_bytecode";
+    readonly '203': "input_sequence_number";
+    readonly '204': "output_value";
+    readonly '205': "output_bytecode";
+    readonly '206': "utxo_token_category";
+    readonly '207': "utxo_token_commitment";
+    readonly '208': "utxo_token_amount";
+    readonly '209': "output_token_category";
+    readonly '210': "output_token_commitment";
+    readonly '211': "output_token_amount";
+    readonly '212': "reserved_212";
+    readonly '213': "reserved_213";
+    readonly '214': "reserved_214";
+    readonly '215': "reserved_215";
+    readonly '216': "reserved_216";
+    readonly '217': "reserved_217";
+    readonly '218': "reserved_218";
+    readonly '219': "reserved_219";
+    readonly '220': "reserved_220";
+    readonly '221': "reserved_221";
+    readonly '222': "reserved_222";
+    readonly '223': "reserved_223";
+    readonly '224': "reserved_224";
+    readonly '225': "reserved_225";
+    readonly '226': "reserved_226";
+    readonly '227': "reserved_227";
+    readonly '228': "reserved_228";
+    readonly '229': "reserved_229";
+    readonly '230': "reserved_230";
+    readonly '231': "reserved_231";
+    readonly '232': "reserved_232";
+    readonly '233': "reserved_233";
+    readonly '234': "reserved_234";
+    readonly '235': "reserved_235";
+    readonly '236': "reserved_236";
+    readonly '237': "reserved_237";
+    readonly '238': "reserved_238";
+    readonly '239': "reserved_239";
+    readonly '240': "reserved_240";
+    readonly '241': "reserved_241";
+    readonly '242': "reserved_242";
+    readonly '243': "reserved_243";
+    readonly '244': "reserved_244";
+    readonly '245': "reserved_245";
+    readonly '246': "reserved_246";
+    readonly '247': "reserved_247";
+    readonly '248': "reserved_248";
+    readonly '249': "reserved_249";
+    readonly '250': "reserved_250";
+    readonly '251': "reserved_251";
+    readonly '252': "reserved_252";
+    readonly '253': "reserved_253";
+    readonly '254': "reserved_254";
+    readonly '255': "reserved_255";
+};
+export declare type OpcodeEnumNative = (typeof _OpcodeEnumNativeIntToKey)[keyof typeof _OpcodeEnumNativeIntToKey];
+export declare function OpcodeEnumNativeToInt(value: OpcodeEnumNative): number;
+export declare function OpcodeEnumNativeFromInt(value: number): OpcodeEnumNative;
 export declare class OpcodeNative {
-    static to_string(value: OpcodeEnumNative, active_forks: number): string;
-    static from_string(value: string): [boolean, OpcodeEnumNative];
-    static to_hexadecimal(code: OpcodeEnumNative): string;
-    static from_hexadecimal(value: string): [boolean, OpcodeEnumNative];
+    static toStr(value: OpcodeEnumNative, active_flags: bigint): string;
+    static fromStr(value: string): [boolean, OpcodeEnumNative];
+    static toHexadecimal(code: OpcodeEnumNative): string;
+    static fromHexadecimal(value: string): [boolean, OpcodeEnumNative];
 }
 export declare class OperationNative {
     private readonly [ptrSym];
     static _create(ptr: number): OperationNative;
     protected _destructor(): void;
     constructor();
-    constructor(opcode: OpcodeEnumNative);
-    constructor(encoded: Uint8Array, minimal: boolean);
-    toStr(activeForks: number): string;
-    toData(): Uint8Array;
-    fromData(encoded: Uint8Array): boolean;
-    fromStr(str: string): boolean;
+    constructor(code: OpcodeEnumNative);
+    constructor(uncoded: Uint8Array, minimal: boolean);
+    static fromData(data: Uint8Array): OperationNative;
+    copy(): OperationNative;
+    equals(other: OperationNative): boolean;
+    notEqual(other: OperationNative): boolean;
+    fromStr(mnemonic: string): boolean;
     isValid(): boolean;
+    toDataSimple(): Uint8Array;
+    toData(): Uint8Array;
+    toStr(active_flags: bigint): string;
     serializedSize(): number;
     code(): OpcodeEnumNative;
     data(): Uint8Array;
-    isPush(): boolean;
-    isCounted(): boolean;
-    isVersion(): boolean;
-    isPositive(): boolean;
-    isDisabled(activeForks: number): boolean;
-    isConditional(): boolean;
-    isRelaxedPush(): boolean;
-    isOversized(maxSize: number): boolean;
-    isMinimalPush(): boolean;
-    isNominalPush(): boolean;
     static opcodeFromSize(size: number): OpcodeEnumNative;
     static minimalOpcodeFromData(data: Uint8Array): OpcodeEnumNative;
     static nominalOpcodeFromData(data: Uint8Array): OpcodeEnumNative;
@@ -329,42 +744,65 @@ export declare class OperationNative {
     static opcodeIsNumeric(code: OpcodeEnumNative): boolean;
     static opcodeIsPositive(code: OpcodeEnumNative): boolean;
     static opcodeIsReserved(code: OpcodeEnumNative): boolean;
-    static opcodeIsDisabled(code: OpcodeEnumNative, activeForks: number): boolean;
+    static opcodeIsDisabled(code: OpcodeEnumNative, active_flags: bigint): boolean;
     static opcodeIsConditional(code: OpcodeEnumNative): boolean;
     static opcodeIsRelaxedPush(code: OpcodeEnumNative): boolean;
+    isPush(): boolean;
+    isCounted(): boolean;
+    isVersion(): boolean;
+    isPositive(): boolean;
+    isDisabled(active_flags: bigint): boolean;
+    isConditional(): boolean;
+    isRelaxedPush(): boolean;
+    isOversized(max_size: number): boolean;
+    isMinimalPush(): boolean;
+    isNominalPush(): boolean;
 }
 export declare class OperationListNative {
     private readonly [ptrSym];
     static _create(ptr: number): OperationListNative;
     protected _destructor(): void;
     constructor();
-    pushBack(operation: OperationNative): void;
+    pushBack(elem: OperationNative): void;
     count(): number;
     nth(index: number): OperationNative;
+    assignAt(index: number, elem: OperationNative): void;
+    erase(index: number): void;
 }
-declare const _ScriptPatternIntToKey: readonly ["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"];
+declare const _ScriptPatternIntToKey: readonly ["null_data", "pay_to_multisig", "pay_to_public_key", "pay_to_public_key_hash", "pay_to_script_hash", "pay_to_script_hash_32", "pay_to_script", "sign_multisig", "sign_public_key", "sign_public_key_hash", "sign_script_hash", "witness_reservation", "non_standard"];
 export declare type ScriptPattern = (typeof _ScriptPatternIntToKey)[number];
 export declare function ScriptPatternToInt(value: ScriptPattern): number;
+export declare function ScriptPatternFromInt(value: number): ScriptPattern;
 declare const _EndorsementTypeIntToKey: readonly ["ecdsa", "schnorr"];
 export declare type EndorsementType = (typeof _EndorsementTypeIntToKey)[number];
 export declare function EndorsementTypeToInt(value: EndorsementType): number;
+export declare function EndorsementTypeFromInt(value: number): EndorsementType;
 export declare class ScriptNative {
     private readonly [ptrSym];
     static _create(ptr: number): ScriptNative;
     protected _destructor(): void;
     constructor();
-    constructor(str: string);
-    constructor(operations: OperationListNative);
+    constructor(ops: OperationListNative);
     constructor(encoded: Uint8Array, prefix: boolean);
+    static fromData(data: Uint8Array, prefix: boolean): ScriptNative;
+    copy(): ScriptNative;
+    equals(other: ScriptNative): boolean;
+    notEqual(other: ScriptNative): boolean;
+    static fromDataWithSize(data: Uint8Array, size: number): ScriptNative;
+    fromOperations(ops: OperationListNative): void;
+    fromStr(mnemonic: string): boolean;
     isValid(): boolean;
     isValidOperations(): boolean;
-    satoshiContentSize(): number;
-    serializedSize(prefix: boolean): number;
-    toStr(activeForks: number): string;
-    type(): string;
     toData(prefix: boolean): Uint8Array;
+    toStr(active_flags: bigint): string;
+    serializedSize(prefix: boolean): number;
+    bytes(): Uint8Array;
     operations(): OperationListNative;
-    toBytes(): Uint8Array;
+    firstOperation(): OperationNative;
+    static generateSignatureHash(tx: TransactionNative, input_index: number, script_code: ScriptNative, sighash_type: number, active_flags: bigint, value: bigint): [HashNative, number];
+    static checkSignature(signature: LongHashNative, sighash_type: number, public_key: Uint8Array, script_code: ScriptNative, tx: TransactionNative, input_index: number, active_flags: bigint, value: bigint): [boolean, number];
+    static createEndorsement(secret: HashNative, prevout_script: ScriptNative, tx: TransactionNative, input_index: number, sighash_type: number, active_flags: bigint, value: bigint, type: EndorsementType): Uint8Array;
+    static isEnabled(active_flags: bigint, fork: bigint): boolean;
     static isPushOnly(ops: OperationListNative): boolean;
     static isRelaxedPush(ops: OperationListNative): boolean;
     static isCoinbasePattern(ops: OperationListNative, height: number): boolean;
@@ -373,174 +811,457 @@ export declare class ScriptNative {
     static isPayPublicKeyPattern(ops: OperationListNative): boolean;
     static isPayPublicKeyHashPattern(ops: OperationListNative): boolean;
     static isPayScriptHashPattern(ops: OperationListNative): boolean;
+    static isPayScriptHash32Pattern(ops: OperationListNative): boolean;
     static isSignMultisigPattern(ops: OperationListNative): boolean;
     static isSignPublicKeyPattern(ops: OperationListNative): boolean;
     static isSignPublicKeyHashPattern(ops: OperationListNative): boolean;
     static isSignScriptHashPattern(ops: OperationListNative): boolean;
-    static toNullDataPattern(data: Uint8Array): OperationListNative;
-    static toPayPublicKeyPattern(point: Uint8Array): OperationListNative;
+    static toNullDataPattern(data: Uint8Array): OperationListNative | null;
+    static toPayPublicKeyPattern(point: Uint8Array): OperationListNative | null;
     static toPayPublicKeyHashPattern(hash: ShortHashNative): OperationListNative;
+    static toPayPublicKeyHashPatternUnlocking(end: Uint8Array, pubkey: EcPublicNative): OperationListNative | null;
+    static toPayPublicKeyHashPatternUnlockingPlaceholder(endorsement_size: number, pubkey_size: number): OperationListNative;
+    static toPayScriptHashPatternUnlockingPlaceholder(script_size: number, multisig: boolean): OperationListNative;
     static toPayScriptHashPattern(hash: ShortHashNative): OperationListNative;
+    static toPayScriptHash32Pattern(hash: HashNative): OperationListNative;
+    static toPayMultisigPatternEcCompressedList(signatures: number, points: EcCompressedListNative): OperationListNative;
+    static toPayMultisigPatternDataStack(signatures: number, points: DataStackNative): OperationListNative;
     pattern(): ScriptPattern;
-    outputPattern(): ScriptPattern;
+    outputPatternSimple(): ScriptPattern;
+    outputPattern(flags: bigint): ScriptPattern;
     inputPattern(): ScriptPattern;
     sigops(accurate: boolean): number;
     isUnspendable(): boolean;
     reset(): void;
-    static createEndorsement(secret: EcSecretNative, prevoutScript: ScriptNative, tx: TransactionNative, inputIndex: number, sighashType: number, activeForks: number, value: bigint, endorsementType: EndorsementType): Uint8Array;
-    static verify(tx: TransactionNative, input: number, forks: number, inputScript: ScriptNative, prevoutScript: ScriptNative, value: bigint): number;
-    static verifyTransaction(tx: TransactionNative, input: number, forks: number): number;
+    isPayToScriptHash(flags: bigint): boolean;
+    isPayToScriptHash32(flags: bigint): boolean;
+    static verify(tx: TransactionNative, input_index: number, flags: bigint, input_script: ScriptNative, prevout_script: ScriptNative, value: bigint): number;
+    static verifySimple(tx: TransactionNative, input: number, flags: bigint): number;
+}
+export declare class PointNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): PointNative;
+    protected _destructor(): void;
+    constructor(hash: HashNative, index: number);
+    static fromData(data: Uint8Array, wire?: boolean): PointNative;
+    copy(): PointNative;
+    equals(other: PointNative): boolean;
+    notEqual(other: PointNative): boolean;
+    less(x: PointNative): boolean;
+    greater(x: PointNative): boolean;
+    lessOrEqual(x: PointNative): boolean;
+    greaterOrEqual(x: PointNative): boolean;
+    toData(wire: boolean): Uint8Array;
+    static satoshiFixedSize(): number;
+    serializedSize(wire?: boolean): number;
+    static createNull(): PointNative;
+    hash(): HashNative;
+    index(): number;
+    checksum(): bigint;
+    isNull(): boolean;
 }
 export declare class OutputPointNative {
     private readonly [ptrSym];
     static _create(ptr: number): OutputPointNative;
     protected _destructor(): void;
     constructor();
+    constructor(x: PointNative);
     constructor(hash: HashNative, index: number);
+    static fromData(data: Uint8Array, wire?: boolean): OutputPointNative;
+    copy(): OutputPointNative;
+    static createNull(): OutputPointNative;
+    isMature(height: number): boolean;
+    isMatureWithTicks(ticks: BlockTicksNative, height: number): boolean;
+    equals(other: OutputPointNative): boolean;
+    notEqual(other: OutputPointNative): boolean;
+    less(x: OutputPointNative): boolean;
+    greater(x: OutputPointNative): boolean;
+    lessOrEqual(x: OutputPointNative): boolean;
+    greaterOrEqual(x: OutputPointNative): boolean;
+    toData(wire: boolean): Uint8Array;
+    static satoshiFixedSize(): number;
+    serializedSize(wire?: boolean): number;
     hash(): HashNative;
     index(): number;
-    cachedOutput(): OutputNative;
-    setHash(hash: HashNative): void;
-    setIndex(index: number): void;
-    setCachedOutput(output: OutputNative): void;
+    checksum(): bigint;
+    isNull(): boolean;
 }
-declare const _TokenKindIntToKey: readonly ["none", "fungible", "non_fungible", "both"];
+declare const _TokenKindIntToKey: readonly ["fungible_only", "non_fungible_only", "both"];
 export declare type TokenKind = (typeof _TokenKindIntToKey)[number];
 export declare function TokenKindToInt(value: TokenKind): number;
-declare const _TokenCapabilityIntToKey: readonly ["none", "mutable", "minting"];
+export declare function TokenKindFromInt(value: number): TokenKind;
+declare const _TokenCapabilityIntToKey: readonly ["none", "mut", "minting"];
 export declare type TokenCapability = (typeof _TokenCapabilityIntToKey)[number];
 export declare function TokenCapabilityToInt(value: TokenCapability): number;
+export declare function TokenCapabilityFromInt(value: number): TokenCapability;
 export declare class TokenDataNative {
     private readonly [ptrSym];
+    private constructor();
     static _create(ptr: number): TokenDataNative;
     protected _destructor(): void;
-    static constructFungible(category: HashNative, amount: bigint): TokenDataNative;
-    static constructNonFungible(category: HashNative, capability: TokenCapability, commitmentData: Uint8Array): TokenDataNative;
-    static constructBothKinds(category: HashNative, amount: bigint, capability: TokenCapability, commitmentData: Uint8Array): TokenDataNative;
+    static fromData(data: Uint8Array): TokenDataNative;
+    copy(): TokenDataNative;
+    id(): HashNative;
+    setId(value: HashNative): void;
+    equals(other: TokenDataNative): boolean;
+    notEqual(other: TokenDataNative): boolean;
+    less(x: TokenDataNative): boolean;
+    greater(x: TokenDataNative): boolean;
+    lessOrEqual(x: TokenDataNative): boolean;
+    greaterOrEqual(x: TokenDataNative): boolean;
+    static makeFungible(id: HashNative, amount: bigint): TokenDataNative | null;
+    static makeNonFungible(id: HashNative, capability: TokenCapability, commitment: Uint8Array): TokenDataNative | null;
+    static makeBoth(id: HashNative, amount: bigint, capability: TokenCapability, commitment: Uint8Array): TokenDataNative | null;
+    getKind(): TokenKind;
     isValid(): boolean;
+    getAmount(): bigint;
+    hasNft(): boolean;
+    isFungibleOnly(): boolean;
+    getNftCapability(): TokenCapability;
+    getNftCommitment(): Uint8Array;
+    isImmutableNft(): boolean;
+    isMutableNft(): boolean;
+    isMintingNft(): boolean;
     serializedSize(): number;
+    bitfield(): number;
     toData(): Uint8Array;
-    kind(): TokenKind;
-    category(): HashNative;
-    fungibleAmount(): bigint;
-    nonFungibleCapability(): TokenCapability;
-    nonFungibleCommitment(): Uint8Array;
 }
 export declare class UtxoNative {
     private readonly [ptrSym];
     static _create(ptr: number): UtxoNative;
     protected _destructor(): void;
     constructor();
-    static fromPointAmount(hash: HashNative, index: number, amount: bigint): UtxoNative;
-    static fromPointAmountFungible(hash: HashNative, index: number, amount: bigint, category: HashNative, tokenAmount: bigint): UtxoNative;
-    static fromPointAmountNonFungible(hash: HashNative, index: number, amount: bigint, category: HashNative, capability: TokenCapability, commitmentData: Uint8Array): UtxoNative;
-    static fromPointAmountBothKinds(hash: HashNative, index: number, amount: bigint, category: HashNative, tokenAmount: bigint, capability: TokenCapability, commitmentData: Uint8Array): UtxoNative;
-    hash(): HashNative;
-    index(): number;
+    constructor(point: OutputPointNative, amount: bigint, token_data: TokenDataNative | null);
+    copy(): UtxoNative;
+    equals(other: UtxoNative): boolean;
+    notEqual(other: UtxoNative): boolean;
+    less(x: UtxoNative): boolean;
+    greater(x: UtxoNative): boolean;
+    lessOrEqual(x: UtxoNative): boolean;
+    greaterOrEqual(x: UtxoNative): boolean;
+    height(): number;
+    point(): OutputPointNative;
     amount(): bigint;
-    cachedOutput(): OutputNative;
-    hasTokenData(): boolean;
-    tokenData(): TokenDataNative;
-    tokenCategory(): HashNative;
-    tokenAmount(): bigint;
-    setHash(hash: HashNative): void;
-    setIndex(index: number): void;
-    setAmount(amount: bigint): void;
-    setCachedOutput(output: OutputNative): void;
-    setTokenData(token_data: TokenDataNative): void;
-    setTokenCategory(category: HashNative): void;
-    setTokenAmount(amount: bigint): void;
+    tokenData(): TokenDataNative | null;
 }
 export declare class OutputNative {
     private readonly [ptrSym];
     static _create(ptr: number): OutputNative;
     protected _destructor(): void;
     constructor();
-    constructor(value: bigint, script: ScriptNative);
-    constructor(value: bigint, script: ScriptNative, tokenData: TokenDataNative);
-    static fromData(data: Uint8Array): OutputNative;
+    constructor(value: bigint, script: ScriptNative, token_data: TokenDataNative | null);
+    static fromData(data: Uint8Array, wire?: boolean): OutputNative;
+    copy(): OutputNative;
+    equals(other: OutputNative): boolean;
+    notEqual(other: OutputNative): boolean;
     toData(wire: boolean): Uint8Array;
-    serializedSize(wire: boolean): number;
-    isValid(): boolean;
+    serializedSize(wire?: boolean): number;
     value(): bigint;
+    setValue(value: bigint): void;
     script(): ScriptNative;
-    hasTokenData(): boolean;
-    tokenData(): TokenDataNative;
+    setScript(value: ScriptNative): void;
+    tokenData(): TokenDataNative | null;
+    setTokenData(value: TokenDataNative | null): void;
+    addressSimple(testnet?: boolean): PaymentAddressNative | null;
+    address(p2kh_version: number, p2sh_version: number): PaymentAddressNative | null;
+    addresses(p2kh_version: number, p2sh_version: number): PaymentAddressListNative;
+    isValid(): boolean;
+    signatureOperations(bip141: boolean): number;
+    isDust(minimum_output_value: bigint): boolean;
+    reset(): void;
 }
 export declare class InputNative {
     private readonly [ptrSym];
     static _create(ptr: number): InputNative;
     protected _destructor(): void;
-    constructor();
-    constructor(previousOutput: OutputPointNative, script: ScriptNative, seq: number);
-    static fromData(data: Uint8Array): InputNative;
+    constructor(previous_output: OutputPointNative, script: ScriptNative, sequence_value: number);
+    static fromData(data: Uint8Array, wire: boolean): InputNative;
+    copy(): InputNative;
+    equals(other: InputNative): boolean;
+    notEqual(other: InputNative): boolean;
     toData(wire: boolean): Uint8Array;
-    serializedSize(wire: boolean): number;
-    isValid(): boolean;
-    seq(): number;
-    script(): ScriptNative;
+    serializedSize(wire?: boolean): number;
     previousOutput(): OutputPointNative;
+    setPreviousOutput(value: OutputPointNative): void;
+    script(): ScriptNative;
+    setScript(value: ScriptNative): void;
+    sequenceValue(): number;
+    setSequence(value: number): void;
+    address(): PaymentAddressNative | null;
+    addresses(): PaymentAddressListNative;
+    isFinal(): boolean;
+    isLocked(block_height: number, median_time_past: number): boolean;
+    isLockedWithTicks(ticks: BlockTicksNative, block_height: number, median_time_past: number): boolean;
+    signatureOperations(bip16: boolean, bip141: boolean): number;
+    extractEmbeddedScript(): ScriptNative;
 }
 export declare class OutputListNative {
     private readonly [ptrSym];
     static _create(ptr: number): OutputListNative;
     protected _destructor(): void;
     constructor();
-    pushBack(output: OutputNative): void;
+    pushBack(elem: OutputNative): void;
     count(): number;
     nth(index: number): OutputNative;
+    assignAt(index: number, elem: OutputNative): void;
+    erase(index: number): void;
 }
 export declare class InputListNative {
     private readonly [ptrSym];
     static _create(ptr: number): InputListNative;
     protected _destructor(): void;
     constructor();
-    pushBack(input: InputNative): void;
+    pushBack(elem: InputNative): void;
     count(): number;
     nth(index: number): InputNative;
+    assignAt(index: number, elem: InputNative): void;
+    erase(index: number): void;
+}
+export declare class OutputPointListNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): OutputPointListNative;
+    protected _destructor(): void;
+    constructor();
+    pushBack(elem: OutputPointNative): void;
+    count(): number;
+    nth(index: number): OutputPointNative;
+    assignAt(index: number, elem: OutputPointNative): void;
+    erase(index: number): void;
+}
+export declare class PointListNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): PointListNative;
+    protected _destructor(): void;
+    constructor();
+    pushBack(elem: PointNative): void;
+    count(): number;
+    nth(index: number): PointNative;
+    assignAt(index: number, elem: PointNative): void;
+    erase(index: number): void;
 }
 export declare class UtxoListNative {
     private readonly [ptrSym];
     static _create(ptr: number): UtxoListNative;
     protected _destructor(): void;
     constructor();
-    pushBack(utxo: UtxoNative): void;
+    pushBack(elem: UtxoNative): void;
     count(): number;
     nth(index: number): UtxoNative;
+    assignAt(index: number, elem: UtxoNative): void;
+    erase(index: number): void;
 }
 declare const _CoinSelectionAlgorithmIntToKey: readonly ["smallest_first", "largest_first", "manual", "send_all"];
 export declare type CoinSelectionAlgorithm = (typeof _CoinSelectionAlgorithmIntToKey)[number];
 export declare function CoinSelectionAlgorithmToInt(value: CoinSelectionAlgorithm): number;
+export declare function CoinSelectionAlgorithmFromInt(value: number): CoinSelectionAlgorithm;
 export declare class TransactionNative {
     private readonly [ptrSym];
     static _create(ptr: number): TransactionNative;
     protected _destructor(): void;
     constructor();
     constructor(version: number, locktime: number, inputs: InputListNative, outputs: OutputListNative);
-    static fromData(data: Uint8Array): TransactionNative;
+    static fromData(data: Uint8Array, wire?: boolean): TransactionNative;
+    static constructMove(version: number, locktime: number, inputs: InputListNative, outputs: OutputListNative): TransactionNative;
+    copy(): TransactionNative;
+    static createNull(): TransactionNative;
+    isNull(): boolean;
+    equals(other: TransactionNative): boolean;
+    notEqual(other: TransactionNative): boolean;
     toData(wire: boolean): Uint8Array;
-    serializedSize(wire: boolean): number;
-    isValid(): boolean;
-    hash(): HashNative;
+    serializedSize(wire?: boolean): number;
     version(): number;
     locktime(): number;
-    outputs(): OutputListNative;
     inputs(): InputListNative;
-    isCoinbase(): boolean;
+    outputs(): OutputListNative;
+    hash(): HashNative;
+    outputsHash(): HashNative;
+    inpointsHash(): HashNative;
+    sequencesHash(): HashNative;
+    utxosHash(): HashNative;
+    fees(): bigint;
+    previousOutputs(): PointListNative;
+    missingPreviousOutputs(): PointListNative;
+    missingPreviousTransactions(): HashListNative;
     totalInputValue(): bigint;
     totalOutputValue(): bigint;
-    fees(): bigint;
-    isMature(target_height: number): boolean;
-    static createTemplateWithChangeRatios(available_utxos: UtxoListNative, amount_to_send: bigint, destination_address: PaymentAddressNative, change_addresses: PaymentAddressListNative, change_ratios: DoubleListNative, selection_algo: CoinSelectionAlgorithm): [number, TransactionNative, U32ListNative, PaymentAddressListNative, U64ListNative];
-    static createTemplate(available_utxos: UtxoListNative, amount_to_send: bigint, destination_address: PaymentAddressNative, change_addresses: PaymentAddressListNative, selection_algo: CoinSelectionAlgorithm): [number, TransactionNative, U32ListNative, PaymentAddressListNative, U64ListNative];
+    signatureOperations(bip16: boolean, bip141: boolean): number;
+    isCoinbase(): boolean;
+    isNullNonCoinbase(): boolean;
+    isOversizedCoinbase(): boolean;
+    isMature(height: number): boolean;
+    isMatureWithTicks(ticks: BlockTicksNative, height: number): boolean;
+    isInternalDoubleSpend(): boolean;
+    isDoubleSpend(include_unconfirmed: boolean): boolean;
+    isDusty(minimum_output_value: bigint): boolean;
+    isMissingPreviousOutputs(): boolean;
+    isFinal(block_height: number, block_time: number): boolean;
+    isFinalWithTicks(ticks: BlockTicksNative, block_height: number, block_time: number): boolean;
+    isLocked(block_height: number, median_time_past: number): boolean;
+    isLockedWithTicks(ticks: BlockTicksNative, block_height: number, median_time_past: number): boolean;
+    isLocktimeConflict(): boolean;
+    isOverspent(): boolean;
+    check(max_block_size: number, transaction_pool: boolean, retarget: boolean): number;
+    minTxSize(flags: bigint): number;
+    accept(flags: bigint, height: number, median_time_past: number, max_sigops: number, is_under_checkpoint: boolean, transaction_pool: boolean, duplicate: boolean): number;
+    acceptWithTicks(ticks: BlockTicksNative, flags: bigint, height: number, median_time_past: number, max_sigops: number, is_under_checkpoint: boolean, transaction_pool: boolean, duplicate: boolean): number;
+    isStandardSimple(): boolean;
+    isStandard(flags: bigint): boolean;
+}
+export declare class TransactionListNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): TransactionListNative;
+    protected _destructor(): void;
+    constructor();
+    pushBack(elem: TransactionNative): void;
+    count(): number;
+    nth(index: number): TransactionNative;
+    assignAt(index: number, elem: TransactionNative): void;
+    erase(index: number): void;
 }
 export declare class InterpreterNative {
-    static run(program: ProgramNative): number;
-    static runOperation(operation: OperationNative, program: ProgramNative): number;
-    static debugStart(program: ProgramNative): [number, number];
-    static debugStepsAvailable(program: ProgramNative, step: number): boolean;
-    static debugStep(program: ProgramNative, step: number): [number, number, ProgramNative];
-    static debugEnd(program: ProgramNative): number;
+    static runSimple(program: ProgramNative): number;
+    static run(op: OperationNative, program: ProgramNative): number;
+    static debugBegin(prog: ProgramNative): DebugSnapshotNative;
+    static debugStep(snapshot: DebugSnapshotNative): DebugSnapshotNative;
+    static debugStepN(snapshot: DebugSnapshotNative, n: number): DebugSnapshotNative;
+    static debugRun(snapshot: DebugSnapshotNative): DebugSnapshotNative;
+    static debugRunTraced(start: DebugSnapshotNative): DebugSnapshotListNative;
+    static debugFinalize(snapshot: DebugSnapshotNative): number;
+}
+export declare class MetricsNative {
+    private readonly [ptrSym];
+    private constructor();
+    static _create(ptr: number): MetricsNative;
+    protected _destructor(): void;
+    copy(): MetricsNative;
+    sigChecks(): number;
+    opCost(): bigint;
+    hashDigestIterations(): bigint;
+    addOpCost(cost: number): void;
+    addPushOp(stack_item_length: number): void;
+    addHashIterations(message_length: number, is_two_round_hash: boolean): void;
+    addSigChecks(n_checks: number): void;
+    isOverOpCostLimit(flags: bigint): boolean;
+    isOverOpCostLimitSimple(): boolean;
+    isOverHashItersLimit(): boolean;
+    hasValidScriptLimits(): boolean;
+    setScriptLimits(flags: bigint, script_sig_size: bigint): void;
+    setNativeScriptLimits(standard: boolean, script_sig_size: bigint): void;
+    compositeOpCostScriptFlags(flags: bigint): bigint;
+    compositeOpCostBool(standard: boolean): bigint;
+}
+export declare class ScriptExecutionContextNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): ScriptExecutionContextNative;
+    protected _destructor(): void;
+    constructor(input_index: number, transaction: TransactionNative);
+    copy(): ScriptExecutionContextNative;
+    inputIndex(): number;
+    transaction(): TransactionNative;
+    inputCount(): number;
+    outputCount(): number;
+    txVersion(): number;
+    txLocktime(): number;
+}
+export declare class DebugSnapshotNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): DebugSnapshotNative;
+    protected _destructor(): void;
+    constructor();
+    constructor(p: ProgramNative);
+    copy(): DebugSnapshotNative;
+    prog(): ProgramNative;
+    step(): number;
+    last(): number;
+    done(): boolean;
+    controlStack(): BoolListNative;
+    loopStack(): U64ListNative;
+    invokeDepth(): number;
+    outerLoopDepth(): number;
+}
+export declare class DebugSnapshotListNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): DebugSnapshotListNative;
+    protected _destructor(): void;
+    constructor();
+    pushBack(elem: DebugSnapshotNative): void;
+    count(): number;
+    nth(index: number): DebugSnapshotNative;
+    assignAt(index: number, elem: DebugSnapshotNative): void;
+    erase(index: number): void;
+}
+export declare class NumberNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): NumberNative;
+    protected _destructor(): void;
+    constructor();
+    copy(): NumberNative;
+    static fromInt(value: bigint): NumberNative;
+    valid(max_size: number): boolean;
+    setData(data: Uint8Array, max_size: number): boolean;
+    data(): Uint8Array;
+    int32(): number;
+    int64(): bigint;
+    isTrue(): boolean;
+    isFalse(): boolean;
+    greater(value: bigint): boolean;
+    less(value: bigint): boolean;
+    greaterOrEqual(value: bigint): boolean;
+    lessOrEqual(value: bigint): boolean;
+    equals(other: NumberNative): boolean;
+    notEqual(other: NumberNative): boolean;
+    addInt64(value: bigint): NumberNative;
+    subtractInt64(value: bigint): NumberNative;
+    addNumber(x: NumberNative): NumberNative;
+    subtractNumber(x: NumberNative): NumberNative;
+    multiply(x: NumberNative): NumberNative;
+    safeAddNumber(x: NumberNative): boolean;
+    safeAddInt64(x: bigint): boolean;
+    safeSubNumber(x: NumberNative): boolean;
+    safeSubInt64(x: bigint): boolean;
+    safeMulNumber(x: NumberNative): boolean;
+    safeMulInt64(x: bigint): boolean;
+    static safeAddNumber2(x: NumberNative, y: NumberNative): NumberNative;
+    static safeSubNumber2(x: NumberNative, y: NumberNative): NumberNative;
+    static safeMulNumber2(x: NumberNative, y: NumberNative): NumberNative;
+    static isMinimallyEncoded(data: Uint8Array, max_integer_size: number): boolean;
+    static minimallyEncode(data: Uint8Array): Uint8Array;
+}
+export declare class BigNumberNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): BigNumberNative;
+    protected _destructor(): void;
+    constructor();
+    constructor(value: bigint);
+    constructor(decimal_str: string);
+    copy(): BigNumberNative;
+    static fromHex(hex_str: string): BigNumberNative;
+    serialize(): Uint8Array;
+    deserialize(data: Uint8Array): boolean;
+    toStr(): string;
+    toHex(): string;
+    sign(): number;
+    isZero(): boolean;
+    isNonzero(): boolean;
+    isNegative(): boolean;
+    toInt32Saturating(): number;
+    byteCount(): number;
+    compare(other: BigNumberNative): number;
+    equals(other: BigNumberNative): boolean;
+    notEqual(other: BigNumberNative): boolean;
+    add(other: BigNumberNative): BigNumberNative;
+    subtract(other: BigNumberNative): BigNumberNative;
+    multiply(other: BigNumberNative): BigNumberNative;
+    abs(): BigNumberNative;
+    negate(): void;
+    pow(exp: BigNumberNative): BigNumberNative;
+    powMod(exp: BigNumberNative, mod: BigNumberNative): BigNumberNative;
+    mathModulo(mod: BigNumberNative): BigNumberNative;
+    data(): Uint8Array;
+    setData(d: Uint8Array, max_size: number): boolean;
+    isTrue(): boolean;
+    isFalse(): boolean;
+    static isMinimallyEncoded(data: Uint8Array, max_size: number): boolean;
 }
 export declare class ProgramNative {
     private readonly [ptrSym];
@@ -548,18 +1269,87 @@ export declare class ProgramNative {
     protected _destructor(): void;
     constructor();
     constructor(script: ScriptNative);
-    constructor(script: ScriptNative, program: ProgramNative);
-    constructor(script: ScriptNative, transaction: TransactionNative, inputIndex: number, forks: number);
+    constructor(script: ScriptNative, x: ProgramNative);
+    constructor(script: ScriptNative, x: ProgramNative, move: boolean);
+    constructor(script: ScriptNative, transaction: TransactionNative, input_index: number, flags: bigint, value: bigint);
+    constructor(script: ScriptNative, transaction: TransactionNative, input_index: number, flags: bigint, stack: DataStackNative, value: bigint);
+    copy(): ProgramNative;
+    getMetrics(): MetricsNative;
     isValid(): boolean;
-    evaluate(): number;
+    flags(): bigint;
+    maxScriptElementSize(): number;
+    maxIntegerSizeLegacy(): number;
+    maxIntegerSize(): number;
+    isChipVmLimitsEnabled(): boolean;
+    isBigintEnabled(): boolean;
+    inputIndex(): number;
+    value(): bigint;
+    transaction(): TransactionNative;
+    context(): ScriptExecutionContextNative | null;
+    getScript(): ScriptNative;
+    resetActiveScript(): void;
+    operationCount(): number;
+    evaluateSimple(): number;
+    evaluate(op: OperationNative): number;
+    incrementOperationCountOperation(op: OperationNative): boolean;
+    incrementOperationCountInt32(public_keys: number): boolean;
+    markCodeSeparator(pc: number): boolean;
+    push(value: boolean): void;
+    pushMove(item: Uint8Array): void;
+    pushCopy(item: Uint8Array): void;
+    drop(): void;
+    popSimple(): Uint8Array;
+    popInt32(): number;
+    popInt64(): bigint;
+    popNumber(maximum_size: number): NumberNative;
+    popBinary(): [NumberNative, NumberNative];
+    popTernary(): [NumberNative, NumberNative, NumberNative];
+    popBigNumber(maximum_size: number): BigNumberNative;
+    popBigBinary(): [BigNumberNative, BigNumberNative];
+    popBigTernary(): [BigNumberNative, BigNumberNative, BigNumberNative];
+    popIndex(): number;
+    pop(count: number): DataStackNative;
+    duplicate(index: number): void;
+    swap(index_left: number, index_right: number): void;
+    empty(): boolean;
+    stackTrue(clean: boolean): boolean;
     stackResult(clean: boolean): boolean;
-    size(): number;
+    isStackOverflowSimple(): boolean;
+    isStackOverflow(extra: number): boolean;
+    if(op: OperationNative): boolean;
     item(index: number): Uint8Array;
+    top(): Uint8Array;
+    topNumber(maximum_size: number): NumberNative;
+    topBigNumber(maximum_size: number): BigNumberNative;
+    subscript(): OperationListNative;
+    size(): number;
+    conditionalStackSize(): number;
+    emptyAlternate(): boolean;
+    pushAlternate(value: Uint8Array): void;
+    popAlternate(): Uint8Array;
+    open(value: boolean): void;
+    negate(): void;
+    close(): void;
+    closed(): boolean;
+    succeeded(): boolean;
+}
+export declare class BlockTicksNative {
+    private readonly [ptrSym];
+    static _create(ptr: number): BlockTicksNative;
+    protected _destructor(): void;
+    constructor();
+    copy(): BlockTicksNative;
+    static activatedAt(activation_height: bigint): BlockTicksNative;
+    heightToTick(height: bigint): bigint;
+    tickToHeight(tick: bigint): bigint;
+    blockInterval(height: bigint): bigint;
+    nextBlockInterval(height: bigint): bigint;
+    nextBlockTick(tip: bigint): bigint;
+    equals(other: BlockTicksNative): boolean;
+    notEqual(other: BlockTicksNative): boolean;
 }
 declare const _RuleForkEnumNativeIntToKey: readonly ["no_rules", "easy_blocks", "bip16_rule", "bip30_rule", "bip34_rule", "bip66_rule", "bip65_rule", "bip90_rule", "allow_collisions", "bip68_rule", "bip112_rule", "bip113_rule", "bch_uahf", "bch_daa_cw144", "bch_pythagoras", "bch_euclid", "bch_pisano", "bch_mersenne", "bch_fermat", "bch_euler", "bch_gauss", "bch_descartes", "bch_lobachevski", "bch_galois", "bch_leibniz", "retarget", "unverified", "bip34_activations", "bip9_bit0_group", "bip9_bit1_group", "all_rules"];
 export declare type RuleForkEnumNative = (typeof _RuleForkEnumNativeIntToKey)[number];
 export declare function RuleForkEnumNativeToInt(value: RuleForkEnumNative): number;
-declare const _OpcodeEnumNativeIntToKey: readonly ["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"];
-export declare type OpcodeEnumNative = (typeof _OpcodeEnumNativeIntToKey)[number];
-export declare function OpcodeEnumNativeToInt(value: OpcodeEnumNative): number;
+export declare function RuleForkEnumNativeFromInt(value: number): RuleForkEnumNative;
 export {};