@agoric/client-utils 0.1.1-dev-a29afed.0.a29afed → 0.1.1-dev-cb1866d.0.cb1866d

package/dist/codegen/agoric/swingset/swingset.js

@@ -5,6 +5,55 @@ import { isSet } from '../../helpers.js';
 import {} from '../../json-safe.js';
 import { decodeBase64 as bytesFromBase64 } from '@endo/base64';
 import { encodeBase64 as base64FromBytes } from '@endo/base64';
+/** Current state of this chunk. */
+export var ChunkState;
+(function (ChunkState) {
+    /** CHUNK_STATE_UNSPECIFIED - Unknown state. */
+    ChunkState[ChunkState["CHUNK_STATE_UNSPECIFIED"] = 0] = "CHUNK_STATE_UNSPECIFIED";
+    /** CHUNK_STATE_IN_FLIGHT - The chunk is still in-flight. */
+    ChunkState[ChunkState["CHUNK_STATE_IN_FLIGHT"] = 1] = "CHUNK_STATE_IN_FLIGHT";
+    /** CHUNK_STATE_RECEIVED - The chunk has been received. */
+    ChunkState[ChunkState["CHUNK_STATE_RECEIVED"] = 2] = "CHUNK_STATE_RECEIVED";
+    /** CHUNK_STATE_PROCESSED - The chunk has been processed. */
+    ChunkState[ChunkState["CHUNK_STATE_PROCESSED"] = 3] = "CHUNK_STATE_PROCESSED";
+    ChunkState[ChunkState["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ChunkState || (ChunkState = {}));
+export const ChunkStateSDKType = ChunkState;
+export function chunkStateFromJSON(object) {
+    switch (object) {
+        case 0:
+        case 'CHUNK_STATE_UNSPECIFIED':
+            return ChunkState.CHUNK_STATE_UNSPECIFIED;
+        case 1:
+        case 'CHUNK_STATE_IN_FLIGHT':
+            return ChunkState.CHUNK_STATE_IN_FLIGHT;
+        case 2:
+        case 'CHUNK_STATE_RECEIVED':
+            return ChunkState.CHUNK_STATE_RECEIVED;
+        case 3:
+        case 'CHUNK_STATE_PROCESSED':
+            return ChunkState.CHUNK_STATE_PROCESSED;
+        case -1:
+        case 'UNRECOGNIZED':
+        default:
+            return ChunkState.UNRECOGNIZED;
+    }
+}
+export function chunkStateToJSON(object) {
+    switch (object) {
+        case ChunkState.CHUNK_STATE_UNSPECIFIED:
+            return 'CHUNK_STATE_UNSPECIFIED';
+        case ChunkState.CHUNK_STATE_IN_FLIGHT:
+            return 'CHUNK_STATE_IN_FLIGHT';
+        case ChunkState.CHUNK_STATE_RECEIVED:
+            return 'CHUNK_STATE_RECEIVED';
+        case ChunkState.CHUNK_STATE_PROCESSED:
+            return 'CHUNK_STATE_PROCESSED';
+        case ChunkState.UNRECOGNIZED:
+        default:
+            return 'UNRECOGNIZED';
+    }
+}
 function createBaseCoreEvalProposal() {
     return {
         title: '',
@@ -168,6 +217,10 @@ function createBaseParams() {
         powerFlagFees: [],
         queueMax: [],
         vatCleanupBudget: [],
+        installationDeadlineBlocks: BigInt(0),
+        installationDeadlineSeconds: BigInt(0),
+        bundleUncompressedSizeLimitBytes: BigInt(0),
+        chunkSizeLimitBytes: BigInt(0),
     };
 }
 export const Params = {
@@ -191,6 +244,18 @@ export const Params = {
         for (const v of message.vatCleanupBudget) {
             UintMapEntry.encode(v, writer.uint32(50).fork()).ldelim();
         }
+        if (message.installationDeadlineBlocks !== BigInt(0)) {
+            writer.uint32(56).int64(message.installationDeadlineBlocks);
+        }
+        if (message.installationDeadlineSeconds !== BigInt(0)) {
+            writer.uint32(64).int64(message.installationDeadlineSeconds);
+        }
+        if (message.bundleUncompressedSizeLimitBytes !== BigInt(0)) {
+            writer.uint32(72).int64(message.bundleUncompressedSizeLimitBytes);
+        }
+        if (message.chunkSizeLimitBytes !== BigInt(0)) {
+            writer.uint32(80).int64(message.chunkSizeLimitBytes);
+        }
         return writer;
     },
     decode(input, length) {
@@ -218,6 +283,18 @@ export const Params = {
                 case 6:
                     message.vatCleanupBudget.push(UintMapEntry.decode(reader, reader.uint32()));
                     break;
+                case 7:
+                    message.installationDeadlineBlocks = reader.int64();
+                    break;
+                case 8:
+                    message.installationDeadlineSeconds = reader.int64();
+                    break;
+                case 9:
+                    message.bundleUncompressedSizeLimitBytes = reader.int64();
+                    break;
+                case 10:
+                    message.chunkSizeLimitBytes = reader.int64();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -245,6 +322,18 @@ export const Params = {
             vatCleanupBudget: Array.isArray(object?.vatCleanupBudget)
                 ? object.vatCleanupBudget.map((e) => UintMapEntry.fromJSON(e))
                 : [],
+            installationDeadlineBlocks: isSet(object.installationDeadlineBlocks)
+                ? BigInt(object.installationDeadlineBlocks.toString())
+                : BigInt(0),
+            installationDeadlineSeconds: isSet(object.installationDeadlineSeconds)
+                ? BigInt(object.installationDeadlineSeconds.toString())
+                : BigInt(0),
+            bundleUncompressedSizeLimitBytes: isSet(object.bundleUncompressedSizeLimitBytes)
+                ? BigInt(object.bundleUncompressedSizeLimitBytes.toString())
+                : BigInt(0),
+            chunkSizeLimitBytes: isSet(object.chunkSizeLimitBytes)
+                ? BigInt(object.chunkSizeLimitBytes.toString())
+                : BigInt(0),
         };
     },
     toJSON(message) {
@@ -281,6 +370,14 @@ export const Params = {
         else {
             obj.vatCleanupBudget = [];
         }
+        message.installationDeadlineBlocks !== undefined &&
+            (obj.installationDeadlineBlocks = (message.installationDeadlineBlocks || BigInt(0)).toString());
+        message.installationDeadlineSeconds !== undefined &&
+            (obj.installationDeadlineSeconds = (message.installationDeadlineSeconds || BigInt(0)).toString());
+        message.bundleUncompressedSizeLimitBytes !== undefined &&
+            (obj.bundleUncompressedSizeLimitBytes = (message.bundleUncompressedSizeLimitBytes || BigInt(0)).toString());
+        message.chunkSizeLimitBytes !== undefined &&
+            (obj.chunkSizeLimitBytes = (message.chunkSizeLimitBytes || BigInt(0)).toString());
         return obj;
     },
     fromPartial(object) {
@@ -296,6 +393,26 @@ export const Params = {
             object.queueMax?.map(e => QueueSize.fromPartial(e)) || [];
         message.vatCleanupBudget =
             object.vatCleanupBudget?.map(e => UintMapEntry.fromPartial(e)) || [];
+        message.installationDeadlineBlocks =
+            object.installationDeadlineBlocks !== undefined &&
+                object.installationDeadlineBlocks !== null
+                ? BigInt(object.installationDeadlineBlocks.toString())
+                : BigInt(0);
+        message.installationDeadlineSeconds =
+            object.installationDeadlineSeconds !== undefined &&
+                object.installationDeadlineSeconds !== null
+                ? BigInt(object.installationDeadlineSeconds.toString())
+                : BigInt(0);
+        message.bundleUncompressedSizeLimitBytes =
+            object.bundleUncompressedSizeLimitBytes !== undefined &&
+                object.bundleUncompressedSizeLimitBytes !== null
+                ? BigInt(object.bundleUncompressedSizeLimitBytes.toString())
+                : BigInt(0);
+        message.chunkSizeLimitBytes =
+            object.chunkSizeLimitBytes !== undefined &&
+                object.chunkSizeLimitBytes !== null
+                ? BigInt(object.chunkSizeLimitBytes.toString())
+                : BigInt(0);
         return message;
     },
     fromProtoMsg(message) {
@@ -314,6 +431,9 @@ export const Params = {
 function createBaseState() {
     return {
         queueAllowed: [],
+        firstChunkedArtifactId: BigInt(0),
+        lastChunkedArtifactId: BigInt(0),
+        nextChunkedArtifactId: BigInt(0),
     };
 }
 export const State = {
@@ -322,6 +442,15 @@ export const State = {
         for (const v of message.queueAllowed) {
             QueueSize.encode(v, writer.uint32(10).fork()).ldelim();
         }
+        if (message.firstChunkedArtifactId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.firstChunkedArtifactId);
+        }
+        if (message.lastChunkedArtifactId !== BigInt(0)) {
+            writer.uint32(24).uint64(message.lastChunkedArtifactId);
+        }
+        if (message.nextChunkedArtifactId !== BigInt(0)) {
+            writer.uint32(32).uint64(message.nextChunkedArtifactId);
+        }
         return writer;
     },
     decode(input, length) {
@@ -334,6 +463,15 @@ export const State = {
                 case 1:
                     message.queueAllowed.push(QueueSize.decode(reader, reader.uint32()));
                     break;
+                case 2:
+                    message.firstChunkedArtifactId = reader.uint64();
+                    break;
+                case 3:
+                    message.lastChunkedArtifactId = reader.uint64();
+                    break;
+                case 4:
+                    message.nextChunkedArtifactId = reader.uint64();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -346,6 +484,15 @@ export const State = {
             queueAllowed: Array.isArray(object?.queueAllowed)
                 ? object.queueAllowed.map((e) => QueueSize.fromJSON(e))
                 : [],
+            firstChunkedArtifactId: isSet(object.firstChunkedArtifactId)
+                ? BigInt(object.firstChunkedArtifactId.toString())
+                : BigInt(0),
+            lastChunkedArtifactId: isSet(object.lastChunkedArtifactId)
+                ? BigInt(object.lastChunkedArtifactId.toString())
+                : BigInt(0),
+            nextChunkedArtifactId: isSet(object.nextChunkedArtifactId)
+                ? BigInt(object.nextChunkedArtifactId.toString())
+                : BigInt(0),
         };
     },
     toJSON(message) {
@@ -356,12 +503,33 @@ export const State = {
         else {
             obj.queueAllowed = [];
         }
+        message.firstChunkedArtifactId !== undefined &&
+            (obj.firstChunkedArtifactId = (message.firstChunkedArtifactId || BigInt(0)).toString());
+        message.lastChunkedArtifactId !== undefined &&
+            (obj.lastChunkedArtifactId = (message.lastChunkedArtifactId || BigInt(0)).toString());
+        message.nextChunkedArtifactId !== undefined &&
+            (obj.nextChunkedArtifactId = (message.nextChunkedArtifactId || BigInt(0)).toString());
         return obj;
     },
     fromPartial(object) {
         const message = createBaseState();
         message.queueAllowed =
             object.queueAllowed?.map(e => QueueSize.fromPartial(e)) || [];
+        message.firstChunkedArtifactId =
+            object.firstChunkedArtifactId !== undefined &&
+                object.firstChunkedArtifactId !== null
+                ? BigInt(object.firstChunkedArtifactId.toString())
+                : BigInt(0);
+        message.lastChunkedArtifactId =
+            object.lastChunkedArtifactId !== undefined &&
+                object.lastChunkedArtifactId !== null
+                ? BigInt(object.lastChunkedArtifactId.toString())
+                : BigInt(0);
+        message.nextChunkedArtifactId =
+            object.nextChunkedArtifactId !== undefined &&
+                object.nextChunkedArtifactId !== null
+                ? BigInt(object.nextChunkedArtifactId.toString())
+                : BigInt(0);
         return message;
     },
     fromProtoMsg(message) {
@@ -815,4 +983,309 @@ export const SwingStoreArtifact = {
         };
     },
 };
+function createBaseChunkedArtifact() {
+    return {
+        sha512: '',
+        sizeBytes: BigInt(0),
+        chunks: [],
+    };
+}
+export const ChunkedArtifact = {
+    typeUrl: '/agoric.swingset.ChunkedArtifact',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sha512 !== '') {
+            writer.uint32(10).string(message.sha512);
+        }
+        if (message.sizeBytes !== BigInt(0)) {
+            writer.uint32(16).uint64(message.sizeBytes);
+        }
+        for (const v of message.chunks) {
+            ChunkInfo.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseChunkedArtifact();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sha512 = reader.string();
+                    break;
+                case 2:
+                    message.sizeBytes = reader.uint64();
+                    break;
+                case 3:
+                    message.chunks.push(ChunkInfo.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            sha512: isSet(object.sha512) ? String(object.sha512) : '',
+            sizeBytes: isSet(object.sizeBytes)
+                ? BigInt(object.sizeBytes.toString())
+                : BigInt(0),
+            chunks: Array.isArray(object?.chunks)
+                ? object.chunks.map((e) => ChunkInfo.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.sha512 !== undefined && (obj.sha512 = message.sha512);
+        message.sizeBytes !== undefined &&
+            (obj.sizeBytes = (message.sizeBytes || BigInt(0)).toString());
+        if (message.chunks) {
+            obj.chunks = message.chunks.map(e => e ? ChunkInfo.toJSON(e) : undefined);
+        }
+        else {
+            obj.chunks = [];
+        }
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseChunkedArtifact();
+        message.sha512 = object.sha512 ?? '';
+        message.sizeBytes =
+            object.sizeBytes !== undefined && object.sizeBytes !== null
+                ? BigInt(object.sizeBytes.toString())
+                : BigInt(0);
+        message.chunks = object.chunks?.map(e => ChunkInfo.fromPartial(e)) || [];
+        return message;
+    },
+    fromProtoMsg(message) {
+        return ChunkedArtifact.decode(message.value);
+    },
+    toProto(message) {
+        return ChunkedArtifact.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/agoric.swingset.ChunkedArtifact',
+            value: ChunkedArtifact.encode(message).finish(),
+        };
+    },
+};
+function createBaseChunkInfo() {
+    return {
+        sha512: '',
+        sizeBytes: BigInt(0),
+        state: 0,
+    };
+}
+export const ChunkInfo = {
+    typeUrl: '/agoric.swingset.ChunkInfo',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sha512 !== '') {
+            writer.uint32(10).string(message.sha512);
+        }
+        if (message.sizeBytes !== BigInt(0)) {
+            writer.uint32(16).uint64(message.sizeBytes);
+        }
+        if (message.state !== 0) {
+            writer.uint32(24).int32(message.state);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseChunkInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sha512 = reader.string();
+                    break;
+                case 2:
+                    message.sizeBytes = reader.uint64();
+                    break;
+                case 3:
+                    message.state = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            sha512: isSet(object.sha512) ? String(object.sha512) : '',
+            sizeBytes: isSet(object.sizeBytes)
+                ? BigInt(object.sizeBytes.toString())
+                : BigInt(0),
+            state: isSet(object.state) ? chunkStateFromJSON(object.state) : -1,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.sha512 !== undefined && (obj.sha512 = message.sha512);
+        message.sizeBytes !== undefined &&
+            (obj.sizeBytes = (message.sizeBytes || BigInt(0)).toString());
+        message.state !== undefined &&
+            (obj.state = chunkStateToJSON(message.state));
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseChunkInfo();
+        message.sha512 = object.sha512 ?? '';
+        message.sizeBytes =
+            object.sizeBytes !== undefined && object.sizeBytes !== null
+                ? BigInt(object.sizeBytes.toString())
+                : BigInt(0);
+        message.state = object.state ?? 0;
+        return message;
+    },
+    fromProtoMsg(message) {
+        return ChunkInfo.decode(message.value);
+    },
+    toProto(message) {
+        return ChunkInfo.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/agoric.swingset.ChunkInfo',
+            value: ChunkInfo.encode(message).finish(),
+        };
+    },
+};
+function createBaseChunkedArtifactNode() {
+    return {
+        chunkedArtifactId: BigInt(0),
+        nextId: BigInt(0),
+        prevId: BigInt(0),
+        startTimeUnix: BigInt(0),
+        startBlockHeight: BigInt(0),
+    };
+}
+export const ChunkedArtifactNode = {
+    typeUrl: '/agoric.swingset.ChunkedArtifactNode',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.chunkedArtifactId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.chunkedArtifactId);
+        }
+        if (message.nextId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.nextId);
+        }
+        if (message.prevId !== BigInt(0)) {
+            writer.uint32(24).uint64(message.prevId);
+        }
+        if (message.startTimeUnix !== BigInt(0)) {
+            writer.uint32(32).int64(message.startTimeUnix);
+        }
+        if (message.startBlockHeight !== BigInt(0)) {
+            writer.uint32(40).int64(message.startBlockHeight);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseChunkedArtifactNode();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.chunkedArtifactId = reader.uint64();
+                    break;
+                case 2:
+                    message.nextId = reader.uint64();
+                    break;
+                case 3:
+                    message.prevId = reader.uint64();
+                    break;
+                case 4:
+                    message.startTimeUnix = reader.int64();
+                    break;
+                case 5:
+                    message.startBlockHeight = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            chunkedArtifactId: isSet(object.chunkedArtifactId)
+                ? BigInt(object.chunkedArtifactId.toString())
+                : BigInt(0),
+            nextId: isSet(object.nextId)
+                ? BigInt(object.nextId.toString())
+                : BigInt(0),
+            prevId: isSet(object.prevId)
+                ? BigInt(object.prevId.toString())
+                : BigInt(0),
+            startTimeUnix: isSet(object.startTimeUnix)
+                ? BigInt(object.startTimeUnix.toString())
+                : BigInt(0),
+            startBlockHeight: isSet(object.startBlockHeight)
+                ? BigInt(object.startBlockHeight.toString())
+                : BigInt(0),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.chunkedArtifactId !== undefined &&
+            (obj.chunkedArtifactId = (message.chunkedArtifactId || BigInt(0)).toString());
+        message.nextId !== undefined &&
+            (obj.nextId = (message.nextId || BigInt(0)).toString());
+        message.prevId !== undefined &&
+            (obj.prevId = (message.prevId || BigInt(0)).toString());
+        message.startTimeUnix !== undefined &&
+            (obj.startTimeUnix = (message.startTimeUnix || BigInt(0)).toString());
+        message.startBlockHeight !== undefined &&
+            (obj.startBlockHeight = (message.startBlockHeight || BigInt(0)).toString());
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseChunkedArtifactNode();
+        message.chunkedArtifactId =
+            object.chunkedArtifactId !== undefined &&
+                object.chunkedArtifactId !== null
+                ? BigInt(object.chunkedArtifactId.toString())
+                : BigInt(0);
+        message.nextId =
+            object.nextId !== undefined && object.nextId !== null
+                ? BigInt(object.nextId.toString())
+                : BigInt(0);
+        message.prevId =
+            object.prevId !== undefined && object.prevId !== null
+                ? BigInt(object.prevId.toString())
+                : BigInt(0);
+        message.startTimeUnix =
+            object.startTimeUnix !== undefined && object.startTimeUnix !== null
+                ? BigInt(object.startTimeUnix.toString())
+                : BigInt(0);
+        message.startBlockHeight =
+            object.startBlockHeight !== undefined && object.startBlockHeight !== null
+                ? BigInt(object.startBlockHeight.toString())
+                : BigInt(0);
+        return message;
+    },
+    fromProtoMsg(message) {
+        return ChunkedArtifactNode.decode(message.value);
+    },
+    toProto(message) {
+        return ChunkedArtifactNode.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/agoric.swingset.ChunkedArtifactNode',
+            value: ChunkedArtifactNode.encode(message).finish(),
+        };
+    },
+};
 //# sourceMappingURL=swingset.js.map