@wireio/opp-solidity-models 1.0.6 → 1.0.8

package/sysio/opp/types/types.js

@@ -0,0 +1,666 @@
+import { WireType } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+// ---------------------------------------------------------------------------
+//  Chain identifier
+// ---------------------------------------------------------------------------
+/**
+ * @generated from protobuf enum sysio.opp.types.ChainKind
+ */
+export var ChainKind;
+(function (ChainKind) {
+    /**
+     * @generated from protobuf enum value: CHAIN_KIND_UNKNOWN = 0;
+     */
+    ChainKind[ChainKind["UNKNOWN"] = 0] = "UNKNOWN";
+    /**
+     * @generated from protobuf enum value: CHAIN_KIND_WIRE = 1;
+     */
+    ChainKind[ChainKind["WIRE"] = 1] = "WIRE";
+    /**
+     * @generated from protobuf enum value: CHAIN_KIND_ETHEREUM = 2;
+     */
+    ChainKind[ChainKind["ETHEREUM"] = 2] = "ETHEREUM";
+    /**
+     * @generated from protobuf enum value: CHAIN_KIND_SOLANA = 3;
+     */
+    ChainKind[ChainKind["SOLANA"] = 3] = "SOLANA";
+    /**
+     * @generated from protobuf enum value: CHAIN_KIND_SUI = 4;
+     */
+    ChainKind[ChainKind["SUI"] = 4] = "SUI";
+})(ChainKind || (ChainKind = {}));
+/**
+ * @generated from protobuf enum sysio.opp.types.ChainKeyType
+ */
+export var ChainKeyType;
+(function (ChainKeyType) {
+    /**
+     * @generated from protobuf enum value: CHAIN_KEY_TYPE_UNKNOWN = 0;
+     */
+    ChainKeyType[ChainKeyType["UNKNOWN"] = 0] = "UNKNOWN";
+    /**
+     * @generated from protobuf enum value: CHAIN_KEY_TYPE_WIRE = 1;
+     */
+    ChainKeyType[ChainKeyType["WIRE"] = 1] = "WIRE";
+    /**
+     * @generated from protobuf enum value: CHAIN_KEY_TYPE_WIRE_BLS = 2;
+     */
+    ChainKeyType[ChainKeyType["WIRE_BLS"] = 2] = "WIRE_BLS";
+    /**
+     * @generated from protobuf enum value: CHAIN_KEY_TYPE_ETHEREUM = 3;
+     */
+    ChainKeyType[ChainKeyType["ETHEREUM"] = 3] = "ETHEREUM";
+    /**
+     * @generated from protobuf enum value: CHAIN_KEY_TYPE_SOLANA = 4;
+     */
+    ChainKeyType[ChainKeyType["SOLANA"] = 4] = "SOLANA";
+    /**
+     * @generated from protobuf enum value: CHAIN_KEY_TYPE_SUI = 5;
+     */
+    ChainKeyType[ChainKeyType["SUI"] = 5] = "SUI";
+})(ChainKeyType || (ChainKeyType = {}));
+/**
+ * Token identifier (upper byte encodes chain family).
+ *
+ * @generated from protobuf enum sysio.opp.types.TokenKind
+ */
+export var TokenKind;
+(function (TokenKind) {
+    /**
+     * 0x0000
+     *
+     * @generated from protobuf enum value: TOKEN_KIND_WIRE = 0;
+     */
+    TokenKind[TokenKind["WIRE"] = 0] = "WIRE";
+    /**
+     * 0x0100
+     *
+     * @generated from protobuf enum value: TOKEN_KIND_ETH = 256;
+     */
+    TokenKind[TokenKind["ETH"] = 256] = "ETH";
+    /**
+     * 0x01F0
+     *
+     * @generated from protobuf enum value: TOKEN_KIND_LIQETH = 496;
+     */
+    TokenKind[TokenKind["LIQETH"] = 496] = "LIQETH";
+    /**
+     * 0x0200
+     *
+     * @generated from protobuf enum value: TOKEN_KIND_SOL = 512;
+     */
+    TokenKind[TokenKind["SOL"] = 512] = "SOL";
+    /**
+     * 0x02F0
+     *
+     * @generated from protobuf enum value: TOKEN_KIND_LIQSOL = 752;
+     */
+    TokenKind[TokenKind["LIQSOL"] = 752] = "LIQSOL";
+})(TokenKind || (TokenKind = {}));
+// ---------------------------------------------------------------------------
+//  Encoding flags  (originally a single uint8 bitfield)
+// 
+//  Decomposed into discrete fields for protobuf compatibility.
+//  Wire-format packing: endianness | (hash_algorithm << 1)
+//                       | (length_encoding << 3) | reserved
+// ---------------------------------------------------------------------------
+/**
+ * @generated from protobuf enum sysio.opp.types.Endianness
+ */
+export var Endianness;
+(function (Endianness) {
+    /**
+     * 0x00
+     *
+     * @generated from protobuf enum value: ENDIANNESS_BIG = 0;
+     */
+    Endianness[Endianness["BIG"] = 0] = "BIG";
+    /**
+     * 0x01
+     *
+     * @generated from protobuf enum value: ENDIANNESS_LITTLE = 1;
+     */
+    Endianness[Endianness["LITTLE"] = 1] = "LITTLE";
+})(Endianness || (Endianness = {}));
+/**
+ * @generated from protobuf enum sysio.opp.types.HashAlgorithm
+ */
+export var HashAlgorithm;
+(function (HashAlgorithm) {
+    /**
+     * bits[2:1] = 00
+     *
+     * @generated from protobuf enum value: HASH_ALGORITHM_KECCAK256 = 0;
+     */
+    HashAlgorithm[HashAlgorithm["KECCAK256"] = 0] = "KECCAK256";
+    /**
+     * bits[2:1] = 01
+     *
+     * @generated from protobuf enum value: HASH_ALGORITHM_SHA256 = 1;
+     */
+    HashAlgorithm[HashAlgorithm["SHA256"] = 1] = "SHA256";
+    /**
+     * bits[2:1] = 10
+     *
+     * @generated from protobuf enum value: HASH_ALGORITHM_RESERVED_1 = 2;
+     */
+    HashAlgorithm[HashAlgorithm["RESERVED_1"] = 2] = "RESERVED_1";
+    /**
+     * bits[2:1] = 11
+     *
+     * @generated from protobuf enum value: HASH_ALGORITHM_RESERVED_2 = 3;
+     */
+    HashAlgorithm[HashAlgorithm["RESERVED_2"] = 3] = "RESERVED_2";
+})(HashAlgorithm || (HashAlgorithm = {}));
+/**
+ * @generated from protobuf enum sysio.opp.types.LengthEncoding
+ */
+export var LengthEncoding;
+(function (LengthEncoding) {
+    /**
+     * bit[3] = 0
+     *
+     * @generated from protobuf enum value: LENGTH_ENCODING_VARUINT = 0;
+     */
+    LengthEncoding[LengthEncoding["VARUINT"] = 0] = "VARUINT";
+    /**
+     * bit[3] = 1
+     *
+     * @generated from protobuf enum value: LENGTH_ENCODING_UINT32 = 1;
+     */
+    LengthEncoding[LengthEncoding["UINT32"] = 1] = "UINT32";
+})(LengthEncoding || (LengthEncoding = {}));
+// ---------------------------------------------------------------------------
+//  Attestation discriminant
+// ---------------------------------------------------------------------------
+/**
+ * @generated from protobuf enum sysio.opp.types.AttestationType
+ */
+export var AttestationType;
+(function (AttestationType) {
+    /**
+     * @generated from protobuf enum value: ATTESTATION_TYPE_UNSPECIFIED = 0;
+     */
+    AttestationType[AttestationType["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * 0x0BB9
+     *
+     * @generated from protobuf enum value: ATTESTATION_TYPE_OPERATOR_ACTION = 2001;
+     */
+    AttestationType[AttestationType["OPERATOR_ACTION"] = 2001] = "OPERATOR_ACTION";
+    /**
+     * 0x0BB9
+     *
+     * @generated from protobuf enum value: ATTESTATION_TYPE_STAKE = 3001;
+     */
+    AttestationType[AttestationType["STAKE"] = 3001] = "STAKE";
+    /**
+     * 0x0BBA
+     *
+     * @generated from protobuf enum value: ATTESTATION_TYPE_UNSTAKE = 3002;
+     */
+    AttestationType[AttestationType["UNSTAKE"] = 3002] = "UNSTAKE";
+    /**
+     * 0x0BBB
+     *
+     * @generated from protobuf enum value: ATTESTATION_TYPE_PRETOKEN_PURCHASE = 3004;
+     */
+    AttestationType[AttestationType["PRETOKEN_PURCHASE"] = 3004] = "PRETOKEN_PURCHASE";
+    /**
+     * 0x0BBE
+     *
+     * @generated from protobuf enum value: ATTESTATION_TYPE_PRETOKEN_YIELD = 3006;
+     */
+    AttestationType[AttestationType["PRETOKEN_YIELD"] = 3006] = "PRETOKEN_YIELD";
+    /**
+     * 0xAA00
+     *
+     * @generated from protobuf enum value: ATTESTATION_TYPE_RESERVE_BALANCE_SHEET = 43520;
+     */
+    AttestationType[AttestationType["RESERVE_BALANCE_SHEET"] = 43520] = "RESERVE_BALANCE_SHEET";
+    /**
+     * 0xEE00
+     *
+     * @generated from protobuf enum value: ATTESTATION_TYPE_STAKE_UPDATE = 60928;
+     */
+    AttestationType[AttestationType["STAKE_UPDATE"] = 60928] = "STAKE_UPDATE";
+    /**
+     * 0xEE01
+     *
+     * @generated from protobuf enum value: ATTESTATION_TYPE_NATIVE_YIELD_REWARD = 60929;
+     */
+    AttestationType[AttestationType["NATIVE_YIELD_REWARD"] = 60929] = "NATIVE_YIELD_REWARD";
+    /**
+     * 0xEE02
+     *
+     * @generated from protobuf enum value: ATTESTATION_TYPE_WIRE_TOKEN_PURCHASE = 60930;
+     */
+    AttestationType[AttestationType["WIRE_TOKEN_PURCHASE"] = 60930] = "WIRE_TOKEN_PURCHASE";
+    /**
+     * 0xEE03
+     *
+     * @generated from protobuf enum value: ATTESTATION_TYPE_OPERATOR_REG_DEREG = 60931;
+     */
+    AttestationType[AttestationType["OPERATOR_REG_DEREG"] = 60931] = "OPERATOR_REG_DEREG";
+    /**
+     * 0xEE04
+     *
+     * @generated from protobuf enum value: ATTESTATION_TYPE_CHALLENGE_RESPONSE = 60932;
+     */
+    AttestationType[AttestationType["CHALLENGE_RESPONSE"] = 60932] = "CHALLENGE_RESPONSE";
+    /**
+     * 0xEE05
+     *
+     * @generated from protobuf enum value: ATTESTATION_TYPE_SLASH_OPERATOR = 60933;
+     */
+    AttestationType[AttestationType["SLASH_OPERATOR"] = 60933] = "SLASH_OPERATOR";
+})(AttestationType || (AttestationType = {}));
+// ---------------------------------------------------------------------------
+//  Staker / Operator lifecycle
+// ---------------------------------------------------------------------------
+/**
+ * @generated from protobuf enum sysio.opp.types.StakeStatus
+ */
+export var StakeStatus;
+(function (StakeStatus) {
+    /**
+     * @generated from protobuf enum value: STAKE_STATUS_UNKNOWN = 0;
+     */
+    StakeStatus[StakeStatus["UNKNOWN"] = 0] = "UNKNOWN";
+    /**
+     * 0x01
+     *
+     * @generated from protobuf enum value: STAKE_STATUS_WARMUP = 1;
+     */
+    StakeStatus[StakeStatus["WARMUP"] = 1] = "WARMUP";
+    /**
+     * 0x02
+     *
+     * @generated from protobuf enum value: STAKE_STATUS_COOLDOWN = 2;
+     */
+    StakeStatus[StakeStatus["COOLDOWN"] = 2] = "COOLDOWN";
+    /**
+     * 0x03
+     *
+     * @generated from protobuf enum value: STAKE_STATUS_ACTIVE = 3;
+     */
+    StakeStatus[StakeStatus["ACTIVE"] = 3] = "ACTIVE";
+    /**
+     * 0xF0
+     *
+     * @generated from protobuf enum value: STAKE_STATUS_TERMINATED = 240;
+     */
+    StakeStatus[StakeStatus["TERMINATED"] = 240] = "TERMINATED";
+    /**
+     * 0xF1
+     *
+     * @generated from protobuf enum value: STAKE_STATUS_SLASHED = 241;
+     */
+    StakeStatus[StakeStatus["SLASHED"] = 241] = "SLASHED";
+})(StakeStatus || (StakeStatus = {}));
+/**
+ * @generated from protobuf enum sysio.opp.types.OperatorType
+ */
+export var OperatorType;
+(function (OperatorType) {
+    /**
+     * @generated from protobuf enum value: OPERATOR_TYPE_UNKNOWN = 0;
+     */
+    OperatorType[OperatorType["UNKNOWN"] = 0] = "UNKNOWN";
+    /**
+     * 0x01
+     *
+     * @generated from protobuf enum value: OPERATOR_TYPE_PRODUCER = 1;
+     */
+    OperatorType[OperatorType["PRODUCER"] = 1] = "PRODUCER";
+    /**
+     * 0x02
+     *
+     * @generated from protobuf enum value: OPERATOR_TYPE_BATCH = 2;
+     */
+    OperatorType[OperatorType["BATCH"] = 2] = "BATCH";
+    /**
+     * 0x03
+     *
+     * @generated from protobuf enum value: OPERATOR_TYPE_UNDERWRITER = 3;
+     */
+    OperatorType[OperatorType["UNDERWRITER"] = 3] = "UNDERWRITER";
+    /**
+     * 0x04
+     *
+     * @generated from protobuf enum value: OPERATOR_TYPE_CHALLENGER = 4;
+     */
+    OperatorType[OperatorType["CHALLENGER"] = 4] = "CHALLENGER";
+})(OperatorType || (OperatorType = {}));
+/**
+ * @generated from protobuf enum sysio.opp.types.OperatorStatus
+ */
+export var OperatorStatus;
+(function (OperatorStatus) {
+    /**
+     * @generated from protobuf enum value: OPERATOR_STATUS_UNKNOWN = 0;
+     */
+    OperatorStatus[OperatorStatus["UNKNOWN"] = 0] = "UNKNOWN";
+    /**
+     * 0x01
+     *
+     * @generated from protobuf enum value: OPERATOR_STATUS_WARMUP = 1;
+     */
+    OperatorStatus[OperatorStatus["WARMUP"] = 1] = "WARMUP";
+    /**
+     * 0x02
+     *
+     * @generated from protobuf enum value: OPERATOR_STATUS_COOLDOWN = 2;
+     */
+    OperatorStatus[OperatorStatus["COOLDOWN"] = 2] = "COOLDOWN";
+    /**
+     * 0x03
+     *
+     * @generated from protobuf enum value: OPERATOR_STATUS_ACTIVE = 3;
+     */
+    OperatorStatus[OperatorStatus["ACTIVE"] = 3] = "ACTIVE";
+    /**
+     * 0xF0
+     *
+     * @generated from protobuf enum value: OPERATOR_STATUS_TERMINATED = 240;
+     */
+    OperatorStatus[OperatorStatus["TERMINATED"] = 240] = "TERMINATED";
+    /**
+     * 0xF1
+     *
+     * @generated from protobuf enum value: OPERATOR_STATUS_SLASHED = 241;
+     */
+    OperatorStatus[OperatorStatus["SLASHED"] = 241] = "SLASHED";
+})(OperatorStatus || (OperatorStatus = {}));
+// @generated message type with reflection information, may provide speed optimized methods
+class ChainId$Type extends MessageType {
+    constructor() {
+        super("sysio.opp.types.ChainId", [
+            { no: 1, name: "kind", kind: "enum", T: () => ["sysio.opp.types.ChainKind", ChainKind, "CHAIN_KIND_"] },
+            { no: 2, name: "id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.kind = 0;
+        message.id = 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.ChainKind kind */ 1:
+                    message.kind = reader.int32();
+                    break;
+                case /* uint32 id */ 2:
+                    message.id = reader.uint32();
+                    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);
+        /* uint32 id = 2; */
+        if (message.id !== 0)
+            writer.tag(2, WireType.Varint).uint32(message.id);
+        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.types.ChainId
+ */
+export const ChainId = new ChainId$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ChainAddress$Type extends MessageType {
+    constructor() {
+        super("sysio.opp.types.ChainAddress", [
+            { no: 1, name: "kind", kind: "enum", T: () => ["sysio.opp.types.ChainKind", ChainKind, "CHAIN_KIND_"] },
+            { no: 2, name: "address", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.kind = 0;
+        message.address = new Uint8Array(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.ChainKind kind */ 1:
+                    message.kind = reader.int32();
+                    break;
+                case /* bytes address */ 2:
+                    message.address = reader.bytes();
+                    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);
+        /* bytes address = 2; */
+        if (message.address.length)
+            writer.tag(2, WireType.LengthDelimited).bytes(message.address);
+        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.types.ChainAddress
+ */
+export const ChainAddress = new ChainAddress$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ChainSignature$Type extends MessageType {
+    constructor() {
+        super("sysio.opp.types.ChainSignature", [
+            { no: 1, name: "actor", kind: "message", T: () => ChainAddress },
+            { no: 2, name: "key_type", kind: "enum", T: () => ["sysio.opp.types.ChainKeyType", ChainKeyType, "CHAIN_KEY_TYPE_"] },
+            { no: 3, name: "signature", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.keyType = 0;
+        message.signature = new Uint8Array(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.ChainKeyType key_type */ 2:
+                    message.keyType = reader.int32();
+                    break;
+                case /* bytes signature */ 3:
+                    message.signature = reader.bytes();
+                    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.ChainKeyType key_type = 2; */
+        if (message.keyType !== 0)
+            writer.tag(2, WireType.Varint).int32(message.keyType);
+        /* bytes signature = 3; */
+        if (message.signature.length)
+            writer.tag(3, WireType.LengthDelimited).bytes(message.signature);
+        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.types.ChainSignature
+ */
+export const ChainSignature = new ChainSignature$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TokenAmount$Type extends MessageType {
+    constructor() {
+        super("sysio.opp.types.TokenAmount", [
+            { no: 1, name: "kind", kind: "enum", T: () => ["sysio.opp.types.TokenKind", TokenKind, "TOKEN_KIND_"] },
+            { no: 2, name: "amount", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.kind = 0;
+        message.amount = 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.TokenKind kind */ 1:
+                    message.kind = reader.int32();
+                    break;
+                case /* int64 amount */ 2:
+                    message.amount = 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.TokenKind kind = 1; */
+        if (message.kind !== 0)
+            writer.tag(1, WireType.Varint).int32(message.kind);
+        /* int64 amount = 2; */
+        if (message.amount !== 0n)
+            writer.tag(2, WireType.Varint).int64(message.amount);
+        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.types.TokenAmount
+ */
+export const TokenAmount = new TokenAmount$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class EncodingFlags$Type extends MessageType {
+    constructor() {
+        super("sysio.opp.types.EncodingFlags", [
+            { no: 1, name: "endianness", kind: "enum", T: () => ["sysio.opp.types.Endianness", Endianness, "ENDIANNESS_"] },
+            { no: 2, name: "hash_algorithm", kind: "enum", T: () => ["sysio.opp.types.HashAlgorithm", HashAlgorithm, "HASH_ALGORITHM_"] },
+            { no: 3, name: "length_encoding", kind: "enum", T: () => ["sysio.opp.types.LengthEncoding", LengthEncoding, "LENGTH_ENCODING_"] }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.endianness = 0;
+        message.hashAlgorithm = 0;
+        message.lengthEncoding = 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.Endianness endianness */ 1:
+                    message.endianness = reader.int32();
+                    break;
+                case /* sysio.opp.types.HashAlgorithm hash_algorithm */ 2:
+                    message.hashAlgorithm = reader.int32();
+                    break;
+                case /* sysio.opp.types.LengthEncoding length_encoding */ 3:
+                    message.lengthEncoding = reader.int32();
+                    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.Endianness endianness = 1; */
+        if (message.endianness !== 0)
+            writer.tag(1, WireType.Varint).int32(message.endianness);
+        /* sysio.opp.types.HashAlgorithm hash_algorithm = 2; */
+        if (message.hashAlgorithm !== 0)
+            writer.tag(2, WireType.Varint).int32(message.hashAlgorithm);
+        /* sysio.opp.types.LengthEncoding length_encoding = 3; */
+        if (message.lengthEncoding !== 0)
+            writer.tag(3, WireType.Varint).int32(message.lengthEncoding);
+        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.types.EncodingFlags
+ */
+export const EncodingFlags = new EncodingFlags$Type();