@nockchain/rose-ts 0.1.1-alpha → 0.1.1-alpha.3

package/dist/grpc/gen/nockchain/common/v2/blockchain.js

@@ -0,0 +1,1981 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { Name, Note as Note1, SchnorrSignature, Signature, Source, TimeLockRangeAbsolute, TimeLockRangeRelative, } from "../v1/blockchain.js";
+import { PageResponse } from "../v1/pagination.js";
+import { BlockHeight, Hash, Nicks, NoteVersion, SchnorrPubkey } from "../v1/primitives.js";
+export const protobufPackage = "nockchain.common.v2";
+function createBaseBalance() {
+    return { notes: [], height: undefined, block_id: undefined, page: undefined };
+}
+export const Balance = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.notes) {
+            BalanceEntry.encode(v, writer.uint32(10).fork()).join();
+        }
+        if (message.height !== undefined) {
+            BlockHeight.encode(message.height, writer.uint32(18).fork()).join();
+        }
+        if (message.block_id !== undefined) {
+            Hash.encode(message.block_id, writer.uint32(26).fork()).join();
+        }
+        if (message.page !== undefined) {
+            PageResponse.encode(message.page, writer.uint32(34).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBalance();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.notes.push(BalanceEntry.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.height = BlockHeight.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.block_id = Hash.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.page = PageResponse.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            notes: globalThis.Array.isArray(object?.notes) ? object.notes.map((e) => BalanceEntry.fromJSON(e)) : [],
+            height: isSet(object.height) ? BlockHeight.fromJSON(object.height) : undefined,
+            block_id: isSet(object.blockId)
+                ? Hash.fromJSON(object.blockId)
+                : isSet(object.block_id)
+                    ? Hash.fromJSON(object.block_id)
+                    : undefined,
+            page: isSet(object.page) ? PageResponse.fromJSON(object.page) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.notes?.length) {
+            obj.notes = message.notes.map((e) => BalanceEntry.toJSON(e));
+        }
+        if (message.height !== undefined) {
+            obj.height = BlockHeight.toJSON(message.height);
+        }
+        if (message.block_id !== undefined) {
+            obj.blockId = Hash.toJSON(message.block_id);
+        }
+        if (message.page !== undefined) {
+            obj.page = PageResponse.toJSON(message.page);
+        }
+        return obj;
+    },
+    create(base) {
+        return Balance.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseBalance();
+        message.notes = object.notes?.map((e) => BalanceEntry.fromPartial(e)) || [];
+        message.height = (object.height !== undefined && object.height !== null)
+            ? BlockHeight.fromPartial(object.height)
+            : undefined;
+        message.block_id = (object.block_id !== undefined && object.block_id !== null)
+            ? Hash.fromPartial(object.block_id)
+            : undefined;
+        message.page = (object.page !== undefined && object.page !== null)
+            ? PageResponse.fromPartial(object.page)
+            : undefined;
+        return message;
+    },
+};
+function createBaseBalanceEntry() {
+    return { name: undefined, note: undefined };
+}
+export const BalanceEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.name !== undefined) {
+            Name.encode(message.name, writer.uint32(10).fork()).join();
+        }
+        if (message.note !== undefined) {
+            Note.encode(message.note, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBalanceEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.name = Name.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.note = Note.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            name: isSet(object.name) ? Name.fromJSON(object.name) : undefined,
+            note: isSet(object.note) ? Note.fromJSON(object.note) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.name !== undefined) {
+            obj.name = Name.toJSON(message.name);
+        }
+        if (message.note !== undefined) {
+            obj.note = Note.toJSON(message.note);
+        }
+        return obj;
+    },
+    create(base) {
+        return BalanceEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseBalanceEntry();
+        message.name = (object.name !== undefined && object.name !== null) ? Name.fromPartial(object.name) : undefined;
+        message.note = (object.note !== undefined && object.note !== null) ? Note.fromPartial(object.note) : undefined;
+        return message;
+    },
+};
+function createBaseNote() {
+    return { note_version: undefined };
+}
+export const Note = {
+    encode(message, writer = new BinaryWriter()) {
+        switch (message.note_version?.$case) {
+            case "legacy":
+                Note1.encode(message.note_version.legacy, writer.uint32(10).fork()).join();
+                break;
+            case "v1":
+                NoteV1.encode(message.note_version.v1, writer.uint32(18).fork()).join();
+                break;
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseNote();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.note_version = { $case: "legacy", legacy: Note1.decode(reader, reader.uint32()) };
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.note_version = { $case: "v1", v1: NoteV1.decode(reader, reader.uint32()) };
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            note_version: isSet(object.legacy)
+                ? { $case: "legacy", legacy: Note1.fromJSON(object.legacy) }
+                : isSet(object.v1)
+                    ? { $case: "v1", v1: NoteV1.fromJSON(object.v1) }
+                    : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.note_version?.$case === "legacy") {
+            obj.legacy = Note1.toJSON(message.note_version.legacy);
+        }
+        else if (message.note_version?.$case === "v1") {
+            obj.v1 = NoteV1.toJSON(message.note_version.v1);
+        }
+        return obj;
+    },
+    create(base) {
+        return Note.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseNote();
+        switch (object.note_version?.$case) {
+            case "legacy": {
+                if (object.note_version?.legacy !== undefined && object.note_version?.legacy !== null) {
+                    message.note_version = { $case: "legacy", legacy: Note1.fromPartial(object.note_version.legacy) };
+                }
+                break;
+            }
+            case "v1": {
+                if (object.note_version?.v1 !== undefined && object.note_version?.v1 !== null) {
+                    message.note_version = { $case: "v1", v1: NoteV1.fromPartial(object.note_version.v1) };
+                }
+                break;
+            }
+        }
+        return message;
+    },
+};
+function createBaseNoteV1() {
+    return { version: undefined, origin_page: undefined, name: undefined, note_data: undefined, assets: undefined };
+}
+export const NoteV1 = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.version !== undefined) {
+            NoteVersion.encode(message.version, writer.uint32(10).fork()).join();
+        }
+        if (message.origin_page !== undefined) {
+            BlockHeight.encode(message.origin_page, writer.uint32(18).fork()).join();
+        }
+        if (message.name !== undefined) {
+            Name.encode(message.name, writer.uint32(26).fork()).join();
+        }
+        if (message.note_data !== undefined) {
+            NoteData.encode(message.note_data, writer.uint32(34).fork()).join();
+        }
+        if (message.assets !== undefined) {
+            Nicks.encode(message.assets, writer.uint32(42).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseNoteV1();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.version = NoteVersion.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.origin_page = BlockHeight.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.name = Name.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.note_data = NoteData.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.assets = Nicks.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            version: isSet(object.version) ? NoteVersion.fromJSON(object.version) : undefined,
+            origin_page: isSet(object.originPage)
+                ? BlockHeight.fromJSON(object.originPage)
+                : isSet(object.origin_page)
+                    ? BlockHeight.fromJSON(object.origin_page)
+                    : undefined,
+            name: isSet(object.name) ? Name.fromJSON(object.name) : undefined,
+            note_data: isSet(object.noteData)
+                ? NoteData.fromJSON(object.noteData)
+                : isSet(object.note_data)
+                    ? NoteData.fromJSON(object.note_data)
+                    : undefined,
+            assets: isSet(object.assets) ? Nicks.fromJSON(object.assets) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.version !== undefined) {
+            obj.version = NoteVersion.toJSON(message.version);
+        }
+        if (message.origin_page !== undefined) {
+            obj.originPage = BlockHeight.toJSON(message.origin_page);
+        }
+        if (message.name !== undefined) {
+            obj.name = Name.toJSON(message.name);
+        }
+        if (message.note_data !== undefined) {
+            obj.noteData = NoteData.toJSON(message.note_data);
+        }
+        if (message.assets !== undefined) {
+            obj.assets = Nicks.toJSON(message.assets);
+        }
+        return obj;
+    },
+    create(base) {
+        return NoteV1.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseNoteV1();
+        message.version = (object.version !== undefined && object.version !== null)
+            ? NoteVersion.fromPartial(object.version)
+            : undefined;
+        message.origin_page = (object.origin_page !== undefined && object.origin_page !== null)
+            ? BlockHeight.fromPartial(object.origin_page)
+            : undefined;
+        message.name = (object.name !== undefined && object.name !== null) ? Name.fromPartial(object.name) : undefined;
+        message.note_data = (object.note_data !== undefined && object.note_data !== null)
+            ? NoteData.fromPartial(object.note_data)
+            : undefined;
+        message.assets = (object.assets !== undefined && object.assets !== null)
+            ? Nicks.fromPartial(object.assets)
+            : undefined;
+        return message;
+    },
+};
+function createBaseNoteData() {
+    return { entries: [] };
+}
+export const NoteData = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.entries) {
+            NoteDataEntry.encode(v, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseNoteData();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.entries.push(NoteDataEntry.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            entries: globalThis.Array.isArray(object?.entries)
+                ? object.entries.map((e) => NoteDataEntry.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.entries?.length) {
+            obj.entries = message.entries.map((e) => NoteDataEntry.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return NoteData.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseNoteData();
+        message.entries = object.entries?.map((e) => NoteDataEntry.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseNoteDataEntry() {
+    return { key: "", blob: new Uint8Array(0) };
+}
+export const NoteDataEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.blob.length !== 0) {
+            writer.uint32(18).bytes(message.blob);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseNoteDataEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.key = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.blob = reader.bytes();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            blob: isSet(object.blob) ? bytesFromBase64(object.blob) : new Uint8Array(0),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== "") {
+            obj.key = message.key;
+        }
+        if (message.blob.length !== 0) {
+            obj.blob = base64FromBytes(message.blob);
+        }
+        return obj;
+    },
+    create(base) {
+        return NoteDataEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseNoteDataEntry();
+        message.key = object.key ?? "";
+        message.blob = object.blob ?? new Uint8Array(0);
+        return message;
+    },
+};
+function createBaseRawTransaction() {
+    return { version: undefined, id: undefined, spends: [] };
+}
+export const RawTransaction = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.version !== undefined) {
+            NoteVersion.encode(message.version, writer.uint32(10).fork()).join();
+        }
+        if (message.id !== undefined) {
+            Hash.encode(message.id, writer.uint32(18).fork()).join();
+        }
+        for (const v of message.spends) {
+            SpendEntry.encode(v, writer.uint32(26).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRawTransaction();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.version = NoteVersion.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.id = Hash.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.spends.push(SpendEntry.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            version: isSet(object.version) ? NoteVersion.fromJSON(object.version) : undefined,
+            id: isSet(object.id) ? Hash.fromJSON(object.id) : undefined,
+            spends: globalThis.Array.isArray(object?.spends) ? object.spends.map((e) => SpendEntry.fromJSON(e)) : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.version !== undefined) {
+            obj.version = NoteVersion.toJSON(message.version);
+        }
+        if (message.id !== undefined) {
+            obj.id = Hash.toJSON(message.id);
+        }
+        if (message.spends?.length) {
+            obj.spends = message.spends.map((e) => SpendEntry.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return RawTransaction.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseRawTransaction();
+        message.version = (object.version !== undefined && object.version !== null)
+            ? NoteVersion.fromPartial(object.version)
+            : undefined;
+        message.id = (object.id !== undefined && object.id !== null) ? Hash.fromPartial(object.id) : undefined;
+        message.spends = object.spends?.map((e) => SpendEntry.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseSpendEntry() {
+    return { name: undefined, spend: undefined };
+}
+export const SpendEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.name !== undefined) {
+            Name.encode(message.name, writer.uint32(10).fork()).join();
+        }
+        if (message.spend !== undefined) {
+            Spend.encode(message.spend, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSpendEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.name = Name.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.spend = Spend.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            name: isSet(object.name) ? Name.fromJSON(object.name) : undefined,
+            spend: isSet(object.spend) ? Spend.fromJSON(object.spend) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.name !== undefined) {
+            obj.name = Name.toJSON(message.name);
+        }
+        if (message.spend !== undefined) {
+            obj.spend = Spend.toJSON(message.spend);
+        }
+        return obj;
+    },
+    create(base) {
+        return SpendEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSpendEntry();
+        message.name = (object.name !== undefined && object.name !== null) ? Name.fromPartial(object.name) : undefined;
+        message.spend = (object.spend !== undefined && object.spend !== null) ? Spend.fromPartial(object.spend) : undefined;
+        return message;
+    },
+};
+function createBaseSpend() {
+    return { spend_kind: undefined };
+}
+export const Spend = {
+    encode(message, writer = new BinaryWriter()) {
+        switch (message.spend_kind?.$case) {
+            case "legacy":
+                LegacySpend.encode(message.spend_kind.legacy, writer.uint32(10).fork()).join();
+                break;
+            case "witness":
+                WitnessSpend.encode(message.spend_kind.witness, writer.uint32(18).fork()).join();
+                break;
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSpend();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.spend_kind = { $case: "legacy", legacy: LegacySpend.decode(reader, reader.uint32()) };
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.spend_kind = { $case: "witness", witness: WitnessSpend.decode(reader, reader.uint32()) };
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            spend_kind: isSet(object.legacy)
+                ? { $case: "legacy", legacy: LegacySpend.fromJSON(object.legacy) }
+                : isSet(object.witness)
+                    ? { $case: "witness", witness: WitnessSpend.fromJSON(object.witness) }
+                    : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.spend_kind?.$case === "legacy") {
+            obj.legacy = LegacySpend.toJSON(message.spend_kind.legacy);
+        }
+        else if (message.spend_kind?.$case === "witness") {
+            obj.witness = WitnessSpend.toJSON(message.spend_kind.witness);
+        }
+        return obj;
+    },
+    create(base) {
+        return Spend.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSpend();
+        switch (object.spend_kind?.$case) {
+            case "legacy": {
+                if (object.spend_kind?.legacy !== undefined && object.spend_kind?.legacy !== null) {
+                    message.spend_kind = { $case: "legacy", legacy: LegacySpend.fromPartial(object.spend_kind.legacy) };
+                }
+                break;
+            }
+            case "witness": {
+                if (object.spend_kind?.witness !== undefined && object.spend_kind?.witness !== null) {
+                    message.spend_kind = { $case: "witness", witness: WitnessSpend.fromPartial(object.spend_kind.witness) };
+                }
+                break;
+            }
+        }
+        return message;
+    },
+};
+function createBaseLegacySpend() {
+    return { signature: undefined, seeds: [], fee: undefined };
+}
+export const LegacySpend = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.signature !== undefined) {
+            Signature.encode(message.signature, writer.uint32(10).fork()).join();
+        }
+        for (const v of message.seeds) {
+            Seed.encode(v, writer.uint32(18).fork()).join();
+        }
+        if (message.fee !== undefined) {
+            Nicks.encode(message.fee, writer.uint32(26).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseLegacySpend();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.signature = Signature.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.seeds.push(Seed.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.fee = Nicks.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            signature: isSet(object.signature) ? Signature.fromJSON(object.signature) : undefined,
+            seeds: globalThis.Array.isArray(object?.seeds) ? object.seeds.map((e) => Seed.fromJSON(e)) : [],
+            fee: isSet(object.fee) ? Nicks.fromJSON(object.fee) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.signature !== undefined) {
+            obj.signature = Signature.toJSON(message.signature);
+        }
+        if (message.seeds?.length) {
+            obj.seeds = message.seeds.map((e) => Seed.toJSON(e));
+        }
+        if (message.fee !== undefined) {
+            obj.fee = Nicks.toJSON(message.fee);
+        }
+        return obj;
+    },
+    create(base) {
+        return LegacySpend.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseLegacySpend();
+        message.signature = (object.signature !== undefined && object.signature !== null)
+            ? Signature.fromPartial(object.signature)
+            : undefined;
+        message.seeds = object.seeds?.map((e) => Seed.fromPartial(e)) || [];
+        message.fee = (object.fee !== undefined && object.fee !== null) ? Nicks.fromPartial(object.fee) : undefined;
+        return message;
+    },
+};
+function createBaseWitnessSpend() {
+    return { witness: undefined, seeds: [], fee: undefined };
+}
+export const WitnessSpend = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.witness !== undefined) {
+            Witness.encode(message.witness, writer.uint32(10).fork()).join();
+        }
+        for (const v of message.seeds) {
+            Seed.encode(v, writer.uint32(18).fork()).join();
+        }
+        if (message.fee !== undefined) {
+            Nicks.encode(message.fee, writer.uint32(26).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseWitnessSpend();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.witness = Witness.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.seeds.push(Seed.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.fee = Nicks.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            witness: isSet(object.witness) ? Witness.fromJSON(object.witness) : undefined,
+            seeds: globalThis.Array.isArray(object?.seeds) ? object.seeds.map((e) => Seed.fromJSON(e)) : [],
+            fee: isSet(object.fee) ? Nicks.fromJSON(object.fee) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.witness !== undefined) {
+            obj.witness = Witness.toJSON(message.witness);
+        }
+        if (message.seeds?.length) {
+            obj.seeds = message.seeds.map((e) => Seed.toJSON(e));
+        }
+        if (message.fee !== undefined) {
+            obj.fee = Nicks.toJSON(message.fee);
+        }
+        return obj;
+    },
+    create(base) {
+        return WitnessSpend.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseWitnessSpend();
+        message.witness = (object.witness !== undefined && object.witness !== null)
+            ? Witness.fromPartial(object.witness)
+            : undefined;
+        message.seeds = object.seeds?.map((e) => Seed.fromPartial(e)) || [];
+        message.fee = (object.fee !== undefined && object.fee !== null) ? Nicks.fromPartial(object.fee) : undefined;
+        return message;
+    },
+};
+function createBaseSeed() {
+    return {
+        output_source: undefined,
+        lock_root: undefined,
+        note_data: undefined,
+        gift: undefined,
+        parent_hash: undefined,
+    };
+}
+export const Seed = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.output_source !== undefined) {
+            Source.encode(message.output_source, writer.uint32(10).fork()).join();
+        }
+        if (message.lock_root !== undefined) {
+            Hash.encode(message.lock_root, writer.uint32(18).fork()).join();
+        }
+        if (message.note_data !== undefined) {
+            NoteData.encode(message.note_data, writer.uint32(26).fork()).join();
+        }
+        if (message.gift !== undefined) {
+            Nicks.encode(message.gift, writer.uint32(34).fork()).join();
+        }
+        if (message.parent_hash !== undefined) {
+            Hash.encode(message.parent_hash, writer.uint32(42).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSeed();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.output_source = Source.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.lock_root = Hash.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.note_data = NoteData.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.gift = Nicks.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.parent_hash = Hash.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            output_source: isSet(object.outputSource)
+                ? Source.fromJSON(object.outputSource)
+                : isSet(object.output_source)
+                    ? Source.fromJSON(object.output_source)
+                    : undefined,
+            lock_root: isSet(object.lockRoot)
+                ? Hash.fromJSON(object.lockRoot)
+                : isSet(object.lock_root)
+                    ? Hash.fromJSON(object.lock_root)
+                    : undefined,
+            note_data: isSet(object.noteData)
+                ? NoteData.fromJSON(object.noteData)
+                : isSet(object.note_data)
+                    ? NoteData.fromJSON(object.note_data)
+                    : undefined,
+            gift: isSet(object.gift) ? Nicks.fromJSON(object.gift) : undefined,
+            parent_hash: isSet(object.parentHash)
+                ? Hash.fromJSON(object.parentHash)
+                : isSet(object.parent_hash)
+                    ? Hash.fromJSON(object.parent_hash)
+                    : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.output_source !== undefined) {
+            obj.outputSource = Source.toJSON(message.output_source);
+        }
+        if (message.lock_root !== undefined) {
+            obj.lockRoot = Hash.toJSON(message.lock_root);
+        }
+        if (message.note_data !== undefined) {
+            obj.noteData = NoteData.toJSON(message.note_data);
+        }
+        if (message.gift !== undefined) {
+            obj.gift = Nicks.toJSON(message.gift);
+        }
+        if (message.parent_hash !== undefined) {
+            obj.parentHash = Hash.toJSON(message.parent_hash);
+        }
+        return obj;
+    },
+    create(base) {
+        return Seed.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSeed();
+        message.output_source = (object.output_source !== undefined && object.output_source !== null)
+            ? Source.fromPartial(object.output_source)
+            : undefined;
+        message.lock_root = (object.lock_root !== undefined && object.lock_root !== null)
+            ? Hash.fromPartial(object.lock_root)
+            : undefined;
+        message.note_data = (object.note_data !== undefined && object.note_data !== null)
+            ? NoteData.fromPartial(object.note_data)
+            : undefined;
+        message.gift = (object.gift !== undefined && object.gift !== null) ? Nicks.fromPartial(object.gift) : undefined;
+        message.parent_hash = (object.parent_hash !== undefined && object.parent_hash !== null)
+            ? Hash.fromPartial(object.parent_hash)
+            : undefined;
+        return message;
+    },
+};
+function createBaseWitness() {
+    return { lock_merkle_proof: undefined, pkh_signature: undefined, hax: [] };
+}
+export const Witness = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.lock_merkle_proof !== undefined) {
+            LockMerkleProof.encode(message.lock_merkle_proof, writer.uint32(10).fork()).join();
+        }
+        if (message.pkh_signature !== undefined) {
+            PkhSignature.encode(message.pkh_signature, writer.uint32(18).fork()).join();
+        }
+        for (const v of message.hax) {
+            HaxPreimage.encode(v, writer.uint32(26).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseWitness();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.lock_merkle_proof = LockMerkleProof.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.pkh_signature = PkhSignature.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.hax.push(HaxPreimage.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            lock_merkle_proof: isSet(object.lockMerkleProof)
+                ? LockMerkleProof.fromJSON(object.lockMerkleProof)
+                : isSet(object.lock_merkle_proof)
+                    ? LockMerkleProof.fromJSON(object.lock_merkle_proof)
+                    : undefined,
+            pkh_signature: isSet(object.pkhSignature)
+                ? PkhSignature.fromJSON(object.pkhSignature)
+                : isSet(object.pkh_signature)
+                    ? PkhSignature.fromJSON(object.pkh_signature)
+                    : undefined,
+            hax: globalThis.Array.isArray(object?.hax) ? object.hax.map((e) => HaxPreimage.fromJSON(e)) : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.lock_merkle_proof !== undefined) {
+            obj.lockMerkleProof = LockMerkleProof.toJSON(message.lock_merkle_proof);
+        }
+        if (message.pkh_signature !== undefined) {
+            obj.pkhSignature = PkhSignature.toJSON(message.pkh_signature);
+        }
+        if (message.hax?.length) {
+            obj.hax = message.hax.map((e) => HaxPreimage.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return Witness.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseWitness();
+        message.lock_merkle_proof = (object.lock_merkle_proof !== undefined && object.lock_merkle_proof !== null)
+            ? LockMerkleProof.fromPartial(object.lock_merkle_proof)
+            : undefined;
+        message.pkh_signature = (object.pkh_signature !== undefined && object.pkh_signature !== null)
+            ? PkhSignature.fromPartial(object.pkh_signature)
+            : undefined;
+        message.hax = object.hax?.map((e) => HaxPreimage.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseHaxPreimage() {
+    return { hash: undefined, value: new Uint8Array(0) };
+}
+export const HaxPreimage = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.hash !== undefined) {
+            Hash.encode(message.hash, writer.uint32(10).fork()).join();
+        }
+        if (message.value.length !== 0) {
+            writer.uint32(18).bytes(message.value);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseHaxPreimage();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.hash = Hash.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.value = reader.bytes();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            hash: isSet(object.hash) ? Hash.fromJSON(object.hash) : undefined,
+            value: isSet(object.value) ? bytesFromBase64(object.value) : new Uint8Array(0),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.hash !== undefined) {
+            obj.hash = Hash.toJSON(message.hash);
+        }
+        if (message.value.length !== 0) {
+            obj.value = base64FromBytes(message.value);
+        }
+        return obj;
+    },
+    create(base) {
+        return HaxPreimage.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseHaxPreimage();
+        message.hash = (object.hash !== undefined && object.hash !== null) ? Hash.fromPartial(object.hash) : undefined;
+        message.value = object.value ?? new Uint8Array(0);
+        return message;
+    },
+};
+function createBasePkhSignature() {
+    return { entries: [] };
+}
+export const PkhSignature = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.entries) {
+            PkhSignatureEntry.encode(v, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePkhSignature();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.entries.push(PkhSignatureEntry.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            entries: globalThis.Array.isArray(object?.entries)
+                ? object.entries.map((e) => PkhSignatureEntry.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.entries?.length) {
+            obj.entries = message.entries.map((e) => PkhSignatureEntry.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return PkhSignature.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBasePkhSignature();
+        message.entries = object.entries?.map((e) => PkhSignatureEntry.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBasePkhSignatureEntry() {
+    return { hash: undefined, pubkey: undefined, signature: undefined };
+}
+export const PkhSignatureEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.hash !== undefined) {
+            Hash.encode(message.hash, writer.uint32(10).fork()).join();
+        }
+        if (message.pubkey !== undefined) {
+            SchnorrPubkey.encode(message.pubkey, writer.uint32(18).fork()).join();
+        }
+        if (message.signature !== undefined) {
+            SchnorrSignature.encode(message.signature, writer.uint32(26).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePkhSignatureEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.hash = Hash.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.pubkey = SchnorrPubkey.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.signature = SchnorrSignature.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            hash: isSet(object.hash) ? Hash.fromJSON(object.hash) : undefined,
+            pubkey: isSet(object.pubkey) ? SchnorrPubkey.fromJSON(object.pubkey) : undefined,
+            signature: isSet(object.signature) ? SchnorrSignature.fromJSON(object.signature) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.hash !== undefined) {
+            obj.hash = Hash.toJSON(message.hash);
+        }
+        if (message.pubkey !== undefined) {
+            obj.pubkey = SchnorrPubkey.toJSON(message.pubkey);
+        }
+        if (message.signature !== undefined) {
+            obj.signature = SchnorrSignature.toJSON(message.signature);
+        }
+        return obj;
+    },
+    create(base) {
+        return PkhSignatureEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBasePkhSignatureEntry();
+        message.hash = (object.hash !== undefined && object.hash !== null) ? Hash.fromPartial(object.hash) : undefined;
+        message.pubkey = (object.pubkey !== undefined && object.pubkey !== null)
+            ? SchnorrPubkey.fromPartial(object.pubkey)
+            : undefined;
+        message.signature = (object.signature !== undefined && object.signature !== null)
+            ? SchnorrSignature.fromPartial(object.signature)
+            : undefined;
+        return message;
+    },
+};
+function createBaseLockMerkleProof() {
+    return { spend_condition: undefined, axis: "0", proof: undefined, lmp_version: undefined };
+}
+export const LockMerkleProof = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.spend_condition !== undefined) {
+            SpendCondition.encode(message.spend_condition, writer.uint32(10).fork()).join();
+        }
+        if (message.axis !== "0") {
+            writer.uint32(16).uint64(message.axis);
+        }
+        if (message.proof !== undefined) {
+            MerkleProof.encode(message.proof, writer.uint32(26).fork()).join();
+        }
+        if (message.lmp_version !== undefined) {
+            writer.uint32(32).uint64(message.lmp_version);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseLockMerkleProof();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.spend_condition = SpendCondition.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.axis = reader.uint64().toString();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.proof = MerkleProof.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.lmp_version = reader.uint64().toString();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            spend_condition: isSet(object.spendCondition)
+                ? SpendCondition.fromJSON(object.spendCondition)
+                : isSet(object.spend_condition)
+                    ? SpendCondition.fromJSON(object.spend_condition)
+                    : undefined,
+            axis: isSet(object.axis) ? globalThis.String(object.axis) : "0",
+            proof: isSet(object.proof) ? MerkleProof.fromJSON(object.proof) : undefined,
+            lmp_version: isSet(object.lmpVersion)
+                ? globalThis.String(object.lmpVersion)
+                : isSet(object.lmp_version)
+                    ? globalThis.String(object.lmp_version)
+                    : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.spend_condition !== undefined) {
+            obj.spendCondition = SpendCondition.toJSON(message.spend_condition);
+        }
+        if (message.axis !== "0") {
+            obj.axis = message.axis;
+        }
+        if (message.proof !== undefined) {
+            obj.proof = MerkleProof.toJSON(message.proof);
+        }
+        if (message.lmp_version !== undefined) {
+            obj.lmpVersion = message.lmp_version;
+        }
+        return obj;
+    },
+    create(base) {
+        return LockMerkleProof.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseLockMerkleProof();
+        message.spend_condition = (object.spend_condition !== undefined && object.spend_condition !== null)
+            ? SpendCondition.fromPartial(object.spend_condition)
+            : undefined;
+        message.axis = object.axis ?? "0";
+        message.proof = (object.proof !== undefined && object.proof !== null)
+            ? MerkleProof.fromPartial(object.proof)
+            : undefined;
+        message.lmp_version = object.lmp_version ?? undefined;
+        return message;
+    },
+};
+function createBaseSpendCondition() {
+    return { primitives: [] };
+}
+export const SpendCondition = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.primitives) {
+            LockPrimitive.encode(v, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSpendCondition();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.primitives.push(LockPrimitive.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            primitives: globalThis.Array.isArray(object?.primitives)
+                ? object.primitives.map((e) => LockPrimitive.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.primitives?.length) {
+            obj.primitives = message.primitives.map((e) => LockPrimitive.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return SpendCondition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSpendCondition();
+        message.primitives = object.primitives?.map((e) => LockPrimitive.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseLockPrimitive() {
+    return { primitive: undefined };
+}
+export const LockPrimitive = {
+    encode(message, writer = new BinaryWriter()) {
+        switch (message.primitive?.$case) {
+            case "pkh":
+                PkhLock.encode(message.primitive.pkh, writer.uint32(10).fork()).join();
+                break;
+            case "tim":
+                LockTim.encode(message.primitive.tim, writer.uint32(18).fork()).join();
+                break;
+            case "hax":
+                HaxLock.encode(message.primitive.hax, writer.uint32(26).fork()).join();
+                break;
+            case "burn":
+                BurnLock.encode(message.primitive.burn, writer.uint32(34).fork()).join();
+                break;
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseLockPrimitive();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.primitive = { $case: "pkh", pkh: PkhLock.decode(reader, reader.uint32()) };
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.primitive = { $case: "tim", tim: LockTim.decode(reader, reader.uint32()) };
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.primitive = { $case: "hax", hax: HaxLock.decode(reader, reader.uint32()) };
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.primitive = { $case: "burn", burn: BurnLock.decode(reader, reader.uint32()) };
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            primitive: isSet(object.pkh)
+                ? { $case: "pkh", pkh: PkhLock.fromJSON(object.pkh) }
+                : isSet(object.tim)
+                    ? { $case: "tim", tim: LockTim.fromJSON(object.tim) }
+                    : isSet(object.hax)
+                        ? { $case: "hax", hax: HaxLock.fromJSON(object.hax) }
+                        : isSet(object.burn)
+                            ? { $case: "burn", burn: BurnLock.fromJSON(object.burn) }
+                            : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.primitive?.$case === "pkh") {
+            obj.pkh = PkhLock.toJSON(message.primitive.pkh);
+        }
+        else if (message.primitive?.$case === "tim") {
+            obj.tim = LockTim.toJSON(message.primitive.tim);
+        }
+        else if (message.primitive?.$case === "hax") {
+            obj.hax = HaxLock.toJSON(message.primitive.hax);
+        }
+        else if (message.primitive?.$case === "burn") {
+            obj.burn = BurnLock.toJSON(message.primitive.burn);
+        }
+        return obj;
+    },
+    create(base) {
+        return LockPrimitive.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseLockPrimitive();
+        switch (object.primitive?.$case) {
+            case "pkh": {
+                if (object.primitive?.pkh !== undefined && object.primitive?.pkh !== null) {
+                    message.primitive = { $case: "pkh", pkh: PkhLock.fromPartial(object.primitive.pkh) };
+                }
+                break;
+            }
+            case "tim": {
+                if (object.primitive?.tim !== undefined && object.primitive?.tim !== null) {
+                    message.primitive = { $case: "tim", tim: LockTim.fromPartial(object.primitive.tim) };
+                }
+                break;
+            }
+            case "hax": {
+                if (object.primitive?.hax !== undefined && object.primitive?.hax !== null) {
+                    message.primitive = { $case: "hax", hax: HaxLock.fromPartial(object.primitive.hax) };
+                }
+                break;
+            }
+            case "burn": {
+                if (object.primitive?.burn !== undefined && object.primitive?.burn !== null) {
+                    message.primitive = { $case: "burn", burn: BurnLock.fromPartial(object.primitive.burn) };
+                }
+                break;
+            }
+        }
+        return message;
+    },
+};
+function createBasePkhLock() {
+    return { m: "0", hashes: [] };
+}
+export const PkhLock = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.m !== "0") {
+            writer.uint32(8).uint64(message.m);
+        }
+        for (const v of message.hashes) {
+            Hash.encode(v, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePkhLock();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.m = reader.uint64().toString();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.hashes.push(Hash.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            m: isSet(object.m) ? globalThis.String(object.m) : "0",
+            hashes: globalThis.Array.isArray(object?.hashes) ? object.hashes.map((e) => Hash.fromJSON(e)) : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.m !== "0") {
+            obj.m = message.m;
+        }
+        if (message.hashes?.length) {
+            obj.hashes = message.hashes.map((e) => Hash.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return PkhLock.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBasePkhLock();
+        message.m = object.m ?? "0";
+        message.hashes = object.hashes?.map((e) => Hash.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseLockTim() {
+    return { rel: undefined, abs: undefined };
+}
+export const LockTim = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.rel !== undefined) {
+            TimeLockRangeRelative.encode(message.rel, writer.uint32(10).fork()).join();
+        }
+        if (message.abs !== undefined) {
+            TimeLockRangeAbsolute.encode(message.abs, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseLockTim();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.rel = TimeLockRangeRelative.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.abs = TimeLockRangeAbsolute.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            rel: isSet(object.rel) ? TimeLockRangeRelative.fromJSON(object.rel) : undefined,
+            abs: isSet(object.abs) ? TimeLockRangeAbsolute.fromJSON(object.abs) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.rel !== undefined) {
+            obj.rel = TimeLockRangeRelative.toJSON(message.rel);
+        }
+        if (message.abs !== undefined) {
+            obj.abs = TimeLockRangeAbsolute.toJSON(message.abs);
+        }
+        return obj;
+    },
+    create(base) {
+        return LockTim.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseLockTim();
+        message.rel = (object.rel !== undefined && object.rel !== null)
+            ? TimeLockRangeRelative.fromPartial(object.rel)
+            : undefined;
+        message.abs = (object.abs !== undefined && object.abs !== null)
+            ? TimeLockRangeAbsolute.fromPartial(object.abs)
+            : undefined;
+        return message;
+    },
+};
+function createBaseHaxLock() {
+    return { hashes: [] };
+}
+export const HaxLock = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.hashes) {
+            Hash.encode(v, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseHaxLock();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.hashes.push(Hash.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { hashes: globalThis.Array.isArray(object?.hashes) ? object.hashes.map((e) => Hash.fromJSON(e)) : [] };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.hashes?.length) {
+            obj.hashes = message.hashes.map((e) => Hash.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return HaxLock.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseHaxLock();
+        message.hashes = object.hashes?.map((e) => Hash.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseBurnLock() {
+    return {};
+}
+export const BurnLock = {
+    encode(_, writer = new BinaryWriter()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBurnLock();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(_) {
+        return {};
+    },
+    toJSON(_) {
+        const obj = {};
+        return obj;
+    },
+    create(base) {
+        return BurnLock.fromPartial(base ?? {});
+    },
+    fromPartial(_) {
+        const message = createBaseBurnLock();
+        return message;
+    },
+};
+function createBaseMerkleProof() {
+    return { root: undefined, path: [] };
+}
+export const MerkleProof = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.root !== undefined) {
+            Hash.encode(message.root, writer.uint32(10).fork()).join();
+        }
+        for (const v of message.path) {
+            Hash.encode(v, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMerkleProof();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.root = Hash.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.path.push(Hash.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            root: isSet(object.root) ? Hash.fromJSON(object.root) : undefined,
+            path: globalThis.Array.isArray(object?.path) ? object.path.map((e) => Hash.fromJSON(e)) : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.root !== undefined) {
+            obj.root = Hash.toJSON(message.root);
+        }
+        if (message.path?.length) {
+            obj.path = message.path.map((e) => Hash.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return MerkleProof.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseMerkleProof();
+        message.root = (object.root !== undefined && object.root !== null) ? Hash.fromPartial(object.root) : undefined;
+        message.path = object.path?.map((e) => Hash.fromPartial(e)) || [];
+        return message;
+    },
+};
+function bytesFromBase64(b64) {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+        arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+}
+function base64FromBytes(arr) {
+    const bin = [];
+    arr.forEach((byte) => {
+        bin.push(globalThis.String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}
+//# sourceMappingURL=blockchain.js.map