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

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

@@ -0,0 +1,1683 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { PageResponse } from "./pagination.js";
+import { BlockHeight, BlockHeightDelta, EightBelt, Hash, Nicks, NoteVersion, SchnorrPubkey } from "./primitives.js";
+export const protobufPackage = "nockchain.common.v1";
+function createBaseWalletBalanceData() {
+    return { notes: [], height: undefined, block_id: undefined, page: undefined };
+}
+export const WalletBalanceData = {
+    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 = createBaseWalletBalanceData();
+        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 WalletBalanceData.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseWalletBalanceData();
+        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 createBaseRawTransaction() {
+    return { named_inputs: [], timelock_range: undefined, total_fees: undefined, id: undefined };
+}
+export const RawTransaction = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.named_inputs) {
+            NamedInput.encode(v, writer.uint32(10).fork()).join();
+        }
+        if (message.timelock_range !== undefined) {
+            TimeLockRangeAbsolute.encode(message.timelock_range, writer.uint32(18).fork()).join();
+        }
+        if (message.total_fees !== undefined) {
+            Nicks.encode(message.total_fees, writer.uint32(26).fork()).join();
+        }
+        if (message.id !== undefined) {
+            Hash.encode(message.id, 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 = createBaseRawTransaction();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.named_inputs.push(NamedInput.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.timelock_range = TimeLockRangeAbsolute.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.total_fees = Nicks.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.id = Hash.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            named_inputs: globalThis.Array.isArray(object?.namedInputs)
+                ? object.namedInputs.map((e) => NamedInput.fromJSON(e))
+                : globalThis.Array.isArray(object?.named_inputs)
+                    ? object.named_inputs.map((e) => NamedInput.fromJSON(e))
+                    : [],
+            timelock_range: isSet(object.timelockRange)
+                ? TimeLockRangeAbsolute.fromJSON(object.timelockRange)
+                : isSet(object.timelock_range)
+                    ? TimeLockRangeAbsolute.fromJSON(object.timelock_range)
+                    : undefined,
+            total_fees: isSet(object.totalFees)
+                ? Nicks.fromJSON(object.totalFees)
+                : isSet(object.total_fees)
+                    ? Nicks.fromJSON(object.total_fees)
+                    : undefined,
+            id: isSet(object.id) ? Hash.fromJSON(object.id) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.named_inputs?.length) {
+            obj.namedInputs = message.named_inputs.map((e) => NamedInput.toJSON(e));
+        }
+        if (message.timelock_range !== undefined) {
+            obj.timelockRange = TimeLockRangeAbsolute.toJSON(message.timelock_range);
+        }
+        if (message.total_fees !== undefined) {
+            obj.totalFees = Nicks.toJSON(message.total_fees);
+        }
+        if (message.id !== undefined) {
+            obj.id = Hash.toJSON(message.id);
+        }
+        return obj;
+    },
+    create(base) {
+        return RawTransaction.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseRawTransaction();
+        message.named_inputs = object.named_inputs?.map((e) => NamedInput.fromPartial(e)) || [];
+        message.timelock_range = (object.timelock_range !== undefined && object.timelock_range !== null)
+            ? TimeLockRangeAbsolute.fromPartial(object.timelock_range)
+            : undefined;
+        message.total_fees = (object.total_fees !== undefined && object.total_fees !== null)
+            ? Nicks.fromPartial(object.total_fees)
+            : undefined;
+        message.id = (object.id !== undefined && object.id !== null) ? Hash.fromPartial(object.id) : undefined;
+        return message;
+    },
+};
+function createBaseNamedInput() {
+    return { name: undefined, input: undefined };
+}
+export const NamedInput = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.name !== undefined) {
+            Name.encode(message.name, writer.uint32(10).fork()).join();
+        }
+        if (message.input !== undefined) {
+            Input.encode(message.input, 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 = createBaseNamedInput();
+        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.input = Input.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,
+            input: isSet(object.input) ? Input.fromJSON(object.input) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.name !== undefined) {
+            obj.name = Name.toJSON(message.name);
+        }
+        if (message.input !== undefined) {
+            obj.input = Input.toJSON(message.input);
+        }
+        return obj;
+    },
+    create(base) {
+        return NamedInput.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseNamedInput();
+        message.name = (object.name !== undefined && object.name !== null) ? Name.fromPartial(object.name) : undefined;
+        message.input = (object.input !== undefined && object.input !== null) ? Input.fromPartial(object.input) : undefined;
+        return message;
+    },
+};
+function createBaseInput() {
+    return { note: undefined, spend: undefined };
+}
+export const Input = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.note !== undefined) {
+            Note.encode(message.note, 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 = createBaseInput();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.note = Note.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 {
+            note: isSet(object.note) ? Note.fromJSON(object.note) : undefined,
+            spend: isSet(object.spend) ? Spend.fromJSON(object.spend) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.note !== undefined) {
+            obj.note = Note.toJSON(message.note);
+        }
+        if (message.spend !== undefined) {
+            obj.spend = Spend.toJSON(message.spend);
+        }
+        return obj;
+    },
+    create(base) {
+        return Input.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseInput();
+        message.note = (object.note !== undefined && object.note !== null) ? Note.fromPartial(object.note) : undefined;
+        message.spend = (object.spend !== undefined && object.spend !== null) ? Spend.fromPartial(object.spend) : undefined;
+        return message;
+    },
+};
+function createBaseSpend() {
+    return { signature: undefined, seeds: [], miner_fee_nicks: undefined };
+}
+export const Spend = {
+    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.miner_fee_nicks !== undefined) {
+            Nicks.encode(message.miner_fee_nicks, 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 = createBaseSpend();
+        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.miner_fee_nicks = 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)) : [],
+            miner_fee_nicks: isSet(object.minerFeeNicks)
+                ? Nicks.fromJSON(object.minerFeeNicks)
+                : isSet(object.miner_fee_nicks)
+                    ? Nicks.fromJSON(object.miner_fee_nicks)
+                    : 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.miner_fee_nicks !== undefined) {
+            obj.minerFeeNicks = Nicks.toJSON(message.miner_fee_nicks);
+        }
+        return obj;
+    },
+    create(base) {
+        return Spend.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSpend();
+        message.signature = (object.signature !== undefined && object.signature !== null)
+            ? Signature.fromPartial(object.signature)
+            : undefined;
+        message.seeds = object.seeds?.map((e) => Seed.fromPartial(e)) || [];
+        message.miner_fee_nicks = (object.miner_fee_nicks !== undefined && object.miner_fee_nicks !== null)
+            ? Nicks.fromPartial(object.miner_fee_nicks)
+            : undefined;
+        return message;
+    },
+};
+function createBaseSeed() {
+    return {
+        output_source: undefined,
+        recipient: undefined,
+        timelock_intent: undefined,
+        gift: undefined,
+        parent_hash: undefined,
+    };
+}
+export const Seed = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.output_source !== undefined) {
+            OutputSource.encode(message.output_source, writer.uint32(10).fork()).join();
+        }
+        if (message.recipient !== undefined) {
+            Lock.encode(message.recipient, writer.uint32(18).fork()).join();
+        }
+        if (message.timelock_intent !== undefined) {
+            TimeLockIntent.encode(message.timelock_intent, 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 = OutputSource.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.recipient = Lock.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.timelock_intent = TimeLockIntent.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)
+                ? OutputSource.fromJSON(object.outputSource)
+                : isSet(object.output_source)
+                    ? OutputSource.fromJSON(object.output_source)
+                    : undefined,
+            recipient: isSet(object.recipient) ? Lock.fromJSON(object.recipient) : undefined,
+            timelock_intent: isSet(object.timelockIntent)
+                ? TimeLockIntent.fromJSON(object.timelockIntent)
+                : isSet(object.timelock_intent)
+                    ? TimeLockIntent.fromJSON(object.timelock_intent)
+                    : 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 = OutputSource.toJSON(message.output_source);
+        }
+        if (message.recipient !== undefined) {
+            obj.recipient = Lock.toJSON(message.recipient);
+        }
+        if (message.timelock_intent !== undefined) {
+            obj.timelockIntent = TimeLockIntent.toJSON(message.timelock_intent);
+        }
+        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)
+            ? OutputSource.fromPartial(object.output_source)
+            : undefined;
+        message.recipient = (object.recipient !== undefined && object.recipient !== null)
+            ? Lock.fromPartial(object.recipient)
+            : undefined;
+        message.timelock_intent = (object.timelock_intent !== undefined && object.timelock_intent !== null)
+            ? TimeLockIntent.fromPartial(object.timelock_intent)
+            : 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 createBaseOutputSource() {
+    return { source: undefined };
+}
+export const OutputSource = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.source !== undefined) {
+            Source.encode(message.source, 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 = createBaseOutputSource();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.source = Source.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { source: isSet(object.source) ? Source.fromJSON(object.source) : undefined };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.source !== undefined) {
+            obj.source = Source.toJSON(message.source);
+        }
+        return obj;
+    },
+    create(base) {
+        return OutputSource.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseOutputSource();
+        message.source = (object.source !== undefined && object.source !== null)
+            ? Source.fromPartial(object.source)
+            : undefined;
+        return message;
+    },
+};
+function createBaseSource() {
+    return { hash: undefined, coinbase: false };
+}
+export const Source = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.hash !== undefined) {
+            Hash.encode(message.hash, writer.uint32(10).fork()).join();
+        }
+        if (message.coinbase !== false) {
+            writer.uint32(16).bool(message.coinbase);
+        }
+        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 = createBaseSource();
+        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 !== 16) {
+                        break;
+                    }
+                    message.coinbase = reader.bool();
+                    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,
+            coinbase: isSet(object.coinbase) ? globalThis.Boolean(object.coinbase) : false,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.hash !== undefined) {
+            obj.hash = Hash.toJSON(message.hash);
+        }
+        if (message.coinbase !== false) {
+            obj.coinbase = message.coinbase;
+        }
+        return obj;
+    },
+    create(base) {
+        return Source.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSource();
+        message.hash = (object.hash !== undefined && object.hash !== null) ? Hash.fromPartial(object.hash) : undefined;
+        message.coinbase = object.coinbase ?? false;
+        return message;
+    },
+};
+function createBaseTimeLockIntent() {
+    return { value: undefined };
+}
+export const TimeLockIntent = {
+    encode(message, writer = new BinaryWriter()) {
+        switch (message.value?.$case) {
+            case "absolute":
+                TimeLockRangeAbsolute.encode(message.value.absolute, writer.uint32(10).fork()).join();
+                break;
+            case "relative":
+                TimeLockRangeRelative.encode(message.value.relative, writer.uint32(18).fork()).join();
+                break;
+            case "absolute_and_relative":
+                TimeLockRangeAbsoluteAndRelative.encode(message.value.absolute_and_relative, writer.uint32(26).fork()).join();
+                break;
+            case "neither":
+                TimeLockRangeNeither.encode(message.value.neither, 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 = createBaseTimeLockIntent();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.value = { $case: "absolute", absolute: TimeLockRangeAbsolute.decode(reader, reader.uint32()) };
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.value = { $case: "relative", relative: TimeLockRangeRelative.decode(reader, reader.uint32()) };
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.value = {
+                        $case: "absolute_and_relative",
+                        absolute_and_relative: TimeLockRangeAbsoluteAndRelative.decode(reader, reader.uint32()),
+                    };
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.value = { $case: "neither", neither: TimeLockRangeNeither.decode(reader, reader.uint32()) };
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            value: isSet(object.absolute)
+                ? { $case: "absolute", absolute: TimeLockRangeAbsolute.fromJSON(object.absolute) }
+                : isSet(object.relative)
+                    ? { $case: "relative", relative: TimeLockRangeRelative.fromJSON(object.relative) }
+                    : isSet(object.absoluteAndRelative)
+                        ? {
+                            $case: "absolute_and_relative",
+                            absolute_and_relative: TimeLockRangeAbsoluteAndRelative.fromJSON(object.absoluteAndRelative),
+                        }
+                        : isSet(object.absolute_and_relative)
+                            ? {
+                                $case: "absolute_and_relative",
+                                absolute_and_relative: TimeLockRangeAbsoluteAndRelative.fromJSON(object.absolute_and_relative),
+                            }
+                            : isSet(object.neither)
+                                ? { $case: "neither", neither: TimeLockRangeNeither.fromJSON(object.neither) }
+                                : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.value?.$case === "absolute") {
+            obj.absolute = TimeLockRangeAbsolute.toJSON(message.value.absolute);
+        }
+        else if (message.value?.$case === "relative") {
+            obj.relative = TimeLockRangeRelative.toJSON(message.value.relative);
+        }
+        else if (message.value?.$case === "absolute_and_relative") {
+            obj.absoluteAndRelative = TimeLockRangeAbsoluteAndRelative.toJSON(message.value.absolute_and_relative);
+        }
+        else if (message.value?.$case === "neither") {
+            obj.neither = TimeLockRangeNeither.toJSON(message.value.neither);
+        }
+        return obj;
+    },
+    create(base) {
+        return TimeLockIntent.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTimeLockIntent();
+        switch (object.value?.$case) {
+            case "absolute": {
+                if (object.value?.absolute !== undefined && object.value?.absolute !== null) {
+                    message.value = { $case: "absolute", absolute: TimeLockRangeAbsolute.fromPartial(object.value.absolute) };
+                }
+                break;
+            }
+            case "relative": {
+                if (object.value?.relative !== undefined && object.value?.relative !== null) {
+                    message.value = { $case: "relative", relative: TimeLockRangeRelative.fromPartial(object.value.relative) };
+                }
+                break;
+            }
+            case "absolute_and_relative": {
+                if (object.value?.absolute_and_relative !== undefined && object.value?.absolute_and_relative !== null) {
+                    message.value = {
+                        $case: "absolute_and_relative",
+                        absolute_and_relative: TimeLockRangeAbsoluteAndRelative.fromPartial(object.value.absolute_and_relative),
+                    };
+                }
+                break;
+            }
+            case "neither": {
+                if (object.value?.neither !== undefined && object.value?.neither !== null) {
+                    message.value = { $case: "neither", neither: TimeLockRangeNeither.fromPartial(object.value.neither) };
+                }
+                break;
+            }
+        }
+        return message;
+    },
+};
+function createBaseTimeLockRangeNeither() {
+    return {};
+}
+export const TimeLockRangeNeither = {
+    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 = createBaseTimeLockRangeNeither();
+        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 TimeLockRangeNeither.fromPartial(base ?? {});
+    },
+    fromPartial(_) {
+        const message = createBaseTimeLockRangeNeither();
+        return message;
+    },
+};
+function createBaseTimeLockRangeAbsoluteAndRelative() {
+    return { absolute: undefined, relative: undefined };
+}
+export const TimeLockRangeAbsoluteAndRelative = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.absolute !== undefined) {
+            TimeLockRangeAbsolute.encode(message.absolute, writer.uint32(10).fork()).join();
+        }
+        if (message.relative !== undefined) {
+            TimeLockRangeRelative.encode(message.relative, 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 = createBaseTimeLockRangeAbsoluteAndRelative();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.absolute = TimeLockRangeAbsolute.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.relative = TimeLockRangeRelative.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            absolute: isSet(object.absolute) ? TimeLockRangeAbsolute.fromJSON(object.absolute) : undefined,
+            relative: isSet(object.relative) ? TimeLockRangeRelative.fromJSON(object.relative) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.absolute !== undefined) {
+            obj.absolute = TimeLockRangeAbsolute.toJSON(message.absolute);
+        }
+        if (message.relative !== undefined) {
+            obj.relative = TimeLockRangeRelative.toJSON(message.relative);
+        }
+        return obj;
+    },
+    create(base) {
+        return TimeLockRangeAbsoluteAndRelative.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTimeLockRangeAbsoluteAndRelative();
+        message.absolute = (object.absolute !== undefined && object.absolute !== null)
+            ? TimeLockRangeAbsolute.fromPartial(object.absolute)
+            : undefined;
+        message.relative = (object.relative !== undefined && object.relative !== null)
+            ? TimeLockRangeRelative.fromPartial(object.relative)
+            : undefined;
+        return message;
+    },
+};
+function createBaseTimeLockRangeAbsolute() {
+    return { min: undefined, max: undefined };
+}
+export const TimeLockRangeAbsolute = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.min !== undefined) {
+            BlockHeight.encode(message.min, writer.uint32(10).fork()).join();
+        }
+        if (message.max !== undefined) {
+            BlockHeight.encode(message.max, 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 = createBaseTimeLockRangeAbsolute();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.min = BlockHeight.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.max = BlockHeight.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            min: isSet(object.min) ? BlockHeight.fromJSON(object.min) : undefined,
+            max: isSet(object.max) ? BlockHeight.fromJSON(object.max) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.min !== undefined) {
+            obj.min = BlockHeight.toJSON(message.min);
+        }
+        if (message.max !== undefined) {
+            obj.max = BlockHeight.toJSON(message.max);
+        }
+        return obj;
+    },
+    create(base) {
+        return TimeLockRangeAbsolute.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTimeLockRangeAbsolute();
+        message.min = (object.min !== undefined && object.min !== null) ? BlockHeight.fromPartial(object.min) : undefined;
+        message.max = (object.max !== undefined && object.max !== null) ? BlockHeight.fromPartial(object.max) : undefined;
+        return message;
+    },
+};
+function createBaseTimeLockRangeRelative() {
+    return { min: undefined, max: undefined };
+}
+export const TimeLockRangeRelative = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.min !== undefined) {
+            BlockHeightDelta.encode(message.min, writer.uint32(10).fork()).join();
+        }
+        if (message.max !== undefined) {
+            BlockHeightDelta.encode(message.max, 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 = createBaseTimeLockRangeRelative();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.min = BlockHeightDelta.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.max = BlockHeightDelta.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            min: isSet(object.min) ? BlockHeightDelta.fromJSON(object.min) : undefined,
+            max: isSet(object.max) ? BlockHeightDelta.fromJSON(object.max) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.min !== undefined) {
+            obj.min = BlockHeightDelta.toJSON(message.min);
+        }
+        if (message.max !== undefined) {
+            obj.max = BlockHeightDelta.toJSON(message.max);
+        }
+        return obj;
+    },
+    create(base) {
+        return TimeLockRangeRelative.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTimeLockRangeRelative();
+        message.min = (object.min !== undefined && object.min !== null)
+            ? BlockHeightDelta.fromPartial(object.min)
+            : undefined;
+        message.max = (object.max !== undefined && object.max !== null)
+            ? BlockHeightDelta.fromPartial(object.max)
+            : undefined;
+        return message;
+    },
+};
+function createBaseLock() {
+    return { keys_required: 0, schnorr_pubkeys: [] };
+}
+export const Lock = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.keys_required !== 0) {
+            writer.uint32(8).uint32(message.keys_required);
+        }
+        for (const v of message.schnorr_pubkeys) {
+            SchnorrPubkey.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 = createBaseLock();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.keys_required = reader.uint32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.schnorr_pubkeys.push(SchnorrPubkey.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            keys_required: isSet(object.keysRequired)
+                ? globalThis.Number(object.keysRequired)
+                : isSet(object.keys_required)
+                    ? globalThis.Number(object.keys_required)
+                    : 0,
+            schnorr_pubkeys: globalThis.Array.isArray(object?.schnorrPubkeys)
+                ? object.schnorrPubkeys.map((e) => SchnorrPubkey.fromJSON(e))
+                : globalThis.Array.isArray(object?.schnorr_pubkeys)
+                    ? object.schnorr_pubkeys.map((e) => SchnorrPubkey.fromJSON(e))
+                    : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.keys_required !== 0) {
+            obj.keysRequired = Math.round(message.keys_required);
+        }
+        if (message.schnorr_pubkeys?.length) {
+            obj.schnorrPubkeys = message.schnorr_pubkeys.map((e) => SchnorrPubkey.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return Lock.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseLock();
+        message.keys_required = object.keys_required ?? 0;
+        message.schnorr_pubkeys = object.schnorr_pubkeys?.map((e) => SchnorrPubkey.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseName() {
+    return { first: undefined, last: undefined };
+}
+export const Name = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.first !== undefined) {
+            Hash.encode(message.first, writer.uint32(10).fork()).join();
+        }
+        if (message.last !== undefined) {
+            Hash.encode(message.last, 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 = createBaseName();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.first = Hash.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.last = Hash.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            first: isSet(object.first) ? Hash.fromJSON(object.first) : undefined,
+            last: isSet(object.last) ? Hash.fromJSON(object.last) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.first !== undefined) {
+            obj.first = Hash.toJSON(message.first);
+        }
+        if (message.last !== undefined) {
+            obj.last = Hash.toJSON(message.last);
+        }
+        return obj;
+    },
+    create(base) {
+        return Name.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseName();
+        message.first = (object.first !== undefined && object.first !== null) ? Hash.fromPartial(object.first) : undefined;
+        message.last = (object.last !== undefined && object.last !== null) ? Hash.fromPartial(object.last) : undefined;
+        return message;
+    },
+};
+function createBaseNote() {
+    return {
+        origin_page: undefined,
+        timelock: undefined,
+        name: undefined,
+        lock: undefined,
+        source: undefined,
+        assets: undefined,
+        version: undefined,
+    };
+}
+export const Note = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.origin_page !== undefined) {
+            BlockHeight.encode(message.origin_page, writer.uint32(10).fork()).join();
+        }
+        if (message.timelock !== undefined) {
+            TimeLockIntent.encode(message.timelock, writer.uint32(18).fork()).join();
+        }
+        if (message.name !== undefined) {
+            Name.encode(message.name, writer.uint32(26).fork()).join();
+        }
+        if (message.lock !== undefined) {
+            Lock.encode(message.lock, writer.uint32(34).fork()).join();
+        }
+        if (message.source !== undefined) {
+            Source.encode(message.source, writer.uint32(42).fork()).join();
+        }
+        if (message.assets !== undefined) {
+            Nicks.encode(message.assets, writer.uint32(50).fork()).join();
+        }
+        if (message.version !== undefined) {
+            NoteVersion.encode(message.version, writer.uint32(58).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 = createBaseNote();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.origin_page = BlockHeight.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.timelock = TimeLockIntent.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.lock = Lock.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.source = Source.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.assets = Nicks.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.version = NoteVersion.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            origin_page: isSet(object.originPage)
+                ? BlockHeight.fromJSON(object.originPage)
+                : isSet(object.origin_page)
+                    ? BlockHeight.fromJSON(object.origin_page)
+                    : undefined,
+            timelock: isSet(object.timelock) ? TimeLockIntent.fromJSON(object.timelock) : undefined,
+            name: isSet(object.name) ? Name.fromJSON(object.name) : undefined,
+            lock: isSet(object.lock) ? Lock.fromJSON(object.lock) : undefined,
+            source: isSet(object.source) ? Source.fromJSON(object.source) : undefined,
+            assets: isSet(object.assets) ? Nicks.fromJSON(object.assets) : undefined,
+            version: isSet(object.version) ? NoteVersion.fromJSON(object.version) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.origin_page !== undefined) {
+            obj.originPage = BlockHeight.toJSON(message.origin_page);
+        }
+        if (message.timelock !== undefined) {
+            obj.timelock = TimeLockIntent.toJSON(message.timelock);
+        }
+        if (message.name !== undefined) {
+            obj.name = Name.toJSON(message.name);
+        }
+        if (message.lock !== undefined) {
+            obj.lock = Lock.toJSON(message.lock);
+        }
+        if (message.source !== undefined) {
+            obj.source = Source.toJSON(message.source);
+        }
+        if (message.assets !== undefined) {
+            obj.assets = Nicks.toJSON(message.assets);
+        }
+        if (message.version !== undefined) {
+            obj.version = NoteVersion.toJSON(message.version);
+        }
+        return obj;
+    },
+    create(base) {
+        return Note.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseNote();
+        message.origin_page = (object.origin_page !== undefined && object.origin_page !== null)
+            ? BlockHeight.fromPartial(object.origin_page)
+            : undefined;
+        message.timelock = (object.timelock !== undefined && object.timelock !== null)
+            ? TimeLockIntent.fromPartial(object.timelock)
+            : undefined;
+        message.name = (object.name !== undefined && object.name !== null) ? Name.fromPartial(object.name) : undefined;
+        message.lock = (object.lock !== undefined && object.lock !== null) ? Lock.fromPartial(object.lock) : undefined;
+        message.source = (object.source !== undefined && object.source !== null)
+            ? Source.fromPartial(object.source)
+            : undefined;
+        message.assets = (object.assets !== undefined && object.assets !== null)
+            ? Nicks.fromPartial(object.assets)
+            : undefined;
+        message.version = (object.version !== undefined && object.version !== null)
+            ? NoteVersion.fromPartial(object.version)
+            : undefined;
+        return message;
+    },
+};
+function createBaseSignature() {
+    return { entries: [] };
+}
+export const Signature = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.entries) {
+            SignatureEntry.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 = createBaseSignature();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.entries.push(SignatureEntry.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) => SignatureEntry.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.entries?.length) {
+            obj.entries = message.entries.map((e) => SignatureEntry.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return Signature.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSignature();
+        message.entries = object.entries?.map((e) => SignatureEntry.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseSignatureEntry() {
+    return { schnorr_pubkey: undefined, signature: undefined };
+}
+export const SignatureEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.schnorr_pubkey !== undefined) {
+            SchnorrPubkey.encode(message.schnorr_pubkey, writer.uint32(10).fork()).join();
+        }
+        if (message.signature !== undefined) {
+            SchnorrSignature.encode(message.signature, 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 = createBaseSignatureEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.schnorr_pubkey = SchnorrPubkey.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        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 {
+            schnorr_pubkey: isSet(object.schnorrPubkey)
+                ? SchnorrPubkey.fromJSON(object.schnorrPubkey)
+                : isSet(object.schnorr_pubkey)
+                    ? SchnorrPubkey.fromJSON(object.schnorr_pubkey)
+                    : undefined,
+            signature: isSet(object.signature) ? SchnorrSignature.fromJSON(object.signature) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.schnorr_pubkey !== undefined) {
+            obj.schnorrPubkey = SchnorrPubkey.toJSON(message.schnorr_pubkey);
+        }
+        if (message.signature !== undefined) {
+            obj.signature = SchnorrSignature.toJSON(message.signature);
+        }
+        return obj;
+    },
+    create(base) {
+        return SignatureEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSignatureEntry();
+        message.schnorr_pubkey = (object.schnorr_pubkey !== undefined && object.schnorr_pubkey !== null)
+            ? SchnorrPubkey.fromPartial(object.schnorr_pubkey)
+            : undefined;
+        message.signature = (object.signature !== undefined && object.signature !== null)
+            ? SchnorrSignature.fromPartial(object.signature)
+            : undefined;
+        return message;
+    },
+};
+function createBaseSchnorrSignature() {
+    return { chal: undefined, sig: undefined };
+}
+export const SchnorrSignature = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.chal !== undefined) {
+            EightBelt.encode(message.chal, writer.uint32(10).fork()).join();
+        }
+        if (message.sig !== undefined) {
+            EightBelt.encode(message.sig, 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 = createBaseSchnorrSignature();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.chal = EightBelt.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.sig = EightBelt.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            chal: isSet(object.chal) ? EightBelt.fromJSON(object.chal) : undefined,
+            sig: isSet(object.sig) ? EightBelt.fromJSON(object.sig) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.chal !== undefined) {
+            obj.chal = EightBelt.toJSON(message.chal);
+        }
+        if (message.sig !== undefined) {
+            obj.sig = EightBelt.toJSON(message.sig);
+        }
+        return obj;
+    },
+    create(base) {
+        return SchnorrSignature.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSchnorrSignature();
+        message.chal = (object.chal !== undefined && object.chal !== null) ? EightBelt.fromPartial(object.chal) : undefined;
+        message.sig = (object.sig !== undefined && object.sig !== null) ? EightBelt.fromPartial(object.sig) : undefined;
+        return message;
+    },
+};
+function isSet(value) {
+    return value !== null && value !== undefined;
+}
+//# sourceMappingURL=blockchain.js.map