@xstoicunicornx/payjoin_test 0.1.4 → 0.1.6

package/dist/generated/bitcoin.js

@@ -0,0 +1,3861 @@
+// This file was autogenerated by some hot garbage in the `uniffi-bindgen-react-native` crate.
+// Trust me, you don't want to mess with it!
+/* tslint:disable */
+/* eslint-disable */
+// @ts-nocheck
+import * as wasmBundle from "./wasm-bindgen/index.js";
+import { AbstractFfiConverterByteArray, FfiConverterArray, FfiConverterArrayBuffer, FfiConverterBool, FfiConverterFloat64, FfiConverterInt32, FfiConverterObject, FfiConverterUInt32, FfiConverterUInt64, FfiConverterUInt8, UniffiAbstractObject, UniffiError, UniffiInternalError, UniffiRustCaller, destructorGuardSymbol, pointerLiteralSymbol, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiTypeNameSymbol, } from "uniffi-bindgen-react-native";
+// Get converters from the other files, if any.
+const nativeModule = () => wasmBundle;
+const uniffiCaller = new UniffiRustCaller(() => new wasmBundle.RustCallStatus());
+const uniffiIsDebug = 
+// @ts-ignore -- The process global might not be defined
+typeof process !== "object" ||
+    // @ts-ignore -- The process global might not be defined
+    process?.env?.NODE_ENV !== "production" ||
+    false;
+/**
+ * Generated factory for {@link OutPoint} record objects.
+ */
+export const OutPoint = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        /**
+         * Create a frozen instance of {@link OutPoint}, with defaults specified
+         * in Rust, in the {@link bitcoin} crate.
+         */
+        create,
+        /**
+         * Create a frozen instance of {@link OutPoint}, with defaults specified
+         * in Rust, in the {@link bitcoin} crate.
+         */
+        new: create,
+        /**
+         * Defaults specified in the {@link bitcoin} crate.
+         */
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeOutPoint = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                txid: FfiConverterTypeTxid.read(from),
+                vout: FfiConverterUInt32.read(from),
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeTxid.write(value.txid, into);
+            FfiConverterUInt32.write(value.vout, into);
+        }
+        allocationSize(value) {
+            return (FfiConverterTypeTxid.allocationSize(value.txid) +
+                FfiConverterUInt32.allocationSize(value.vout));
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link TxIn} record objects.
+ */
+export const TxIn = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        /**
+         * Create a frozen instance of {@link TxIn}, with defaults specified
+         * in Rust, in the {@link bitcoin} crate.
+         */
+        create,
+        /**
+         * Create a frozen instance of {@link TxIn}, with defaults specified
+         * in Rust, in the {@link bitcoin} crate.
+         */
+        new: create,
+        /**
+         * Defaults specified in the {@link bitcoin} crate.
+         */
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeTxIn = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                previousOutput: FfiConverterTypeOutPoint.read(from),
+                scriptSig: FfiConverterTypeScript.read(from),
+                sequence: FfiConverterUInt32.read(from),
+                witness: FfiConverterArrayArrayBuffer.read(from),
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeOutPoint.write(value.previousOutput, into);
+            FfiConverterTypeScript.write(value.scriptSig, into);
+            FfiConverterUInt32.write(value.sequence, into);
+            FfiConverterArrayArrayBuffer.write(value.witness, into);
+        }
+        allocationSize(value) {
+            return (FfiConverterTypeOutPoint.allocationSize(value.previousOutput) +
+                FfiConverterTypeScript.allocationSize(value.scriptSig) +
+                FfiConverterUInt32.allocationSize(value.sequence) +
+                FfiConverterArrayArrayBuffer.allocationSize(value.witness));
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link TxOut} record objects.
+ */
+export const TxOut = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        /**
+         * Create a frozen instance of {@link TxOut}, with defaults specified
+         * in Rust, in the {@link bitcoin} crate.
+         */
+        create,
+        /**
+         * Create a frozen instance of {@link TxOut}, with defaults specified
+         * in Rust, in the {@link bitcoin} crate.
+         */
+        new: create,
+        /**
+         * Defaults specified in the {@link bitcoin} crate.
+         */
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeTxOut = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                value: FfiConverterTypeAmount.read(from),
+                scriptPubkey: FfiConverterTypeScript.read(from),
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeAmount.write(value.value, into);
+            FfiConverterTypeScript.write(value.scriptPubkey, into);
+        }
+        allocationSize(value) {
+            return (FfiConverterTypeAmount.allocationSize(value.value) +
+                FfiConverterTypeScript.allocationSize(value.scriptPubkey));
+        }
+    }
+    return new FFIConverter();
+})();
+const stringConverter = (() => {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    return {
+        stringToBytes: (s) => encoder.encode(s),
+        bytesToString: (ab) => decoder.decode(ab),
+        stringByteLength: (s) => encoder.encode(s).byteLength,
+    };
+})();
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+// FfiConverter for BlockHash, a type alias for string.
+const FfiConverterTypeBlockHash = FfiConverterString;
+// FfiConverter for Txid, a type alias for string.
+const FfiConverterTypeTxid = FfiConverterString;
+// Error type: AddressParseError
+// Enum: AddressParseError
+export var AddressParseError_Tags;
+(function (AddressParseError_Tags) {
+    AddressParseError_Tags["Base58"] = "Base58";
+    AddressParseError_Tags["Bech32"] = "Bech32";
+    AddressParseError_Tags["WitnessVersion"] = "WitnessVersion";
+    AddressParseError_Tags["WitnessProgram"] = "WitnessProgram";
+    AddressParseError_Tags["UnknownHrp"] = "UnknownHrp";
+    AddressParseError_Tags["LegacyAddressTooLong"] = "LegacyAddressTooLong";
+    AddressParseError_Tags["InvalidBase58PayloadLength"] = "InvalidBase58PayloadLength";
+    AddressParseError_Tags["InvalidLegacyPrefix"] = "InvalidLegacyPrefix";
+    AddressParseError_Tags["NetworkValidation"] = "NetworkValidation";
+    AddressParseError_Tags["OtherAddressParseErr"] = "OtherAddressParseErr";
+})(AddressParseError_Tags || (AddressParseError_Tags = {}));
+export const AddressParseError = (() => {
+    class Base58_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "AddressParseError";
+        tag = AddressParseError_Tags.Base58;
+        constructor() {
+            super("AddressParseError", "Base58");
+        }
+        static new() {
+            return new Base58_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === AddressParseError_Tags.Base58;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class Bech32_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "AddressParseError";
+        tag = AddressParseError_Tags.Bech32;
+        constructor() {
+            super("AddressParseError", "Bech32");
+        }
+        static new() {
+            return new Bech32_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === AddressParseError_Tags.Bech32;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class WitnessVersion_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "AddressParseError";
+        tag = AddressParseError_Tags.WitnessVersion;
+        inner;
+        constructor(inner) {
+            super("AddressParseError", "WitnessVersion");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new WitnessVersion_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === AddressParseError_Tags.WitnessVersion;
+        }
+        static hasInner(obj) {
+            return WitnessVersion_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class WitnessProgram_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "AddressParseError";
+        tag = AddressParseError_Tags.WitnessProgram;
+        inner;
+        constructor(inner) {
+            super("AddressParseError", "WitnessProgram");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new WitnessProgram_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === AddressParseError_Tags.WitnessProgram;
+        }
+        static hasInner(obj) {
+            return WitnessProgram_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class UnknownHrp_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "AddressParseError";
+        tag = AddressParseError_Tags.UnknownHrp;
+        constructor() {
+            super("AddressParseError", "UnknownHrp");
+        }
+        static new() {
+            return new UnknownHrp_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === AddressParseError_Tags.UnknownHrp;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class LegacyAddressTooLong_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "AddressParseError";
+        tag = AddressParseError_Tags.LegacyAddressTooLong;
+        constructor() {
+            super("AddressParseError", "LegacyAddressTooLong");
+        }
+        static new() {
+            return new LegacyAddressTooLong_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === AddressParseError_Tags.LegacyAddressTooLong;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class InvalidBase58PayloadLength_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "AddressParseError";
+        tag = AddressParseError_Tags.InvalidBase58PayloadLength;
+        constructor() {
+            super("AddressParseError", "InvalidBase58PayloadLength");
+        }
+        static new() {
+            return new InvalidBase58PayloadLength_();
+        }
+        static instanceOf(obj) {
+            return (obj.tag === AddressParseError_Tags.InvalidBase58PayloadLength);
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class InvalidLegacyPrefix_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "AddressParseError";
+        tag = AddressParseError_Tags.InvalidLegacyPrefix;
+        constructor() {
+            super("AddressParseError", "InvalidLegacyPrefix");
+        }
+        static new() {
+            return new InvalidLegacyPrefix_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === AddressParseError_Tags.InvalidLegacyPrefix;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class NetworkValidation_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "AddressParseError";
+        tag = AddressParseError_Tags.NetworkValidation;
+        constructor() {
+            super("AddressParseError", "NetworkValidation");
+        }
+        static new() {
+            return new NetworkValidation_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === AddressParseError_Tags.NetworkValidation;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class OtherAddressParseErr_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "AddressParseError";
+        tag = AddressParseError_Tags.OtherAddressParseErr;
+        constructor() {
+            super("AddressParseError", "OtherAddressParseErr");
+        }
+        static new() {
+            return new OtherAddressParseErr_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === AddressParseError_Tags.OtherAddressParseErr;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "AddressParseError";
+    }
+    return Object.freeze({
+        instanceOf,
+        Base58: Base58_,
+        Bech32: Bech32_,
+        WitnessVersion: WitnessVersion_,
+        WitnessProgram: WitnessProgram_,
+        UnknownHrp: UnknownHrp_,
+        LegacyAddressTooLong: LegacyAddressTooLong_,
+        InvalidBase58PayloadLength: InvalidBase58PayloadLength_,
+        InvalidLegacyPrefix: InvalidLegacyPrefix_,
+        NetworkValidation: NetworkValidation_,
+        OtherAddressParseErr: OtherAddressParseErr_,
+    });
+})();
+// FfiConverter for enum AddressParseError
+const FfiConverterTypeAddressParseError = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1:
+                    return new AddressParseError.Base58();
+                case 2:
+                    return new AddressParseError.Bech32();
+                case 3:
+                    return new AddressParseError.WitnessVersion({
+                        errorMessage: FfiConverterString.read(from),
+                    });
+                case 4:
+                    return new AddressParseError.WitnessProgram({
+                        errorMessage: FfiConverterString.read(from),
+                    });
+                case 5:
+                    return new AddressParseError.UnknownHrp();
+                case 6:
+                    return new AddressParseError.LegacyAddressTooLong();
+                case 7:
+                    return new AddressParseError.InvalidBase58PayloadLength();
+                case 8:
+                    return new AddressParseError.InvalidLegacyPrefix();
+                case 9:
+                    return new AddressParseError.NetworkValidation();
+                case 10:
+                    return new AddressParseError.OtherAddressParseErr();
+                default:
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case AddressParseError_Tags.Base58: {
+                    ordinalConverter.write(1, into);
+                    return;
+                }
+                case AddressParseError_Tags.Bech32: {
+                    ordinalConverter.write(2, into);
+                    return;
+                }
+                case AddressParseError_Tags.WitnessVersion: {
+                    ordinalConverter.write(3, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.errorMessage, into);
+                    return;
+                }
+                case AddressParseError_Tags.WitnessProgram: {
+                    ordinalConverter.write(4, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.errorMessage, into);
+                    return;
+                }
+                case AddressParseError_Tags.UnknownHrp: {
+                    ordinalConverter.write(5, into);
+                    return;
+                }
+                case AddressParseError_Tags.LegacyAddressTooLong: {
+                    ordinalConverter.write(6, into);
+                    return;
+                }
+                case AddressParseError_Tags.InvalidBase58PayloadLength: {
+                    ordinalConverter.write(7, into);
+                    return;
+                }
+                case AddressParseError_Tags.InvalidLegacyPrefix: {
+                    ordinalConverter.write(8, into);
+                    return;
+                }
+                case AddressParseError_Tags.NetworkValidation: {
+                    ordinalConverter.write(9, into);
+                    return;
+                }
+                case AddressParseError_Tags.OtherAddressParseErr: {
+                    ordinalConverter.write(10, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that AddressParseError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case AddressParseError_Tags.Base58: {
+                    return ordinalConverter.allocationSize(1);
+                }
+                case AddressParseError_Tags.Bech32: {
+                    return ordinalConverter.allocationSize(2);
+                }
+                case AddressParseError_Tags.WitnessVersion: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(3);
+                    size += FfiConverterString.allocationSize(inner.errorMessage);
+                    return size;
+                }
+                case AddressParseError_Tags.WitnessProgram: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(4);
+                    size += FfiConverterString.allocationSize(inner.errorMessage);
+                    return size;
+                }
+                case AddressParseError_Tags.UnknownHrp: {
+                    return ordinalConverter.allocationSize(5);
+                }
+                case AddressParseError_Tags.LegacyAddressTooLong: {
+                    return ordinalConverter.allocationSize(6);
+                }
+                case AddressParseError_Tags.InvalidBase58PayloadLength: {
+                    return ordinalConverter.allocationSize(7);
+                }
+                case AddressParseError_Tags.InvalidLegacyPrefix: {
+                    return ordinalConverter.allocationSize(8);
+                }
+                case AddressParseError_Tags.NetworkValidation: {
+                    return ordinalConverter.allocationSize(9);
+                }
+                case AddressParseError_Tags.OtherAddressParseErr: {
+                    return ordinalConverter.allocationSize(10);
+                }
+                default:
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+// Error type: EncodeError
+// Enum: EncodeError
+export var EncodeError_Tags;
+(function (EncodeError_Tags) {
+    EncodeError_Tags["Io"] = "Io";
+    EncodeError_Tags["OversizedVectorAllocation"] = "OversizedVectorAllocation";
+    EncodeError_Tags["InvalidChecksum"] = "InvalidChecksum";
+    EncodeError_Tags["NonMinimalVarInt"] = "NonMinimalVarInt";
+    EncodeError_Tags["ParseFailed"] = "ParseFailed";
+    EncodeError_Tags["UnsupportedSegwitFlag"] = "UnsupportedSegwitFlag";
+    EncodeError_Tags["OtherEncodeErr"] = "OtherEncodeErr";
+})(EncodeError_Tags || (EncodeError_Tags = {}));
+export const EncodeError = (() => {
+    class Io_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "EncodeError";
+        tag = EncodeError_Tags.Io;
+        constructor() {
+            super("EncodeError", "Io");
+        }
+        static new() {
+            return new Io_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === EncodeError_Tags.Io;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class OversizedVectorAllocation_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "EncodeError";
+        tag = EncodeError_Tags.OversizedVectorAllocation;
+        constructor() {
+            super("EncodeError", "OversizedVectorAllocation");
+        }
+        static new() {
+            return new OversizedVectorAllocation_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === EncodeError_Tags.OversizedVectorAllocation;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class InvalidChecksum_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "EncodeError";
+        tag = EncodeError_Tags.InvalidChecksum;
+        inner;
+        constructor(inner) {
+            super("EncodeError", "InvalidChecksum");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new InvalidChecksum_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === EncodeError_Tags.InvalidChecksum;
+        }
+        static hasInner(obj) {
+            return InvalidChecksum_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class NonMinimalVarInt_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "EncodeError";
+        tag = EncodeError_Tags.NonMinimalVarInt;
+        constructor() {
+            super("EncodeError", "NonMinimalVarInt");
+        }
+        static new() {
+            return new NonMinimalVarInt_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === EncodeError_Tags.NonMinimalVarInt;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class ParseFailed_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "EncodeError";
+        tag = EncodeError_Tags.ParseFailed;
+        constructor() {
+            super("EncodeError", "ParseFailed");
+        }
+        static new() {
+            return new ParseFailed_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === EncodeError_Tags.ParseFailed;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class UnsupportedSegwitFlag_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "EncodeError";
+        tag = EncodeError_Tags.UnsupportedSegwitFlag;
+        inner;
+        constructor(inner) {
+            super("EncodeError", "UnsupportedSegwitFlag");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new UnsupportedSegwitFlag_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === EncodeError_Tags.UnsupportedSegwitFlag;
+        }
+        static hasInner(obj) {
+            return UnsupportedSegwitFlag_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class OtherEncodeErr_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "EncodeError";
+        tag = EncodeError_Tags.OtherEncodeErr;
+        constructor() {
+            super("EncodeError", "OtherEncodeErr");
+        }
+        static new() {
+            return new OtherEncodeErr_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === EncodeError_Tags.OtherEncodeErr;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "EncodeError";
+    }
+    return Object.freeze({
+        instanceOf,
+        Io: Io_,
+        OversizedVectorAllocation: OversizedVectorAllocation_,
+        InvalidChecksum: InvalidChecksum_,
+        NonMinimalVarInt: NonMinimalVarInt_,
+        ParseFailed: ParseFailed_,
+        UnsupportedSegwitFlag: UnsupportedSegwitFlag_,
+        OtherEncodeErr: OtherEncodeErr_,
+    });
+})();
+// FfiConverter for enum EncodeError
+const FfiConverterTypeEncodeError = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1:
+                    return new EncodeError.Io();
+                case 2:
+                    return new EncodeError.OversizedVectorAllocation();
+                case 3:
+                    return new EncodeError.InvalidChecksum({
+                        expected: FfiConverterString.read(from),
+                        actual: FfiConverterString.read(from),
+                    });
+                case 4:
+                    return new EncodeError.NonMinimalVarInt();
+                case 5:
+                    return new EncodeError.ParseFailed();
+                case 6:
+                    return new EncodeError.UnsupportedSegwitFlag({
+                        flag: FfiConverterUInt8.read(from),
+                    });
+                case 7:
+                    return new EncodeError.OtherEncodeErr();
+                default:
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case EncodeError_Tags.Io: {
+                    ordinalConverter.write(1, into);
+                    return;
+                }
+                case EncodeError_Tags.OversizedVectorAllocation: {
+                    ordinalConverter.write(2, into);
+                    return;
+                }
+                case EncodeError_Tags.InvalidChecksum: {
+                    ordinalConverter.write(3, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.expected, into);
+                    FfiConverterString.write(inner.actual, into);
+                    return;
+                }
+                case EncodeError_Tags.NonMinimalVarInt: {
+                    ordinalConverter.write(4, into);
+                    return;
+                }
+                case EncodeError_Tags.ParseFailed: {
+                    ordinalConverter.write(5, into);
+                    return;
+                }
+                case EncodeError_Tags.UnsupportedSegwitFlag: {
+                    ordinalConverter.write(6, into);
+                    const inner = value.inner;
+                    FfiConverterUInt8.write(inner.flag, into);
+                    return;
+                }
+                case EncodeError_Tags.OtherEncodeErr: {
+                    ordinalConverter.write(7, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that EncodeError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case EncodeError_Tags.Io: {
+                    return ordinalConverter.allocationSize(1);
+                }
+                case EncodeError_Tags.OversizedVectorAllocation: {
+                    return ordinalConverter.allocationSize(2);
+                }
+                case EncodeError_Tags.InvalidChecksum: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(3);
+                    size += FfiConverterString.allocationSize(inner.expected);
+                    size += FfiConverterString.allocationSize(inner.actual);
+                    return size;
+                }
+                case EncodeError_Tags.NonMinimalVarInt: {
+                    return ordinalConverter.allocationSize(4);
+                }
+                case EncodeError_Tags.ParseFailed: {
+                    return ordinalConverter.allocationSize(5);
+                }
+                case EncodeError_Tags.UnsupportedSegwitFlag: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(6);
+                    size += FfiConverterUInt8.allocationSize(inner.flag);
+                    return size;
+                }
+                case EncodeError_Tags.OtherEncodeErr: {
+                    return ordinalConverter.allocationSize(7);
+                }
+                default:
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+// Error type: ExtractTxError
+// Enum: ExtractTxError
+export var ExtractTxError_Tags;
+(function (ExtractTxError_Tags) {
+    ExtractTxError_Tags["AbsurdFeeRate"] = "AbsurdFeeRate";
+    ExtractTxError_Tags["MissingInputValue"] = "MissingInputValue";
+    ExtractTxError_Tags["SendingTooMuch"] = "SendingTooMuch";
+    ExtractTxError_Tags["OtherExtractTxErr"] = "OtherExtractTxErr";
+})(ExtractTxError_Tags || (ExtractTxError_Tags = {}));
+export const ExtractTxError = (() => {
+    class AbsurdFeeRate_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "ExtractTxError";
+        tag = ExtractTxError_Tags.AbsurdFeeRate;
+        inner;
+        constructor(inner) {
+            super("ExtractTxError", "AbsurdFeeRate");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new AbsurdFeeRate_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === ExtractTxError_Tags.AbsurdFeeRate;
+        }
+        static hasInner(obj) {
+            return AbsurdFeeRate_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class MissingInputValue_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "ExtractTxError";
+        tag = ExtractTxError_Tags.MissingInputValue;
+        constructor() {
+            super("ExtractTxError", "MissingInputValue");
+        }
+        static new() {
+            return new MissingInputValue_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === ExtractTxError_Tags.MissingInputValue;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class SendingTooMuch_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "ExtractTxError";
+        tag = ExtractTxError_Tags.SendingTooMuch;
+        constructor() {
+            super("ExtractTxError", "SendingTooMuch");
+        }
+        static new() {
+            return new SendingTooMuch_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === ExtractTxError_Tags.SendingTooMuch;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class OtherExtractTxErr_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "ExtractTxError";
+        tag = ExtractTxError_Tags.OtherExtractTxErr;
+        constructor() {
+            super("ExtractTxError", "OtherExtractTxErr");
+        }
+        static new() {
+            return new OtherExtractTxErr_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === ExtractTxError_Tags.OtherExtractTxErr;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "ExtractTxError";
+    }
+    return Object.freeze({
+        instanceOf,
+        AbsurdFeeRate: AbsurdFeeRate_,
+        MissingInputValue: MissingInputValue_,
+        SendingTooMuch: SendingTooMuch_,
+        OtherExtractTxErr: OtherExtractTxErr_,
+    });
+})();
+// FfiConverter for enum ExtractTxError
+const FfiConverterTypeExtractTxError = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1:
+                    return new ExtractTxError.AbsurdFeeRate({
+                        feeRate: FfiConverterString.read(from),
+                    });
+                case 2:
+                    return new ExtractTxError.MissingInputValue();
+                case 3:
+                    return new ExtractTxError.SendingTooMuch();
+                case 4:
+                    return new ExtractTxError.OtherExtractTxErr();
+                default:
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case ExtractTxError_Tags.AbsurdFeeRate: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.feeRate, into);
+                    return;
+                }
+                case ExtractTxError_Tags.MissingInputValue: {
+                    ordinalConverter.write(2, into);
+                    return;
+                }
+                case ExtractTxError_Tags.SendingTooMuch: {
+                    ordinalConverter.write(3, into);
+                    return;
+                }
+                case ExtractTxError_Tags.OtherExtractTxErr: {
+                    ordinalConverter.write(4, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that ExtractTxError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case ExtractTxError_Tags.AbsurdFeeRate: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterString.allocationSize(inner.feeRate);
+                    return size;
+                }
+                case ExtractTxError_Tags.MissingInputValue: {
+                    return ordinalConverter.allocationSize(2);
+                }
+                case ExtractTxError_Tags.SendingTooMuch: {
+                    return ordinalConverter.allocationSize(3);
+                }
+                case ExtractTxError_Tags.OtherExtractTxErr: {
+                    return ordinalConverter.allocationSize(4);
+                }
+                default:
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+// Error type: FeeRateError
+// Enum: FeeRateError
+export var FeeRateError_Tags;
+(function (FeeRateError_Tags) {
+    FeeRateError_Tags["ArithmeticOverflow"] = "ArithmeticOverflow";
+})(FeeRateError_Tags || (FeeRateError_Tags = {}));
+export const FeeRateError = (() => {
+    class ArithmeticOverflow_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "FeeRateError";
+        tag = FeeRateError_Tags.ArithmeticOverflow;
+        constructor() {
+            super("FeeRateError", "ArithmeticOverflow");
+        }
+        static new() {
+            return new ArithmeticOverflow_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === FeeRateError_Tags.ArithmeticOverflow;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "FeeRateError";
+    }
+    return Object.freeze({
+        instanceOf,
+        ArithmeticOverflow: ArithmeticOverflow_,
+    });
+})();
+// FfiConverter for enum FeeRateError
+const FfiConverterTypeFeeRateError = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1:
+                    return new FeeRateError.ArithmeticOverflow();
+                default:
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case FeeRateError_Tags.ArithmeticOverflow: {
+                    ordinalConverter.write(1, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that FeeRateError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case FeeRateError_Tags.ArithmeticOverflow: {
+                    return ordinalConverter.allocationSize(1);
+                }
+                default:
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+// Error type: FromScriptError
+// Enum: FromScriptError
+export var FromScriptError_Tags;
+(function (FromScriptError_Tags) {
+    FromScriptError_Tags["UnrecognizedScript"] = "UnrecognizedScript";
+    FromScriptError_Tags["WitnessProgram"] = "WitnessProgram";
+    FromScriptError_Tags["WitnessVersion"] = "WitnessVersion";
+    FromScriptError_Tags["OtherFromScriptErr"] = "OtherFromScriptErr";
+})(FromScriptError_Tags || (FromScriptError_Tags = {}));
+export const FromScriptError = (() => {
+    class UnrecognizedScript_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "FromScriptError";
+        tag = FromScriptError_Tags.UnrecognizedScript;
+        constructor() {
+            super("FromScriptError", "UnrecognizedScript");
+        }
+        static new() {
+            return new UnrecognizedScript_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === FromScriptError_Tags.UnrecognizedScript;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class WitnessProgram_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "FromScriptError";
+        tag = FromScriptError_Tags.WitnessProgram;
+        inner;
+        constructor(inner) {
+            super("FromScriptError", "WitnessProgram");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new WitnessProgram_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === FromScriptError_Tags.WitnessProgram;
+        }
+        static hasInner(obj) {
+            return WitnessProgram_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class WitnessVersion_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "FromScriptError";
+        tag = FromScriptError_Tags.WitnessVersion;
+        inner;
+        constructor(inner) {
+            super("FromScriptError", "WitnessVersion");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new WitnessVersion_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === FromScriptError_Tags.WitnessVersion;
+        }
+        static hasInner(obj) {
+            return WitnessVersion_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class OtherFromScriptErr_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "FromScriptError";
+        tag = FromScriptError_Tags.OtherFromScriptErr;
+        constructor() {
+            super("FromScriptError", "OtherFromScriptErr");
+        }
+        static new() {
+            return new OtherFromScriptErr_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === FromScriptError_Tags.OtherFromScriptErr;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "FromScriptError";
+    }
+    return Object.freeze({
+        instanceOf,
+        UnrecognizedScript: UnrecognizedScript_,
+        WitnessProgram: WitnessProgram_,
+        WitnessVersion: WitnessVersion_,
+        OtherFromScriptErr: OtherFromScriptErr_,
+    });
+})();
+// FfiConverter for enum FromScriptError
+const FfiConverterTypeFromScriptError = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1:
+                    return new FromScriptError.UnrecognizedScript();
+                case 2:
+                    return new FromScriptError.WitnessProgram({
+                        errorMessage: FfiConverterString.read(from),
+                    });
+                case 3:
+                    return new FromScriptError.WitnessVersion({
+                        errorMessage: FfiConverterString.read(from),
+                    });
+                case 4:
+                    return new FromScriptError.OtherFromScriptErr();
+                default:
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case FromScriptError_Tags.UnrecognizedScript: {
+                    ordinalConverter.write(1, into);
+                    return;
+                }
+                case FromScriptError_Tags.WitnessProgram: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.errorMessage, into);
+                    return;
+                }
+                case FromScriptError_Tags.WitnessVersion: {
+                    ordinalConverter.write(3, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.errorMessage, into);
+                    return;
+                }
+                case FromScriptError_Tags.OtherFromScriptErr: {
+                    ordinalConverter.write(4, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that FromScriptError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case FromScriptError_Tags.UnrecognizedScript: {
+                    return ordinalConverter.allocationSize(1);
+                }
+                case FromScriptError_Tags.WitnessProgram: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterString.allocationSize(inner.errorMessage);
+                    return size;
+                }
+                case FromScriptError_Tags.WitnessVersion: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(3);
+                    size += FfiConverterString.allocationSize(inner.errorMessage);
+                    return size;
+                }
+                case FromScriptError_Tags.OtherFromScriptErr: {
+                    return ordinalConverter.allocationSize(4);
+                }
+                default:
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+export var Network;
+(function (Network) {
+    Network[Network["Bitcoin"] = 0] = "Bitcoin";
+    Network[Network["Testnet"] = 1] = "Testnet";
+    Network[Network["Testnet4"] = 2] = "Testnet4";
+    Network[Network["Signet"] = 3] = "Signet";
+    Network[Network["Regtest"] = 4] = "Regtest";
+})(Network || (Network = {}));
+const FfiConverterTypeNetwork = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1:
+                    return Network.Bitcoin;
+                case 2:
+                    return Network.Testnet;
+                case 3:
+                    return Network.Testnet4;
+                case 4:
+                    return Network.Signet;
+                case 5:
+                    return Network.Regtest;
+                default:
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case Network.Bitcoin:
+                    return ordinalConverter.write(1, into);
+                case Network.Testnet:
+                    return ordinalConverter.write(2, into);
+                case Network.Testnet4:
+                    return ordinalConverter.write(3, into);
+                case Network.Signet:
+                    return ordinalConverter.write(4, into);
+                case Network.Regtest:
+                    return ordinalConverter.write(5, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+// Error type: ParseAmountError
+// Enum: ParseAmountError
+export var ParseAmountError_Tags;
+(function (ParseAmountError_Tags) {
+    ParseAmountError_Tags["OutOfRange"] = "OutOfRange";
+    ParseAmountError_Tags["TooPrecise"] = "TooPrecise";
+    ParseAmountError_Tags["MissingDigits"] = "MissingDigits";
+    ParseAmountError_Tags["InputTooLarge"] = "InputTooLarge";
+    ParseAmountError_Tags["InvalidCharacter"] = "InvalidCharacter";
+    ParseAmountError_Tags["OtherParseAmountErr"] = "OtherParseAmountErr";
+})(ParseAmountError_Tags || (ParseAmountError_Tags = {}));
+export const ParseAmountError = (() => {
+    class OutOfRange_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "ParseAmountError";
+        tag = ParseAmountError_Tags.OutOfRange;
+        constructor() {
+            super("ParseAmountError", "OutOfRange");
+        }
+        static new() {
+            return new OutOfRange_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === ParseAmountError_Tags.OutOfRange;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class TooPrecise_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "ParseAmountError";
+        tag = ParseAmountError_Tags.TooPrecise;
+        constructor() {
+            super("ParseAmountError", "TooPrecise");
+        }
+        static new() {
+            return new TooPrecise_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === ParseAmountError_Tags.TooPrecise;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class MissingDigits_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "ParseAmountError";
+        tag = ParseAmountError_Tags.MissingDigits;
+        constructor() {
+            super("ParseAmountError", "MissingDigits");
+        }
+        static new() {
+            return new MissingDigits_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === ParseAmountError_Tags.MissingDigits;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class InputTooLarge_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "ParseAmountError";
+        tag = ParseAmountError_Tags.InputTooLarge;
+        constructor() {
+            super("ParseAmountError", "InputTooLarge");
+        }
+        static new() {
+            return new InputTooLarge_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === ParseAmountError_Tags.InputTooLarge;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class InvalidCharacter_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "ParseAmountError";
+        tag = ParseAmountError_Tags.InvalidCharacter;
+        inner;
+        constructor(inner) {
+            super("ParseAmountError", "InvalidCharacter");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new InvalidCharacter_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === ParseAmountError_Tags.InvalidCharacter;
+        }
+        static hasInner(obj) {
+            return InvalidCharacter_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class OtherParseAmountErr_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "ParseAmountError";
+        tag = ParseAmountError_Tags.OtherParseAmountErr;
+        constructor() {
+            super("ParseAmountError", "OtherParseAmountErr");
+        }
+        static new() {
+            return new OtherParseAmountErr_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === ParseAmountError_Tags.OtherParseAmountErr;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "ParseAmountError";
+    }
+    return Object.freeze({
+        instanceOf,
+        OutOfRange: OutOfRange_,
+        TooPrecise: TooPrecise_,
+        MissingDigits: MissingDigits_,
+        InputTooLarge: InputTooLarge_,
+        InvalidCharacter: InvalidCharacter_,
+        OtherParseAmountErr: OtherParseAmountErr_,
+    });
+})();
+// FfiConverter for enum ParseAmountError
+const FfiConverterTypeParseAmountError = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1:
+                    return new ParseAmountError.OutOfRange();
+                case 2:
+                    return new ParseAmountError.TooPrecise();
+                case 3:
+                    return new ParseAmountError.MissingDigits();
+                case 4:
+                    return new ParseAmountError.InputTooLarge();
+                case 5:
+                    return new ParseAmountError.InvalidCharacter({
+                        errorMessage: FfiConverterString.read(from),
+                    });
+                case 6:
+                    return new ParseAmountError.OtherParseAmountErr();
+                default:
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case ParseAmountError_Tags.OutOfRange: {
+                    ordinalConverter.write(1, into);
+                    return;
+                }
+                case ParseAmountError_Tags.TooPrecise: {
+                    ordinalConverter.write(2, into);
+                    return;
+                }
+                case ParseAmountError_Tags.MissingDigits: {
+                    ordinalConverter.write(3, into);
+                    return;
+                }
+                case ParseAmountError_Tags.InputTooLarge: {
+                    ordinalConverter.write(4, into);
+                    return;
+                }
+                case ParseAmountError_Tags.InvalidCharacter: {
+                    ordinalConverter.write(5, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.errorMessage, into);
+                    return;
+                }
+                case ParseAmountError_Tags.OtherParseAmountErr: {
+                    ordinalConverter.write(6, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that ParseAmountError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case ParseAmountError_Tags.OutOfRange: {
+                    return ordinalConverter.allocationSize(1);
+                }
+                case ParseAmountError_Tags.TooPrecise: {
+                    return ordinalConverter.allocationSize(2);
+                }
+                case ParseAmountError_Tags.MissingDigits: {
+                    return ordinalConverter.allocationSize(3);
+                }
+                case ParseAmountError_Tags.InputTooLarge: {
+                    return ordinalConverter.allocationSize(4);
+                }
+                case ParseAmountError_Tags.InvalidCharacter: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(5);
+                    size += FfiConverterString.allocationSize(inner.errorMessage);
+                    return size;
+                }
+                case ParseAmountError_Tags.OtherParseAmountErr: {
+                    return ordinalConverter.allocationSize(6);
+                }
+                default:
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+// Error type: PsbtError
+// Enum: PsbtError
+export var PsbtError_Tags;
+(function (PsbtError_Tags) {
+    PsbtError_Tags["InvalidMagic"] = "InvalidMagic";
+    PsbtError_Tags["MissingUtxo"] = "MissingUtxo";
+    PsbtError_Tags["InvalidSeparator"] = "InvalidSeparator";
+    PsbtError_Tags["PsbtUtxoOutOfBounds"] = "PsbtUtxoOutOfBounds";
+    PsbtError_Tags["InvalidKey"] = "InvalidKey";
+    PsbtError_Tags["InvalidProprietaryKey"] = "InvalidProprietaryKey";
+    PsbtError_Tags["DuplicateKey"] = "DuplicateKey";
+    PsbtError_Tags["UnsignedTxHasScriptSigs"] = "UnsignedTxHasScriptSigs";
+    PsbtError_Tags["UnsignedTxHasScriptWitnesses"] = "UnsignedTxHasScriptWitnesses";
+    PsbtError_Tags["MustHaveUnsignedTx"] = "MustHaveUnsignedTx";
+    PsbtError_Tags["NoMorePairs"] = "NoMorePairs";
+    PsbtError_Tags["UnexpectedUnsignedTx"] = "UnexpectedUnsignedTx";
+    PsbtError_Tags["NonStandardSighashType"] = "NonStandardSighashType";
+    PsbtError_Tags["InvalidHash"] = "InvalidHash";
+    PsbtError_Tags["InvalidPreimageHashPair"] = "InvalidPreimageHashPair";
+    PsbtError_Tags["CombineInconsistentKeySources"] = "CombineInconsistentKeySources";
+    PsbtError_Tags["ConsensusEncoding"] = "ConsensusEncoding";
+    PsbtError_Tags["NegativeFee"] = "NegativeFee";
+    PsbtError_Tags["FeeOverflow"] = "FeeOverflow";
+    PsbtError_Tags["InvalidPublicKey"] = "InvalidPublicKey";
+    PsbtError_Tags["InvalidSecp256k1PublicKey"] = "InvalidSecp256k1PublicKey";
+    PsbtError_Tags["InvalidXOnlyPublicKey"] = "InvalidXOnlyPublicKey";
+    PsbtError_Tags["InvalidEcdsaSignature"] = "InvalidEcdsaSignature";
+    PsbtError_Tags["InvalidTaprootSignature"] = "InvalidTaprootSignature";
+    PsbtError_Tags["InvalidControlBlock"] = "InvalidControlBlock";
+    PsbtError_Tags["InvalidLeafVersion"] = "InvalidLeafVersion";
+    PsbtError_Tags["Taproot"] = "Taproot";
+    PsbtError_Tags["TapTree"] = "TapTree";
+    PsbtError_Tags["XPubKey"] = "XPubKey";
+    PsbtError_Tags["Version"] = "Version";
+    PsbtError_Tags["PartialDataConsumption"] = "PartialDataConsumption";
+    PsbtError_Tags["Io"] = "Io";
+    PsbtError_Tags["OtherPsbtErr"] = "OtherPsbtErr";
+})(PsbtError_Tags || (PsbtError_Tags = {}));
+export const PsbtError = (() => {
+    class InvalidMagic_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.InvalidMagic;
+        constructor() {
+            super("PsbtError", "InvalidMagic");
+        }
+        static new() {
+            return new InvalidMagic_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.InvalidMagic;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class MissingUtxo_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.MissingUtxo;
+        constructor() {
+            super("PsbtError", "MissingUtxo");
+        }
+        static new() {
+            return new MissingUtxo_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.MissingUtxo;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class InvalidSeparator_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.InvalidSeparator;
+        constructor() {
+            super("PsbtError", "InvalidSeparator");
+        }
+        static new() {
+            return new InvalidSeparator_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.InvalidSeparator;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class PsbtUtxoOutOfBounds_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.PsbtUtxoOutOfBounds;
+        constructor() {
+            super("PsbtError", "PsbtUtxoOutOfBounds");
+        }
+        static new() {
+            return new PsbtUtxoOutOfBounds_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.PsbtUtxoOutOfBounds;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class InvalidKey_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.InvalidKey;
+        inner;
+        constructor(inner) {
+            super("PsbtError", "InvalidKey");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new InvalidKey_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.InvalidKey;
+        }
+        static hasInner(obj) {
+            return InvalidKey_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class InvalidProprietaryKey_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.InvalidProprietaryKey;
+        constructor() {
+            super("PsbtError", "InvalidProprietaryKey");
+        }
+        static new() {
+            return new InvalidProprietaryKey_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.InvalidProprietaryKey;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class DuplicateKey_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.DuplicateKey;
+        inner;
+        constructor(inner) {
+            super("PsbtError", "DuplicateKey");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new DuplicateKey_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.DuplicateKey;
+        }
+        static hasInner(obj) {
+            return DuplicateKey_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class UnsignedTxHasScriptSigs_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.UnsignedTxHasScriptSigs;
+        constructor() {
+            super("PsbtError", "UnsignedTxHasScriptSigs");
+        }
+        static new() {
+            return new UnsignedTxHasScriptSigs_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.UnsignedTxHasScriptSigs;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class UnsignedTxHasScriptWitnesses_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.UnsignedTxHasScriptWitnesses;
+        constructor() {
+            super("PsbtError", "UnsignedTxHasScriptWitnesses");
+        }
+        static new() {
+            return new UnsignedTxHasScriptWitnesses_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.UnsignedTxHasScriptWitnesses;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class MustHaveUnsignedTx_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.MustHaveUnsignedTx;
+        constructor() {
+            super("PsbtError", "MustHaveUnsignedTx");
+        }
+        static new() {
+            return new MustHaveUnsignedTx_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.MustHaveUnsignedTx;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class NoMorePairs_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.NoMorePairs;
+        constructor() {
+            super("PsbtError", "NoMorePairs");
+        }
+        static new() {
+            return new NoMorePairs_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.NoMorePairs;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class UnexpectedUnsignedTx_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.UnexpectedUnsignedTx;
+        constructor() {
+            super("PsbtError", "UnexpectedUnsignedTx");
+        }
+        static new() {
+            return new UnexpectedUnsignedTx_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.UnexpectedUnsignedTx;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class NonStandardSighashType_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.NonStandardSighashType;
+        inner;
+        constructor(inner) {
+            super("PsbtError", "NonStandardSighashType");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new NonStandardSighashType_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.NonStandardSighashType;
+        }
+        static hasInner(obj) {
+            return NonStandardSighashType_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class InvalidHash_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.InvalidHash;
+        inner;
+        constructor(inner) {
+            super("PsbtError", "InvalidHash");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new InvalidHash_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.InvalidHash;
+        }
+        static hasInner(obj) {
+            return InvalidHash_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class InvalidPreimageHashPair_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.InvalidPreimageHashPair;
+        constructor() {
+            super("PsbtError", "InvalidPreimageHashPair");
+        }
+        static new() {
+            return new InvalidPreimageHashPair_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.InvalidPreimageHashPair;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class CombineInconsistentKeySources_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.CombineInconsistentKeySources;
+        inner;
+        constructor(inner) {
+            super("PsbtError", "CombineInconsistentKeySources");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new CombineInconsistentKeySources_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.CombineInconsistentKeySources;
+        }
+        static hasInner(obj) {
+            return CombineInconsistentKeySources_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class ConsensusEncoding_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.ConsensusEncoding;
+        inner;
+        constructor(inner) {
+            super("PsbtError", "ConsensusEncoding");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new ConsensusEncoding_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.ConsensusEncoding;
+        }
+        static hasInner(obj) {
+            return ConsensusEncoding_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class NegativeFee_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.NegativeFee;
+        constructor() {
+            super("PsbtError", "NegativeFee");
+        }
+        static new() {
+            return new NegativeFee_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.NegativeFee;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class FeeOverflow_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.FeeOverflow;
+        constructor() {
+            super("PsbtError", "FeeOverflow");
+        }
+        static new() {
+            return new FeeOverflow_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.FeeOverflow;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class InvalidPublicKey_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.InvalidPublicKey;
+        inner;
+        constructor(inner) {
+            super("PsbtError", "InvalidPublicKey");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new InvalidPublicKey_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.InvalidPublicKey;
+        }
+        static hasInner(obj) {
+            return InvalidPublicKey_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class InvalidSecp256k1PublicKey_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.InvalidSecp256k1PublicKey;
+        inner;
+        constructor(inner) {
+            super("PsbtError", "InvalidSecp256k1PublicKey");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new InvalidSecp256k1PublicKey_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.InvalidSecp256k1PublicKey;
+        }
+        static hasInner(obj) {
+            return InvalidSecp256k1PublicKey_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class InvalidXOnlyPublicKey_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.InvalidXOnlyPublicKey;
+        constructor() {
+            super("PsbtError", "InvalidXOnlyPublicKey");
+        }
+        static new() {
+            return new InvalidXOnlyPublicKey_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.InvalidXOnlyPublicKey;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class InvalidEcdsaSignature_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.InvalidEcdsaSignature;
+        inner;
+        constructor(inner) {
+            super("PsbtError", "InvalidEcdsaSignature");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new InvalidEcdsaSignature_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.InvalidEcdsaSignature;
+        }
+        static hasInner(obj) {
+            return InvalidEcdsaSignature_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class InvalidTaprootSignature_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.InvalidTaprootSignature;
+        inner;
+        constructor(inner) {
+            super("PsbtError", "InvalidTaprootSignature");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new InvalidTaprootSignature_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.InvalidTaprootSignature;
+        }
+        static hasInner(obj) {
+            return InvalidTaprootSignature_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class InvalidControlBlock_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.InvalidControlBlock;
+        constructor() {
+            super("PsbtError", "InvalidControlBlock");
+        }
+        static new() {
+            return new InvalidControlBlock_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.InvalidControlBlock;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class InvalidLeafVersion_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.InvalidLeafVersion;
+        constructor() {
+            super("PsbtError", "InvalidLeafVersion");
+        }
+        static new() {
+            return new InvalidLeafVersion_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.InvalidLeafVersion;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class Taproot_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.Taproot;
+        constructor() {
+            super("PsbtError", "Taproot");
+        }
+        static new() {
+            return new Taproot_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.Taproot;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class TapTree_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.TapTree;
+        inner;
+        constructor(inner) {
+            super("PsbtError", "TapTree");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new TapTree_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.TapTree;
+        }
+        static hasInner(obj) {
+            return TapTree_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class XPubKey_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.XPubKey;
+        constructor() {
+            super("PsbtError", "XPubKey");
+        }
+        static new() {
+            return new XPubKey_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.XPubKey;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class Version_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.Version;
+        inner;
+        constructor(inner) {
+            super("PsbtError", "Version");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Version_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.Version;
+        }
+        static hasInner(obj) {
+            return Version_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class PartialDataConsumption_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.PartialDataConsumption;
+        constructor() {
+            super("PsbtError", "PartialDataConsumption");
+        }
+        static new() {
+            return new PartialDataConsumption_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.PartialDataConsumption;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    class Io_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.Io;
+        inner;
+        constructor(inner) {
+            super("PsbtError", "Io");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Io_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.Io;
+        }
+        static hasInner(obj) {
+            return Io_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class OtherPsbtErr_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtError";
+        tag = PsbtError_Tags.OtherPsbtErr;
+        constructor() {
+            super("PsbtError", "OtherPsbtErr");
+        }
+        static new() {
+            return new OtherPsbtErr_();
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtError_Tags.OtherPsbtErr;
+        }
+        static hasInner(obj) {
+            return false;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "PsbtError";
+    }
+    return Object.freeze({
+        instanceOf,
+        InvalidMagic: InvalidMagic_,
+        MissingUtxo: MissingUtxo_,
+        InvalidSeparator: InvalidSeparator_,
+        PsbtUtxoOutOfBounds: PsbtUtxoOutOfBounds_,
+        InvalidKey: InvalidKey_,
+        InvalidProprietaryKey: InvalidProprietaryKey_,
+        DuplicateKey: DuplicateKey_,
+        UnsignedTxHasScriptSigs: UnsignedTxHasScriptSigs_,
+        UnsignedTxHasScriptWitnesses: UnsignedTxHasScriptWitnesses_,
+        MustHaveUnsignedTx: MustHaveUnsignedTx_,
+        NoMorePairs: NoMorePairs_,
+        UnexpectedUnsignedTx: UnexpectedUnsignedTx_,
+        NonStandardSighashType: NonStandardSighashType_,
+        InvalidHash: InvalidHash_,
+        InvalidPreimageHashPair: InvalidPreimageHashPair_,
+        CombineInconsistentKeySources: CombineInconsistentKeySources_,
+        ConsensusEncoding: ConsensusEncoding_,
+        NegativeFee: NegativeFee_,
+        FeeOverflow: FeeOverflow_,
+        InvalidPublicKey: InvalidPublicKey_,
+        InvalidSecp256k1PublicKey: InvalidSecp256k1PublicKey_,
+        InvalidXOnlyPublicKey: InvalidXOnlyPublicKey_,
+        InvalidEcdsaSignature: InvalidEcdsaSignature_,
+        InvalidTaprootSignature: InvalidTaprootSignature_,
+        InvalidControlBlock: InvalidControlBlock_,
+        InvalidLeafVersion: InvalidLeafVersion_,
+        Taproot: Taproot_,
+        TapTree: TapTree_,
+        XPubKey: XPubKey_,
+        Version: Version_,
+        PartialDataConsumption: PartialDataConsumption_,
+        Io: Io_,
+        OtherPsbtErr: OtherPsbtErr_,
+    });
+})();
+// FfiConverter for enum PsbtError
+const FfiConverterTypePsbtError = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1:
+                    return new PsbtError.InvalidMagic();
+                case 2:
+                    return new PsbtError.MissingUtxo();
+                case 3:
+                    return new PsbtError.InvalidSeparator();
+                case 4:
+                    return new PsbtError.PsbtUtxoOutOfBounds();
+                case 5:
+                    return new PsbtError.InvalidKey({
+                        key: FfiConverterString.read(from),
+                    });
+                case 6:
+                    return new PsbtError.InvalidProprietaryKey();
+                case 7:
+                    return new PsbtError.DuplicateKey({
+                        key: FfiConverterString.read(from),
+                    });
+                case 8:
+                    return new PsbtError.UnsignedTxHasScriptSigs();
+                case 9:
+                    return new PsbtError.UnsignedTxHasScriptWitnesses();
+                case 10:
+                    return new PsbtError.MustHaveUnsignedTx();
+                case 11:
+                    return new PsbtError.NoMorePairs();
+                case 12:
+                    return new PsbtError.UnexpectedUnsignedTx();
+                case 13:
+                    return new PsbtError.NonStandardSighashType({
+                        sighash: FfiConverterUInt32.read(from),
+                    });
+                case 14:
+                    return new PsbtError.InvalidHash({
+                        hash: FfiConverterString.read(from),
+                    });
+                case 15:
+                    return new PsbtError.InvalidPreimageHashPair();
+                case 16:
+                    return new PsbtError.CombineInconsistentKeySources({
+                        xpub: FfiConverterString.read(from),
+                    });
+                case 17:
+                    return new PsbtError.ConsensusEncoding({
+                        encodingError: FfiConverterString.read(from),
+                    });
+                case 18:
+                    return new PsbtError.NegativeFee();
+                case 19:
+                    return new PsbtError.FeeOverflow();
+                case 20:
+                    return new PsbtError.InvalidPublicKey({
+                        errorMessage: FfiConverterString.read(from),
+                    });
+                case 21:
+                    return new PsbtError.InvalidSecp256k1PublicKey({
+                        secp256k1Error: FfiConverterString.read(from),
+                    });
+                case 22:
+                    return new PsbtError.InvalidXOnlyPublicKey();
+                case 23:
+                    return new PsbtError.InvalidEcdsaSignature({
+                        errorMessage: FfiConverterString.read(from),
+                    });
+                case 24:
+                    return new PsbtError.InvalidTaprootSignature({
+                        errorMessage: FfiConverterString.read(from),
+                    });
+                case 25:
+                    return new PsbtError.InvalidControlBlock();
+                case 26:
+                    return new PsbtError.InvalidLeafVersion();
+                case 27:
+                    return new PsbtError.Taproot();
+                case 28:
+                    return new PsbtError.TapTree({
+                        errorMessage: FfiConverterString.read(from),
+                    });
+                case 29:
+                    return new PsbtError.XPubKey();
+                case 30:
+                    return new PsbtError.Version({
+                        errorMessage: FfiConverterString.read(from),
+                    });
+                case 31:
+                    return new PsbtError.PartialDataConsumption();
+                case 32:
+                    return new PsbtError.Io({
+                        errorMessage: FfiConverterString.read(from),
+                    });
+                case 33:
+                    return new PsbtError.OtherPsbtErr();
+                default:
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case PsbtError_Tags.InvalidMagic: {
+                    ordinalConverter.write(1, into);
+                    return;
+                }
+                case PsbtError_Tags.MissingUtxo: {
+                    ordinalConverter.write(2, into);
+                    return;
+                }
+                case PsbtError_Tags.InvalidSeparator: {
+                    ordinalConverter.write(3, into);
+                    return;
+                }
+                case PsbtError_Tags.PsbtUtxoOutOfBounds: {
+                    ordinalConverter.write(4, into);
+                    return;
+                }
+                case PsbtError_Tags.InvalidKey: {
+                    ordinalConverter.write(5, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.key, into);
+                    return;
+                }
+                case PsbtError_Tags.InvalidProprietaryKey: {
+                    ordinalConverter.write(6, into);
+                    return;
+                }
+                case PsbtError_Tags.DuplicateKey: {
+                    ordinalConverter.write(7, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.key, into);
+                    return;
+                }
+                case PsbtError_Tags.UnsignedTxHasScriptSigs: {
+                    ordinalConverter.write(8, into);
+                    return;
+                }
+                case PsbtError_Tags.UnsignedTxHasScriptWitnesses: {
+                    ordinalConverter.write(9, into);
+                    return;
+                }
+                case PsbtError_Tags.MustHaveUnsignedTx: {
+                    ordinalConverter.write(10, into);
+                    return;
+                }
+                case PsbtError_Tags.NoMorePairs: {
+                    ordinalConverter.write(11, into);
+                    return;
+                }
+                case PsbtError_Tags.UnexpectedUnsignedTx: {
+                    ordinalConverter.write(12, into);
+                    return;
+                }
+                case PsbtError_Tags.NonStandardSighashType: {
+                    ordinalConverter.write(13, into);
+                    const inner = value.inner;
+                    FfiConverterUInt32.write(inner.sighash, into);
+                    return;
+                }
+                case PsbtError_Tags.InvalidHash: {
+                    ordinalConverter.write(14, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.hash, into);
+                    return;
+                }
+                case PsbtError_Tags.InvalidPreimageHashPair: {
+                    ordinalConverter.write(15, into);
+                    return;
+                }
+                case PsbtError_Tags.CombineInconsistentKeySources: {
+                    ordinalConverter.write(16, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.xpub, into);
+                    return;
+                }
+                case PsbtError_Tags.ConsensusEncoding: {
+                    ordinalConverter.write(17, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.encodingError, into);
+                    return;
+                }
+                case PsbtError_Tags.NegativeFee: {
+                    ordinalConverter.write(18, into);
+                    return;
+                }
+                case PsbtError_Tags.FeeOverflow: {
+                    ordinalConverter.write(19, into);
+                    return;
+                }
+                case PsbtError_Tags.InvalidPublicKey: {
+                    ordinalConverter.write(20, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.errorMessage, into);
+                    return;
+                }
+                case PsbtError_Tags.InvalidSecp256k1PublicKey: {
+                    ordinalConverter.write(21, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.secp256k1Error, into);
+                    return;
+                }
+                case PsbtError_Tags.InvalidXOnlyPublicKey: {
+                    ordinalConverter.write(22, into);
+                    return;
+                }
+                case PsbtError_Tags.InvalidEcdsaSignature: {
+                    ordinalConverter.write(23, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.errorMessage, into);
+                    return;
+                }
+                case PsbtError_Tags.InvalidTaprootSignature: {
+                    ordinalConverter.write(24, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.errorMessage, into);
+                    return;
+                }
+                case PsbtError_Tags.InvalidControlBlock: {
+                    ordinalConverter.write(25, into);
+                    return;
+                }
+                case PsbtError_Tags.InvalidLeafVersion: {
+                    ordinalConverter.write(26, into);
+                    return;
+                }
+                case PsbtError_Tags.Taproot: {
+                    ordinalConverter.write(27, into);
+                    return;
+                }
+                case PsbtError_Tags.TapTree: {
+                    ordinalConverter.write(28, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.errorMessage, into);
+                    return;
+                }
+                case PsbtError_Tags.XPubKey: {
+                    ordinalConverter.write(29, into);
+                    return;
+                }
+                case PsbtError_Tags.Version: {
+                    ordinalConverter.write(30, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.errorMessage, into);
+                    return;
+                }
+                case PsbtError_Tags.PartialDataConsumption: {
+                    ordinalConverter.write(31, into);
+                    return;
+                }
+                case PsbtError_Tags.Io: {
+                    ordinalConverter.write(32, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.errorMessage, into);
+                    return;
+                }
+                case PsbtError_Tags.OtherPsbtErr: {
+                    ordinalConverter.write(33, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that PsbtError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case PsbtError_Tags.InvalidMagic: {
+                    return ordinalConverter.allocationSize(1);
+                }
+                case PsbtError_Tags.MissingUtxo: {
+                    return ordinalConverter.allocationSize(2);
+                }
+                case PsbtError_Tags.InvalidSeparator: {
+                    return ordinalConverter.allocationSize(3);
+                }
+                case PsbtError_Tags.PsbtUtxoOutOfBounds: {
+                    return ordinalConverter.allocationSize(4);
+                }
+                case PsbtError_Tags.InvalidKey: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(5);
+                    size += FfiConverterString.allocationSize(inner.key);
+                    return size;
+                }
+                case PsbtError_Tags.InvalidProprietaryKey: {
+                    return ordinalConverter.allocationSize(6);
+                }
+                case PsbtError_Tags.DuplicateKey: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(7);
+                    size += FfiConverterString.allocationSize(inner.key);
+                    return size;
+                }
+                case PsbtError_Tags.UnsignedTxHasScriptSigs: {
+                    return ordinalConverter.allocationSize(8);
+                }
+                case PsbtError_Tags.UnsignedTxHasScriptWitnesses: {
+                    return ordinalConverter.allocationSize(9);
+                }
+                case PsbtError_Tags.MustHaveUnsignedTx: {
+                    return ordinalConverter.allocationSize(10);
+                }
+                case PsbtError_Tags.NoMorePairs: {
+                    return ordinalConverter.allocationSize(11);
+                }
+                case PsbtError_Tags.UnexpectedUnsignedTx: {
+                    return ordinalConverter.allocationSize(12);
+                }
+                case PsbtError_Tags.NonStandardSighashType: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(13);
+                    size += FfiConverterUInt32.allocationSize(inner.sighash);
+                    return size;
+                }
+                case PsbtError_Tags.InvalidHash: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(14);
+                    size += FfiConverterString.allocationSize(inner.hash);
+                    return size;
+                }
+                case PsbtError_Tags.InvalidPreimageHashPair: {
+                    return ordinalConverter.allocationSize(15);
+                }
+                case PsbtError_Tags.CombineInconsistentKeySources: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(16);
+                    size += FfiConverterString.allocationSize(inner.xpub);
+                    return size;
+                }
+                case PsbtError_Tags.ConsensusEncoding: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(17);
+                    size += FfiConverterString.allocationSize(inner.encodingError);
+                    return size;
+                }
+                case PsbtError_Tags.NegativeFee: {
+                    return ordinalConverter.allocationSize(18);
+                }
+                case PsbtError_Tags.FeeOverflow: {
+                    return ordinalConverter.allocationSize(19);
+                }
+                case PsbtError_Tags.InvalidPublicKey: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(20);
+                    size += FfiConverterString.allocationSize(inner.errorMessage);
+                    return size;
+                }
+                case PsbtError_Tags.InvalidSecp256k1PublicKey: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(21);
+                    size += FfiConverterString.allocationSize(inner.secp256k1Error);
+                    return size;
+                }
+                case PsbtError_Tags.InvalidXOnlyPublicKey: {
+                    return ordinalConverter.allocationSize(22);
+                }
+                case PsbtError_Tags.InvalidEcdsaSignature: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(23);
+                    size += FfiConverterString.allocationSize(inner.errorMessage);
+                    return size;
+                }
+                case PsbtError_Tags.InvalidTaprootSignature: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(24);
+                    size += FfiConverterString.allocationSize(inner.errorMessage);
+                    return size;
+                }
+                case PsbtError_Tags.InvalidControlBlock: {
+                    return ordinalConverter.allocationSize(25);
+                }
+                case PsbtError_Tags.InvalidLeafVersion: {
+                    return ordinalConverter.allocationSize(26);
+                }
+                case PsbtError_Tags.Taproot: {
+                    return ordinalConverter.allocationSize(27);
+                }
+                case PsbtError_Tags.TapTree: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(28);
+                    size += FfiConverterString.allocationSize(inner.errorMessage);
+                    return size;
+                }
+                case PsbtError_Tags.XPubKey: {
+                    return ordinalConverter.allocationSize(29);
+                }
+                case PsbtError_Tags.Version: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(30);
+                    size += FfiConverterString.allocationSize(inner.errorMessage);
+                    return size;
+                }
+                case PsbtError_Tags.PartialDataConsumption: {
+                    return ordinalConverter.allocationSize(31);
+                }
+                case PsbtError_Tags.Io: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(32);
+                    size += FfiConverterString.allocationSize(inner.errorMessage);
+                    return size;
+                }
+                case PsbtError_Tags.OtherPsbtErr: {
+                    return ordinalConverter.allocationSize(33);
+                }
+                default:
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+// Error type: PsbtParseError
+// Enum: PsbtParseError
+export var PsbtParseError_Tags;
+(function (PsbtParseError_Tags) {
+    PsbtParseError_Tags["PsbtEncoding"] = "PsbtEncoding";
+    PsbtParseError_Tags["Base64Encoding"] = "Base64Encoding";
+})(PsbtParseError_Tags || (PsbtParseError_Tags = {}));
+export const PsbtParseError = (() => {
+    class PsbtEncoding_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtParseError";
+        tag = PsbtParseError_Tags.PsbtEncoding;
+        inner;
+        constructor(inner) {
+            super("PsbtParseError", "PsbtEncoding");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new PsbtEncoding_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtParseError_Tags.PsbtEncoding;
+        }
+        static hasInner(obj) {
+            return PsbtEncoding_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    class Base64Encoding_ extends UniffiError {
+        /**
+         * @private
+         * This field is private and should not be used, use `tag` instead.
+         */
+        [uniffiTypeNameSymbol] = "PsbtParseError";
+        tag = PsbtParseError_Tags.Base64Encoding;
+        inner;
+        constructor(inner) {
+            super("PsbtParseError", "Base64Encoding");
+            this.inner = Object.freeze(inner);
+        }
+        static new(inner) {
+            return new Base64Encoding_(inner);
+        }
+        static instanceOf(obj) {
+            return obj.tag === PsbtParseError_Tags.Base64Encoding;
+        }
+        static hasInner(obj) {
+            return Base64Encoding_.instanceOf(obj);
+        }
+        static getInner(obj) {
+            return obj.inner;
+        }
+    }
+    function instanceOf(obj) {
+        return obj[uniffiTypeNameSymbol] === "PsbtParseError";
+    }
+    return Object.freeze({
+        instanceOf,
+        PsbtEncoding: PsbtEncoding_,
+        Base64Encoding: Base64Encoding_,
+    });
+})();
+// FfiConverter for enum PsbtParseError
+const FfiConverterTypePsbtParseError = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1:
+                    return new PsbtParseError.PsbtEncoding({
+                        errorMessage: FfiConverterString.read(from),
+                    });
+                case 2:
+                    return new PsbtParseError.Base64Encoding({
+                        errorMessage: FfiConverterString.read(from),
+                    });
+                default:
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value.tag) {
+                case PsbtParseError_Tags.PsbtEncoding: {
+                    ordinalConverter.write(1, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.errorMessage, into);
+                    return;
+                }
+                case PsbtParseError_Tags.Base64Encoding: {
+                    ordinalConverter.write(2, into);
+                    const inner = value.inner;
+                    FfiConverterString.write(inner.errorMessage, into);
+                    return;
+                }
+                default:
+                    // Throwing from here means that PsbtParseError_Tags hasn't matched an ordinal.
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        allocationSize(value) {
+            switch (value.tag) {
+                case PsbtParseError_Tags.PsbtEncoding: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(1);
+                    size += FfiConverterString.allocationSize(inner.errorMessage);
+                    return size;
+                }
+                case PsbtParseError_Tags.Base64Encoding: {
+                    const inner = value.inner;
+                    let size = ordinalConverter.allocationSize(2);
+                    size += FfiConverterString.allocationSize(inner.errorMessage);
+                    return size;
+                }
+                default:
+                    throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+    }
+    return new FFIConverter();
+})();
+export class Address extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "Address";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    constructor(address, network) {
+        super();
+        const pointer = uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeAddressParseError.lift.bind(FfiConverterTypeAddressParseError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_constructor_address_new(FfiConverterString.lower(address), FfiConverterTypeNetwork.lower(network), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift);
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] =
+            uniffiTypeAddressObjectFactory.bless(pointer);
+    }
+    static fromScript(script, network) {
+        return FfiConverterTypeAddress.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeFromScriptError.lift.bind(FfiConverterTypeFromScriptError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_constructor_address_from_script(FfiConverterTypeScript.lower(script), FfiConverterTypeNetwork.lower(network), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    isValidForNetwork(network) {
+        return FfiConverterBool.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_address_is_valid_for_network(uniffiTypeAddressObjectFactory.clonePointer(this), FfiConverterTypeNetwork.lower(network), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    scriptPubkey() {
+        return FfiConverterTypeScript.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_address_script_pubkey(uniffiTypeAddressObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    toQrUri() {
+        return FfiConverterString.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_address_to_qr_uri(uniffiTypeAddressObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    /**
+     * Calls into the `AddressInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString() {
+        return FfiConverterString.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_address_uniffi_trait_display(uniffiTypeAddressObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeAddressObjectFactory.pointer(this);
+            uniffiTypeAddressObjectFactory.freePointer(pointer);
+            uniffiTypeAddressObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj) {
+        return uniffiTypeAddressObjectFactory.isConcreteType(obj);
+    }
+}
+const uniffiTypeAddressObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== "undefined"
+        ? new FinalizationRegistry((heldValue) => {
+            uniffiTypeAddressObjectFactory.freePointer(heldValue);
+        })
+        : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(Address.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "Address";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr) {
+            if (registry) {
+                registry.unregister(ptr);
+            }
+        },
+        pointer(obj) {
+            if (obj[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj[pointerLiteralSymbol];
+        },
+        clonePointer(obj) {
+            const pointer = this.pointer(obj);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_bitcoin_ffi_fn_clone_address(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_bitcoin_ffi_fn_free_address(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj) {
+            return (obj[destructorGuardSymbol] &&
+                obj[uniffiTypeNameSymbol] === "Address");
+        },
+    };
+})();
+// FfiConverter for AddressInterface
+const FfiConverterTypeAddress = new FfiConverterObject(uniffiTypeAddressObjectFactory);
+export class Amount extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "Amount";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] =
+            uniffiTypeAmountObjectFactory.bless(pointer);
+    }
+    static fromBtc(btc) {
+        return FfiConverterTypeAmount.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeParseAmountError.lift.bind(FfiConverterTypeParseAmountError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_constructor_amount_from_btc(FfiConverterFloat64.lower(btc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    static fromSat(sat) {
+        return FfiConverterTypeAmount.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_constructor_amount_from_sat(FfiConverterUInt64.lower(sat), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    toBtc() {
+        return FfiConverterFloat64.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_amount_to_btc(uniffiTypeAmountObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    toSat() {
+        return FfiConverterUInt64.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_amount_to_sat(uniffiTypeAmountObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeAmountObjectFactory.pointer(this);
+            uniffiTypeAmountObjectFactory.freePointer(pointer);
+            uniffiTypeAmountObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj) {
+        return uniffiTypeAmountObjectFactory.isConcreteType(obj);
+    }
+}
+const uniffiTypeAmountObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== "undefined"
+        ? new FinalizationRegistry((heldValue) => {
+            uniffiTypeAmountObjectFactory.freePointer(heldValue);
+        })
+        : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(Amount.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "Amount";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr) {
+            if (registry) {
+                registry.unregister(ptr);
+            }
+        },
+        pointer(obj) {
+            if (obj[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj[pointerLiteralSymbol];
+        },
+        clonePointer(obj) {
+            const pointer = this.pointer(obj);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_bitcoin_ffi_fn_clone_amount(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_bitcoin_ffi_fn_free_amount(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj) {
+            return (obj[destructorGuardSymbol] &&
+                obj[uniffiTypeNameSymbol] === "Amount");
+        },
+    };
+})();
+// FfiConverter for AmountInterface
+const FfiConverterTypeAmount = new FfiConverterObject(uniffiTypeAmountObjectFactory);
+export class FeeRate extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "FeeRate";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] =
+            uniffiTypeFeeRateObjectFactory.bless(pointer);
+    }
+    static fromSatPerKwu(satPerKwu) {
+        return FfiConverterTypeFeeRate.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_constructor_feerate_from_sat_per_kwu(FfiConverterUInt64.lower(satPerKwu), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    static fromSatPerVb(satPerVb) {
+        return FfiConverterTypeFeeRate.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeFeeRateError.lift.bind(FfiConverterTypeFeeRateError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_constructor_feerate_from_sat_per_vb(FfiConverterUInt64.lower(satPerVb), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    toSatPerKwu() {
+        return FfiConverterUInt64.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_feerate_to_sat_per_kwu(uniffiTypeFeeRateObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    toSatPerVbCeil() {
+        return FfiConverterUInt64.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_feerate_to_sat_per_vb_ceil(uniffiTypeFeeRateObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    toSatPerVbFloor() {
+        return FfiConverterUInt64.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_feerate_to_sat_per_vb_floor(uniffiTypeFeeRateObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeFeeRateObjectFactory.pointer(this);
+            uniffiTypeFeeRateObjectFactory.freePointer(pointer);
+            uniffiTypeFeeRateObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj) {
+        return uniffiTypeFeeRateObjectFactory.isConcreteType(obj);
+    }
+}
+const uniffiTypeFeeRateObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== "undefined"
+        ? new FinalizationRegistry((heldValue) => {
+            uniffiTypeFeeRateObjectFactory.freePointer(heldValue);
+        })
+        : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(FeeRate.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "FeeRate";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr) {
+            if (registry) {
+                registry.unregister(ptr);
+            }
+        },
+        pointer(obj) {
+            if (obj[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj[pointerLiteralSymbol];
+        },
+        clonePointer(obj) {
+            const pointer = this.pointer(obj);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_bitcoin_ffi_fn_clone_feerate(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_bitcoin_ffi_fn_free_feerate(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj) {
+            return (obj[destructorGuardSymbol] &&
+                obj[uniffiTypeNameSymbol] === "FeeRate");
+        },
+    };
+})();
+// FfiConverter for FeeRateInterface
+const FfiConverterTypeFeeRate = new FfiConverterObject(uniffiTypeFeeRateObjectFactory);
+export class Psbt extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "Psbt";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] =
+            uniffiTypePsbtObjectFactory.bless(pointer);
+    }
+    static deserialize(psbtBytes) {
+        return FfiConverterTypePsbt.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypePsbtError.lift.bind(FfiConverterTypePsbtError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_constructor_psbt_deserialize(FfiConverterArrayBuffer.lower(psbtBytes), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    static deserializeBase64(psbtBase64) {
+        return FfiConverterTypePsbt.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypePsbtParseError.lift.bind(FfiConverterTypePsbtParseError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_constructor_psbt_deserialize_base64(FfiConverterString.lower(psbtBase64), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    static fromUnsignedTx(tx) {
+        return FfiConverterTypePsbt.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypePsbtError.lift.bind(FfiConverterTypePsbtError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_constructor_psbt_from_unsigned_tx(FfiConverterTypeTransaction.lower(tx), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    combine(other) {
+        return FfiConverterTypePsbt.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypePsbtError.lift.bind(FfiConverterTypePsbtError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_psbt_combine(uniffiTypePsbtObjectFactory.clonePointer(this), FfiConverterTypePsbt.lower(other), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    extractTx() {
+        return FfiConverterTypeTransaction.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeExtractTxError.lift.bind(FfiConverterTypeExtractTxError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_psbt_extract_tx(uniffiTypePsbtObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    fee() {
+        return FfiConverterTypeAmount.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypePsbtError.lift.bind(FfiConverterTypePsbtError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_psbt_fee(uniffiTypePsbtObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    serialize() {
+        return FfiConverterArrayBuffer.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_psbt_serialize(uniffiTypePsbtObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    serializeBase64() {
+        return FfiConverterString.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_psbt_serialize_base64(uniffiTypePsbtObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    serializeHex() {
+        return FfiConverterString.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_psbt_serialize_hex(uniffiTypePsbtObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypePsbtObjectFactory.pointer(this);
+            uniffiTypePsbtObjectFactory.freePointer(pointer);
+            uniffiTypePsbtObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj) {
+        return uniffiTypePsbtObjectFactory.isConcreteType(obj);
+    }
+}
+const uniffiTypePsbtObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== "undefined"
+        ? new FinalizationRegistry((heldValue) => {
+            uniffiTypePsbtObjectFactory.freePointer(heldValue);
+        })
+        : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(Psbt.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "Psbt";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr) {
+            if (registry) {
+                registry.unregister(ptr);
+            }
+        },
+        pointer(obj) {
+            if (obj[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj[pointerLiteralSymbol];
+        },
+        clonePointer(obj) {
+            const pointer = this.pointer(obj);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_bitcoin_ffi_fn_clone_psbt(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_bitcoin_ffi_fn_free_psbt(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj) {
+            return (obj[destructorGuardSymbol] &&
+                obj[uniffiTypeNameSymbol] === "Psbt");
+        },
+    };
+})();
+// FfiConverter for PsbtInterface
+const FfiConverterTypePsbt = new FfiConverterObject(uniffiTypePsbtObjectFactory);
+export class Script extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "Script";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    constructor(rawOutputScript) {
+        super();
+        const pointer = uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_constructor_script_new(FfiConverterArrayBuffer.lower(rawOutputScript), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift);
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] =
+            uniffiTypeScriptObjectFactory.bless(pointer);
+    }
+    toBytes() {
+        return FfiConverterArrayBuffer.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_script_to_bytes(uniffiTypeScriptObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeScriptObjectFactory.pointer(this);
+            uniffiTypeScriptObjectFactory.freePointer(pointer);
+            uniffiTypeScriptObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj) {
+        return uniffiTypeScriptObjectFactory.isConcreteType(obj);
+    }
+}
+const uniffiTypeScriptObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== "undefined"
+        ? new FinalizationRegistry((heldValue) => {
+            uniffiTypeScriptObjectFactory.freePointer(heldValue);
+        })
+        : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(Script.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "Script";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr) {
+            if (registry) {
+                registry.unregister(ptr);
+            }
+        },
+        pointer(obj) {
+            if (obj[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj[pointerLiteralSymbol];
+        },
+        clonePointer(obj) {
+            const pointer = this.pointer(obj);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_bitcoin_ffi_fn_clone_script(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_bitcoin_ffi_fn_free_script(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj) {
+            return (obj[destructorGuardSymbol] &&
+                obj[uniffiTypeNameSymbol] === "Script");
+        },
+    };
+})();
+// FfiConverter for ScriptInterface
+const FfiConverterTypeScript = new FfiConverterObject(uniffiTypeScriptObjectFactory);
+export class Transaction extends UniffiAbstractObject {
+    [uniffiTypeNameSymbol] = "Transaction";
+    [destructorGuardSymbol];
+    [pointerLiteralSymbol];
+    // No primary constructor declared for this class.
+    constructor(pointer) {
+        super();
+        this[pointerLiteralSymbol] = pointer;
+        this[destructorGuardSymbol] =
+            uniffiTypeTransactionObjectFactory.bless(pointer);
+    }
+    static deserialize(transactionBytes) {
+        return FfiConverterTypeTransaction.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeEncodeError.lift.bind(FfiConverterTypeEncodeError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_constructor_transaction_deserialize(FfiConverterArrayBuffer.lower(transactionBytes), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    computeTxid() {
+        return FfiConverterString.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_transaction_compute_txid(uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    input() {
+        return FfiConverterArrayTypeTxIn.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_transaction_input(uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    isCoinbase() {
+        return FfiConverterBool.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_transaction_is_coinbase(uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    isExplicitlyRbf() {
+        return FfiConverterBool.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_transaction_is_explicitly_rbf(uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    isLockTimeEnabled() {
+        return FfiConverterBool.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_transaction_is_lock_time_enabled(uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    lockTime() {
+        return FfiConverterUInt32.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_transaction_lock_time(uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    output() {
+        return FfiConverterArrayTypeTxOut.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_transaction_output(uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    serialize() {
+        return FfiConverterArrayBuffer.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_transaction_serialize(uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    totalSize() {
+        return FfiConverterUInt64.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_transaction_total_size(uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    version() {
+        return FfiConverterInt32.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_transaction_version(uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    vsize() {
+        return FfiConverterUInt64.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_transaction_vsize(uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    weight() {
+        return FfiConverterUInt64.lift(uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) => {
+            return nativeModule().ubrn_uniffi_bitcoin_ffi_fn_method_transaction_weight(uniffiTypeTransactionObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift));
+    }
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy() {
+        const ptr = this[destructorGuardSymbol];
+        if (ptr !== undefined) {
+            const pointer = uniffiTypeTransactionObjectFactory.pointer(this);
+            uniffiTypeTransactionObjectFactory.freePointer(pointer);
+            uniffiTypeTransactionObjectFactory.unbless(ptr);
+            delete this[destructorGuardSymbol];
+        }
+    }
+    static instanceOf(obj) {
+        return uniffiTypeTransactionObjectFactory.isConcreteType(obj);
+    }
+}
+const uniffiTypeTransactionObjectFactory = (() => {
+    /// <reference lib="es2021" />
+    const registry = typeof FinalizationRegistry !== "undefined"
+        ? new FinalizationRegistry((heldValue) => {
+            uniffiTypeTransactionObjectFactory.freePointer(heldValue);
+        })
+        : null;
+    return {
+        create(pointer) {
+            const instance = Object.create(Transaction.prototype);
+            instance[pointerLiteralSymbol] = pointer;
+            instance[destructorGuardSymbol] = this.bless(pointer);
+            instance[uniffiTypeNameSymbol] = "Transaction";
+            return instance;
+        },
+        bless(p) {
+            const ptr = {
+                p, // make sure this object doesn't get optimized away.
+                markDestroyed: () => undefined,
+            };
+            if (registry) {
+                registry.register(ptr, p, ptr);
+            }
+            return ptr;
+        },
+        unbless(ptr) {
+            if (registry) {
+                registry.unregister(ptr);
+            }
+        },
+        pointer(obj) {
+            if (obj[destructorGuardSymbol] === undefined) {
+                throw new UniffiInternalError.UnexpectedNullPointer();
+            }
+            return obj[pointerLiteralSymbol];
+        },
+        clonePointer(obj) {
+            const pointer = this.pointer(obj);
+            return uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_bitcoin_ffi_fn_clone_transaction(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        freePointer(pointer) {
+            uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => nativeModule().ubrn_uniffi_bitcoin_ffi_fn_free_transaction(pointer, callStatus), 
+            /*liftString:*/ FfiConverterString.lift);
+        },
+        isConcreteType(obj) {
+            return (obj[destructorGuardSymbol] &&
+                obj[uniffiTypeNameSymbol] === "Transaction");
+        },
+    };
+})();
+// FfiConverter for TransactionInterface
+const FfiConverterTypeTransaction = new FfiConverterObject(uniffiTypeTransactionObjectFactory);
+// FfiConverter for Array<ArrayBuffer>
+const FfiConverterArrayArrayBuffer = new FfiConverterArray(FfiConverterArrayBuffer);
+// FfiConverter for Array<TxIn>
+const FfiConverterArrayTypeTxIn = new FfiConverterArray(FfiConverterTypeTxIn);
+// FfiConverter for Array<TxOut>
+const FfiConverterArrayTypeTxOut = new FfiConverterArray(FfiConverterTypeTxOut);
+/**
+ * This should be called before anything else.
+ *
+ * It is likely that this is being done for you by the library's `index.ts`.
+ *
+ * It checks versions of uniffi between when the Rust scaffolding was generated
+ * and when the bindings were generated.
+ *
+ * It also initializes the machinery to enable Rust to talk back to Javascript.
+ */
+function uniffiEnsureInitialized() {
+    // Get the bindings contract version from our ComponentInterface
+    const bindingsContractVersion = 29;
+    // Get the scaffolding contract version by calling the into the dylib
+    const scaffoldingContractVersion = nativeModule().ubrn_ffi_bitcoin_ffi_uniffi_contract_version();
+    if (bindingsContractVersion !== scaffoldingContractVersion) {
+        throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_address_is_valid_for_network() !==
+        55428) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_address_is_valid_for_network");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_address_script_pubkey() !==
+        7086) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_address_script_pubkey");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_address_to_qr_uri() !==
+        34272) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_address_to_qr_uri");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_amount_to_btc() !==
+        20425) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_amount_to_btc");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_amount_to_sat() !==
+        8831) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_amount_to_sat");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_feerate_to_sat_per_kwu() !==
+        30352) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_feerate_to_sat_per_kwu");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_feerate_to_sat_per_vb_ceil() !==
+        35371) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_feerate_to_sat_per_vb_ceil");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_feerate_to_sat_per_vb_floor() !==
+        55263) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_feerate_to_sat_per_vb_floor");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_psbt_combine() !==
+        42095) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_psbt_combine");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_psbt_extract_tx() !==
+        31319) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_psbt_extract_tx");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_psbt_fee() !==
+        21708) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_psbt_fee");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_psbt_serialize() !==
+        50542) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_psbt_serialize");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_psbt_serialize_base64() !==
+        43319) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_psbt_serialize_base64");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_psbt_serialize_hex() !==
+        62751) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_psbt_serialize_hex");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_script_to_bytes() !==
+        44421) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_script_to_bytes");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_transaction_compute_txid() !==
+        54056) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_transaction_compute_txid");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_transaction_input() !==
+        57477) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_transaction_input");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_transaction_is_coinbase() !==
+        30082) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_transaction_is_coinbase");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_transaction_is_explicitly_rbf() !==
+        27333) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_transaction_is_explicitly_rbf");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_transaction_is_lock_time_enabled() !==
+        60902) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_transaction_is_lock_time_enabled");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_transaction_lock_time() !==
+        47596) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_transaction_lock_time");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_transaction_output() !==
+        61951) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_transaction_output");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_transaction_serialize() !==
+        53292) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_transaction_serialize");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_transaction_total_size() !==
+        51597) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_transaction_total_size");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_transaction_version() !==
+        47252) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_transaction_version");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_transaction_vsize() !==
+        58879) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_transaction_vsize");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_method_transaction_weight() !==
+        12807) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_method_transaction_weight");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_constructor_address_from_script() !==
+        62411) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_constructor_address_from_script");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_constructor_address_new() !==
+        26098) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_constructor_address_new");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_constructor_amount_from_btc() !==
+        52219) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_constructor_amount_from_btc");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_constructor_amount_from_sat() !==
+        5551) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_constructor_amount_from_sat");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_constructor_feerate_from_sat_per_kwu() !==
+        60257) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_constructor_feerate_from_sat_per_kwu");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_constructor_feerate_from_sat_per_vb() !==
+        48712) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_constructor_feerate_from_sat_per_vb");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_constructor_psbt_deserialize() !==
+        4447) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_constructor_psbt_deserialize");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_constructor_psbt_deserialize_base64() !==
+        61367) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_constructor_psbt_deserialize_base64");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_constructor_psbt_from_unsigned_tx() !==
+        28547) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_constructor_psbt_from_unsigned_tx");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_constructor_script_new() !==
+        16741) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_constructor_script_new");
+    }
+    if (nativeModule().ubrn_uniffi_bitcoin_ffi_checksum_constructor_transaction_deserialize() !==
+        44363) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bitcoin_ffi_checksum_constructor_transaction_deserialize");
+    }
+}
+export default Object.freeze({
+    initialize: uniffiEnsureInitialized,
+    converters: {
+        FfiConverterTypeAddress,
+        FfiConverterTypeAddressParseError,
+        FfiConverterTypeAmount,
+        FfiConverterTypeBlockHash,
+        FfiConverterTypeEncodeError,
+        FfiConverterTypeExtractTxError,
+        FfiConverterTypeFeeRate,
+        FfiConverterTypeFeeRateError,
+        FfiConverterTypeFromScriptError,
+        FfiConverterTypeNetwork,
+        FfiConverterTypeOutPoint,
+        FfiConverterTypeParseAmountError,
+        FfiConverterTypePsbt,
+        FfiConverterTypePsbtError,
+        FfiConverterTypePsbtParseError,
+        FfiConverterTypeScript,
+        FfiConverterTypeTransaction,
+        FfiConverterTypeTxIn,
+        FfiConverterTypeTxOut,
+        FfiConverterTypeTxid,
+    },
+});
+//# sourceMappingURL=bitcoin.js.map