@wireio/opp-solidity-models 1.0.6 → 1.0.7

package/sysio/opp/attestations/attestations.js

@@ -0,0 +1,670 @@
+import { WireType } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { ChainId } from "../types/types";
+import { Message } from "../opp";
+import { ChainSignature } from "../types/types";
+import { OperatorStatus } from "../types/types";
+import { OperatorType } from "../types/types";
+import { StakeStatus } from "../types/types";
+import { ChainAddress } from "../types/types";
+import { TokenAmount } from "../types/types";
+import { ChainKind } from "../types/types";
+/**
+ * @generated from protobuf enum sysio.opp.attestations.OperatorAction.ActionType
+ */
+export var OperatorAction_ActionType;
+(function (OperatorAction_ActionType) {
+    /**
+     * @generated from protobuf enum value: ACTION_TYPE_UNKNOWN = 0;
+     */
+    OperatorAction_ActionType[OperatorAction_ActionType["UNKNOWN"] = 0] = "UNKNOWN";
+    /**
+     * @generated from protobuf enum value: ACTION_TYPE_DEPOSIT = 1;
+     */
+    OperatorAction_ActionType[OperatorAction_ActionType["DEPOSIT"] = 1] = "DEPOSIT";
+    /**
+     * @generated from protobuf enum value: ACTION_TYPE_WITHDRAW = 2;
+     */
+    OperatorAction_ActionType[OperatorAction_ActionType["WITHDRAW"] = 2] = "WITHDRAW";
+})(OperatorAction_ActionType || (OperatorAction_ActionType = {}));
+// @generated message type with reflection information, may provide speed optimized methods
+class ChainReserveBalanceSheet$Type extends MessageType {
+    constructor() {
+        super("sysio.opp.attestations.ChainReserveBalanceSheet", [
+            { no: 1, name: "kind", kind: "enum", T: () => ["sysio.opp.types.ChainKind", ChainKind, "CHAIN_KIND_"] },
+            { no: 2, name: "amounts", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => TokenAmount }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.kind = 0;
+        message.amounts = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* sysio.opp.types.ChainKind kind */ 1:
+                    message.kind = reader.int32();
+                    break;
+                case /* repeated sysio.opp.types.TokenAmount amounts */ 2:
+                    message.amounts.push(TokenAmount.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* sysio.opp.types.ChainKind kind = 1; */
+        if (message.kind !== 0)
+            writer.tag(1, WireType.Varint).int32(message.kind);
+        /* repeated sysio.opp.types.TokenAmount amounts = 2; */
+        for (let i = 0; i < message.amounts.length; i++)
+            TokenAmount.internalBinaryWrite(message.amounts[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message sysio.opp.attestations.ChainReserveBalanceSheet
+ */
+export const ChainReserveBalanceSheet = new ChainReserveBalanceSheet$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PretokenStakeChange$Type extends MessageType {
+    constructor() {
+        super("sysio.opp.attestations.PretokenStakeChange", [
+            { no: 1, name: "actor", kind: "message", T: () => ChainAddress },
+            { no: 2, name: "amount", kind: "message", T: () => TokenAmount },
+            { no: 10, name: "index_at_mint", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 11, name: "index_at_burn", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.indexAtMint = 0n;
+        message.indexAtBurn = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* sysio.opp.types.ChainAddress actor */ 1:
+                    message.actor = ChainAddress.internalBinaryRead(reader, reader.uint32(), options, message.actor);
+                    break;
+                case /* sysio.opp.types.TokenAmount amount */ 2:
+                    message.amount = TokenAmount.internalBinaryRead(reader, reader.uint32(), options, message.amount);
+                    break;
+                case /* int64 index_at_mint */ 10:
+                    message.indexAtMint = reader.int64().toBigInt();
+                    break;
+                case /* int64 index_at_burn */ 11:
+                    message.indexAtBurn = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* sysio.opp.types.ChainAddress actor = 1; */
+        if (message.actor)
+            ChainAddress.internalBinaryWrite(message.actor, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* sysio.opp.types.TokenAmount amount = 2; */
+        if (message.amount)
+            TokenAmount.internalBinaryWrite(message.amount, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* int64 index_at_mint = 10; */
+        if (message.indexAtMint !== 0n)
+            writer.tag(10, WireType.Varint).int64(message.indexAtMint);
+        /* int64 index_at_burn = 11; */
+        if (message.indexAtBurn !== 0n)
+            writer.tag(11, WireType.Varint).int64(message.indexAtBurn);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message sysio.opp.attestations.PretokenStakeChange
+ */
+export const PretokenStakeChange = new PretokenStakeChange$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PretokenPurchase$Type extends MessageType {
+    constructor() {
+        super("sysio.opp.attestations.PretokenPurchase", [
+            { no: 1, name: "actor", kind: "message", T: () => ChainAddress },
+            { no: 2, name: "amount", kind: "message", T: () => TokenAmount },
+            { no: 3, name: "pretoken_count", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 10, name: "index_at_mint", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.pretokenCount = 0n;
+        message.indexAtMint = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* sysio.opp.types.ChainAddress actor */ 1:
+                    message.actor = ChainAddress.internalBinaryRead(reader, reader.uint32(), options, message.actor);
+                    break;
+                case /* sysio.opp.types.TokenAmount amount */ 2:
+                    message.amount = TokenAmount.internalBinaryRead(reader, reader.uint32(), options, message.amount);
+                    break;
+                case /* int64 pretoken_count */ 3:
+                    message.pretokenCount = reader.int64().toBigInt();
+                    break;
+                case /* int64 index_at_mint */ 10:
+                    message.indexAtMint = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* sysio.opp.types.ChainAddress actor = 1; */
+        if (message.actor)
+            ChainAddress.internalBinaryWrite(message.actor, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* sysio.opp.types.TokenAmount amount = 2; */
+        if (message.amount)
+            TokenAmount.internalBinaryWrite(message.amount, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* int64 pretoken_count = 3; */
+        if (message.pretokenCount !== 0n)
+            writer.tag(3, WireType.Varint).int64(message.pretokenCount);
+        /* int64 index_at_mint = 10; */
+        if (message.indexAtMint !== 0n)
+            writer.tag(10, WireType.Varint).int64(message.indexAtMint);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message sysio.opp.attestations.PretokenPurchase
+ */
+export const PretokenPurchase = new PretokenPurchase$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PretokenYield$Type extends MessageType {
+    constructor() {
+        super("sysio.opp.attestations.PretokenYield", [
+            { no: 1, name: "actor", kind: "message", T: () => ChainAddress },
+            { no: 2, name: "amount", kind: "message", T: () => TokenAmount },
+            { no: 3, name: "index_at_mint", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.indexAtMint = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* sysio.opp.types.ChainAddress actor */ 1:
+                    message.actor = ChainAddress.internalBinaryRead(reader, reader.uint32(), options, message.actor);
+                    break;
+                case /* sysio.opp.types.TokenAmount amount */ 2:
+                    message.amount = TokenAmount.internalBinaryRead(reader, reader.uint32(), options, message.amount);
+                    break;
+                case /* int64 index_at_mint */ 3:
+                    message.indexAtMint = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* sysio.opp.types.ChainAddress actor = 1; */
+        if (message.actor)
+            ChainAddress.internalBinaryWrite(message.actor, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* sysio.opp.types.TokenAmount amount = 2; */
+        if (message.amount)
+            TokenAmount.internalBinaryWrite(message.amount, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* int64 index_at_mint = 3; */
+        if (message.indexAtMint !== 0n)
+            writer.tag(3, WireType.Varint).int64(message.indexAtMint);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message sysio.opp.attestations.PretokenYield
+ */
+export const PretokenYield = new PretokenYield$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StakeUpdate$Type extends MessageType {
+    constructor() {
+        super("sysio.opp.attestations.StakeUpdate", [
+            { no: 1, name: "actor", kind: "message", T: () => ChainAddress },
+            { no: 2, name: "status", kind: "enum", T: () => ["sysio.opp.types.StakeStatus", StakeStatus, "STAKE_STATUS_"] },
+            { no: 3, name: "amount", kind: "message", T: () => TokenAmount }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.status = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* sysio.opp.types.ChainAddress actor */ 1:
+                    message.actor = ChainAddress.internalBinaryRead(reader, reader.uint32(), options, message.actor);
+                    break;
+                case /* sysio.opp.types.StakeStatus status */ 2:
+                    message.status = reader.int32();
+                    break;
+                case /* sysio.opp.types.TokenAmount amount */ 3:
+                    message.amount = TokenAmount.internalBinaryRead(reader, reader.uint32(), options, message.amount);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* sysio.opp.types.ChainAddress actor = 1; */
+        if (message.actor)
+            ChainAddress.internalBinaryWrite(message.actor, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* sysio.opp.types.StakeStatus status = 2; */
+        if (message.status !== 0)
+            writer.tag(2, WireType.Varint).int32(message.status);
+        /* sysio.opp.types.TokenAmount amount = 3; */
+        if (message.amount)
+            TokenAmount.internalBinaryWrite(message.amount, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message sysio.opp.attestations.StakeUpdate
+ */
+export const StakeUpdate = new StakeUpdate$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class WireTokenPurchase$Type extends MessageType {
+    constructor() {
+        super("sysio.opp.attestations.WireTokenPurchase", [
+            { no: 1, name: "actor", kind: "message", T: () => ChainAddress },
+            { no: 2, name: "amounts", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => TokenAmount }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.amounts = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* sysio.opp.types.ChainAddress actor */ 1:
+                    message.actor = ChainAddress.internalBinaryRead(reader, reader.uint32(), options, message.actor);
+                    break;
+                case /* repeated sysio.opp.types.TokenAmount amounts */ 2:
+                    message.amounts.push(TokenAmount.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* sysio.opp.types.ChainAddress actor = 1; */
+        if (message.actor)
+            ChainAddress.internalBinaryWrite(message.actor, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated sysio.opp.types.TokenAmount amounts = 2; */
+        for (let i = 0; i < message.amounts.length; i++)
+            TokenAmount.internalBinaryWrite(message.amounts[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message sysio.opp.attestations.WireTokenPurchase
+ */
+export const WireTokenPurchase = new WireTokenPurchase$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OperatorAction$Type extends MessageType {
+    constructor() {
+        super("sysio.opp.attestations.OperatorAction", [
+            { no: 1, name: "action_type", kind: "enum", T: () => ["sysio.opp.attestations.OperatorAction.ActionType", OperatorAction_ActionType, "ACTION_TYPE_"] },
+            { no: 2, name: "actor", kind: "message", T: () => ChainAddress },
+            { no: 3, name: "type", kind: "enum", T: () => ["sysio.opp.types.OperatorType", OperatorType, "OPERATOR_TYPE_"] },
+            { no: 4, name: "status", kind: "enum", T: () => ["sysio.opp.types.OperatorStatus", OperatorStatus, "OPERATOR_STATUS_"] },
+            { no: 10, name: "amount", kind: "message", T: () => TokenAmount }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.actionType = 0;
+        message.type = 0;
+        message.status = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* sysio.opp.attestations.OperatorAction.ActionType action_type */ 1:
+                    message.actionType = reader.int32();
+                    break;
+                case /* sysio.opp.types.ChainAddress actor */ 2:
+                    message.actor = ChainAddress.internalBinaryRead(reader, reader.uint32(), options, message.actor);
+                    break;
+                case /* sysio.opp.types.OperatorType type */ 3:
+                    message.type = reader.int32();
+                    break;
+                case /* sysio.opp.types.OperatorStatus status */ 4:
+                    message.status = reader.int32();
+                    break;
+                case /* sysio.opp.types.TokenAmount amount */ 10:
+                    message.amount = TokenAmount.internalBinaryRead(reader, reader.uint32(), options, message.amount);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* sysio.opp.attestations.OperatorAction.ActionType action_type = 1; */
+        if (message.actionType !== 0)
+            writer.tag(1, WireType.Varint).int32(message.actionType);
+        /* sysio.opp.types.ChainAddress actor = 2; */
+        if (message.actor)
+            ChainAddress.internalBinaryWrite(message.actor, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* sysio.opp.types.OperatorType type = 3; */
+        if (message.type !== 0)
+            writer.tag(3, WireType.Varint).int32(message.type);
+        /* sysio.opp.types.OperatorStatus status = 4; */
+        if (message.status !== 0)
+            writer.tag(4, WireType.Varint).int32(message.status);
+        /* sysio.opp.types.TokenAmount amount = 10; */
+        if (message.amount)
+            TokenAmount.internalBinaryWrite(message.amount, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message sysio.opp.attestations.OperatorAction
+ */
+export const OperatorAction = new OperatorAction$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReserveDisbursement$Type extends MessageType {
+    constructor() {
+        super("sysio.opp.attestations.ReserveDisbursement", [
+            { no: 1, name: "actor", kind: "message", T: () => ChainAddress },
+            { no: 2, name: "amount", kind: "message", T: () => TokenAmount },
+            { no: 3, name: "signature", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ChainSignature }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.signature = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* sysio.opp.types.ChainAddress actor */ 1:
+                    message.actor = ChainAddress.internalBinaryRead(reader, reader.uint32(), options, message.actor);
+                    break;
+                case /* sysio.opp.types.TokenAmount amount */ 2:
+                    message.amount = TokenAmount.internalBinaryRead(reader, reader.uint32(), options, message.amount);
+                    break;
+                case /* repeated sysio.opp.types.ChainSignature signature */ 3:
+                    message.signature.push(ChainSignature.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* sysio.opp.types.ChainAddress actor = 1; */
+        if (message.actor)
+            ChainAddress.internalBinaryWrite(message.actor, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* sysio.opp.types.TokenAmount amount = 2; */
+        if (message.amount)
+            TokenAmount.internalBinaryWrite(message.amount, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* repeated sysio.opp.types.ChainSignature signature = 3; */
+        for (let i = 0; i < message.signature.length; i++)
+            ChainSignature.internalBinaryWrite(message.signature[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message sysio.opp.attestations.ReserveDisbursement
+ */
+export const ReserveDisbursement = new ReserveDisbursement$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TimestampedMessage$Type extends MessageType {
+    constructor() {
+        super("sysio.opp.attestations.TimestampedMessage", [
+            { no: 1, name: "timestamp", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "message", kind: "message", T: () => Message }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.timestamp = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint64 timestamp */ 1:
+                    message.timestamp = reader.uint64().toBigInt();
+                    break;
+                case /* sysio.opp.Message message */ 2:
+                    message.message = Message.internalBinaryRead(reader, reader.uint32(), options, message.message);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* uint64 timestamp = 1; */
+        if (message.timestamp !== 0n)
+            writer.tag(1, WireType.Varint).uint64(message.timestamp);
+        /* sysio.opp.Message message = 2; */
+        if (message.message)
+            Message.internalBinaryWrite(message.message, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message sysio.opp.attestations.TimestampedMessage
+ */
+export const TimestampedMessage = new TimestampedMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ProtocolState$Type extends MessageType {
+    constructor() {
+        super("sysio.opp.attestations.ProtocolState", [
+            { no: 1, name: "chain_id", kind: "message", T: () => ChainId },
+            { no: 2, name: "current_message_id", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 3, name: "processed_message_id", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 4, name: "incoming_messages", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => TimestampedMessage },
+            { no: 5, name: "outgoing", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Message }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.currentMessageId = new Uint8Array(0);
+        message.processedMessageId = new Uint8Array(0);
+        message.incomingMessages = [];
+        message.outgoing = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* sysio.opp.types.ChainId chain_id */ 1:
+                    message.chainId = ChainId.internalBinaryRead(reader, reader.uint32(), options, message.chainId);
+                    break;
+                case /* bytes current_message_id */ 2:
+                    message.currentMessageId = reader.bytes();
+                    break;
+                case /* bytes processed_message_id */ 3:
+                    message.processedMessageId = reader.bytes();
+                    break;
+                case /* repeated sysio.opp.attestations.TimestampedMessage incoming_messages */ 4:
+                    message.incomingMessages.push(TimestampedMessage.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated sysio.opp.Message outgoing */ 5:
+                    message.outgoing.push(Message.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* sysio.opp.types.ChainId chain_id = 1; */
+        if (message.chainId)
+            ChainId.internalBinaryWrite(message.chainId, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* bytes current_message_id = 2; */
+        if (message.currentMessageId.length)
+            writer.tag(2, WireType.LengthDelimited).bytes(message.currentMessageId);
+        /* bytes processed_message_id = 3; */
+        if (message.processedMessageId.length)
+            writer.tag(3, WireType.LengthDelimited).bytes(message.processedMessageId);
+        /* repeated sysio.opp.attestations.TimestampedMessage incoming_messages = 4; */
+        for (let i = 0; i < message.incomingMessages.length; i++)
+            TimestampedMessage.internalBinaryWrite(message.incomingMessages[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* repeated sysio.opp.Message outgoing = 5; */
+        for (let i = 0; i < message.outgoing.length; i++)
+            Message.internalBinaryWrite(message.outgoing[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message sysio.opp.attestations.ProtocolState
+ */
+export const ProtocolState = new ProtocolState$Type();