@agoric/client-utils 0.1.1-other-dev-3eb1a1d.0 → 0.1.1-other-dev-d15096d.0.d15096d

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

@@ -0,0 +1,1274 @@
+//@ts-nocheck
+import { Coin } from '../../cosmos/base/v1beta1/coin.js';
+import { BinaryReader, BinaryWriter } from '../../binary.js';
+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: '',
+        description: '',
+        evals: [],
+    };
+}
+export const CoreEvalProposal = {
+    typeUrl: '/agoric.swingset.CoreEvalProposal',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.title !== '') {
+            writer.uint32(10).string(message.title);
+        }
+        if (message.description !== '') {
+            writer.uint32(18).string(message.description);
+        }
+        for (const v of message.evals) {
+            CoreEval.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 = createBaseCoreEvalProposal();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.title = reader.string();
+                    break;
+                case 2:
+                    message.description = reader.string();
+                    break;
+                case 3:
+                    message.evals.push(CoreEval.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            title: isSet(object.title) ? String(object.title) : '',
+            description: isSet(object.description) ? String(object.description) : '',
+            evals: Array.isArray(object?.evals)
+                ? object.evals.map((e) => CoreEval.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.title !== undefined && (obj.title = message.title);
+        message.description !== undefined &&
+            (obj.description = message.description);
+        if (message.evals) {
+            obj.evals = message.evals.map(e => (e ? CoreEval.toJSON(e) : undefined));
+        }
+        else {
+            obj.evals = [];
+        }
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseCoreEvalProposal();
+        message.title = object.title ?? '';
+        message.description = object.description ?? '';
+        message.evals = object.evals?.map(e => CoreEval.fromPartial(e)) || [];
+        return message;
+    },
+    fromProtoMsg(message) {
+        return CoreEvalProposal.decode(message.value);
+    },
+    toProto(message) {
+        return CoreEvalProposal.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/agoric.swingset.CoreEvalProposal',
+            value: CoreEvalProposal.encode(message).finish(),
+        };
+    },
+};
+function createBaseCoreEval() {
+    return {
+        jsonPermits: '',
+        jsCode: '',
+    };
+}
+export const CoreEval = {
+    typeUrl: '/agoric.swingset.CoreEval',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.jsonPermits !== '') {
+            writer.uint32(10).string(message.jsonPermits);
+        }
+        if (message.jsCode !== '') {
+            writer.uint32(18).string(message.jsCode);
+        }
+        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 = createBaseCoreEval();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.jsonPermits = reader.string();
+                    break;
+                case 2:
+                    message.jsCode = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            jsonPermits: isSet(object.jsonPermits) ? String(object.jsonPermits) : '',
+            jsCode: isSet(object.jsCode) ? String(object.jsCode) : '',
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.jsonPermits !== undefined &&
+            (obj.jsonPermits = message.jsonPermits);
+        message.jsCode !== undefined && (obj.jsCode = message.jsCode);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseCoreEval();
+        message.jsonPermits = object.jsonPermits ?? '';
+        message.jsCode = object.jsCode ?? '';
+        return message;
+    },
+    fromProtoMsg(message) {
+        return CoreEval.decode(message.value);
+    },
+    toProto(message) {
+        return CoreEval.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/agoric.swingset.CoreEval',
+            value: CoreEval.encode(message).finish(),
+        };
+    },
+};
+function createBaseParams() {
+    return {
+        beansPerUnit: [],
+        feeUnitPrice: [],
+        bootstrapVatConfig: '',
+        powerFlagFees: [],
+        queueMax: [],
+        vatCleanupBudget: [],
+        installationDeadlineBlocks: BigInt(0),
+        installationDeadlineSeconds: BigInt(0),
+        bundleUncompressedSizeLimitBytes: BigInt(0),
+        chunkSizeLimitBytes: BigInt(0),
+    };
+}
+export const Params = {
+    typeUrl: '/agoric.swingset.Params',
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.beansPerUnit) {
+            StringBeans.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.feeUnitPrice) {
+            Coin.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.bootstrapVatConfig !== '') {
+            writer.uint32(26).string(message.bootstrapVatConfig);
+        }
+        for (const v of message.powerFlagFees) {
+            PowerFlagFee.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        for (const v of message.queueMax) {
+            QueueSize.encode(v, writer.uint32(42).fork()).ldelim();
+        }
+        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) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.beansPerUnit.push(StringBeans.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.feeUnitPrice.push(Coin.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.bootstrapVatConfig = reader.string();
+                    break;
+                case 4:
+                    message.powerFlagFees.push(PowerFlagFee.decode(reader, reader.uint32()));
+                    break;
+                case 5:
+                    message.queueMax.push(QueueSize.decode(reader, reader.uint32()));
+                    break;
+                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;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            beansPerUnit: Array.isArray(object?.beansPerUnit)
+                ? object.beansPerUnit.map((e) => StringBeans.fromJSON(e))
+                : [],
+            feeUnitPrice: Array.isArray(object?.feeUnitPrice)
+                ? object.feeUnitPrice.map((e) => Coin.fromJSON(e))
+                : [],
+            bootstrapVatConfig: isSet(object.bootstrapVatConfig)
+                ? String(object.bootstrapVatConfig)
+                : '',
+            powerFlagFees: Array.isArray(object?.powerFlagFees)
+                ? object.powerFlagFees.map((e) => PowerFlagFee.fromJSON(e))
+                : [],
+            queueMax: Array.isArray(object?.queueMax)
+                ? object.queueMax.map((e) => QueueSize.fromJSON(e))
+                : [],
+            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) {
+        const obj = {};
+        if (message.beansPerUnit) {
+            obj.beansPerUnit = message.beansPerUnit.map(e => e ? StringBeans.toJSON(e) : undefined);
+        }
+        else {
+            obj.beansPerUnit = [];
+        }
+        if (message.feeUnitPrice) {
+            obj.feeUnitPrice = message.feeUnitPrice.map(e => e ? Coin.toJSON(e) : undefined);
+        }
+        else {
+            obj.feeUnitPrice = [];
+        }
+        message.bootstrapVatConfig !== undefined &&
+            (obj.bootstrapVatConfig = message.bootstrapVatConfig);
+        if (message.powerFlagFees) {
+            obj.powerFlagFees = message.powerFlagFees.map(e => e ? PowerFlagFee.toJSON(e) : undefined);
+        }
+        else {
+            obj.powerFlagFees = [];
+        }
+        if (message.queueMax) {
+            obj.queueMax = message.queueMax.map(e => e ? QueueSize.toJSON(e) : undefined);
+        }
+        else {
+            obj.queueMax = [];
+        }
+        if (message.vatCleanupBudget) {
+            obj.vatCleanupBudget = message.vatCleanupBudget.map(e => e ? UintMapEntry.toJSON(e) : undefined);
+        }
+        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) {
+        const message = createBaseParams();
+        message.beansPerUnit =
+            object.beansPerUnit?.map(e => StringBeans.fromPartial(e)) || [];
+        message.feeUnitPrice =
+            object.feeUnitPrice?.map(e => Coin.fromPartial(e)) || [];
+        message.bootstrapVatConfig = object.bootstrapVatConfig ?? '';
+        message.powerFlagFees =
+            object.powerFlagFees?.map(e => PowerFlagFee.fromPartial(e)) || [];
+        message.queueMax =
+            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) {
+        return Params.decode(message.value);
+    },
+    toProto(message) {
+        return Params.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/agoric.swingset.Params',
+            value: Params.encode(message).finish(),
+        };
+    },
+};
+function createBaseState() {
+    return {
+        queueAllowed: [],
+        firstChunkedArtifactId: BigInt(0),
+        lastChunkedArtifactId: BigInt(0),
+    };
+}
+export const State = {
+    typeUrl: '/agoric.swingset.State',
+    encode(message, writer = BinaryWriter.create()) {
+        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);
+        }
+        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 = createBaseState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                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;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            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),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.queueAllowed) {
+            obj.queueAllowed = message.queueAllowed.map(e => e ? QueueSize.toJSON(e) : undefined);
+        }
+        else {
+            obj.queueAllowed = [];
+        }
+        message.firstChunkedArtifactId !== undefined &&
+            (obj.firstChunkedArtifactId = (message.firstChunkedArtifactId || BigInt(0)).toString());
+        message.lastChunkedArtifactId !== undefined &&
+            (obj.lastChunkedArtifactId = (message.lastChunkedArtifactId || 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);
+        return message;
+    },
+    fromProtoMsg(message) {
+        return State.decode(message.value);
+    },
+    toProto(message) {
+        return State.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/agoric.swingset.State',
+            value: State.encode(message).finish(),
+        };
+    },
+};
+function createBaseStringBeans() {
+    return {
+        key: '',
+        beans: '',
+    };
+}
+export const StringBeans = {
+    typeUrl: '/agoric.swingset.StringBeans',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.key !== '') {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.beans !== '') {
+            writer.uint32(18).string(message.beans);
+        }
+        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 = createBaseStringBeans();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.string();
+                    break;
+                case 2:
+                    message.beans = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? String(object.key) : '',
+            beans: isSet(object.beans) ? String(object.beans) : '',
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.key !== undefined && (obj.key = message.key);
+        message.beans !== undefined && (obj.beans = message.beans);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseStringBeans();
+        message.key = object.key ?? '';
+        message.beans = object.beans ?? '';
+        return message;
+    },
+    fromProtoMsg(message) {
+        return StringBeans.decode(message.value);
+    },
+    toProto(message) {
+        return StringBeans.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/agoric.swingset.StringBeans',
+            value: StringBeans.encode(message).finish(),
+        };
+    },
+};
+function createBasePowerFlagFee() {
+    return {
+        powerFlag: '',
+        fee: [],
+    };
+}
+export const PowerFlagFee = {
+    typeUrl: '/agoric.swingset.PowerFlagFee',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.powerFlag !== '') {
+            writer.uint32(10).string(message.powerFlag);
+        }
+        for (const v of message.fee) {
+            Coin.encode(v, writer.uint32(18).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 = createBasePowerFlagFee();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.powerFlag = reader.string();
+                    break;
+                case 2:
+                    message.fee.push(Coin.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            powerFlag: isSet(object.powerFlag) ? String(object.powerFlag) : '',
+            fee: Array.isArray(object?.fee)
+                ? object.fee.map((e) => Coin.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.powerFlag !== undefined && (obj.powerFlag = message.powerFlag);
+        if (message.fee) {
+            obj.fee = message.fee.map(e => (e ? Coin.toJSON(e) : undefined));
+        }
+        else {
+            obj.fee = [];
+        }
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBasePowerFlagFee();
+        message.powerFlag = object.powerFlag ?? '';
+        message.fee = object.fee?.map(e => Coin.fromPartial(e)) || [];
+        return message;
+    },
+    fromProtoMsg(message) {
+        return PowerFlagFee.decode(message.value);
+    },
+    toProto(message) {
+        return PowerFlagFee.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/agoric.swingset.PowerFlagFee',
+            value: PowerFlagFee.encode(message).finish(),
+        };
+    },
+};
+function createBaseQueueSize() {
+    return {
+        key: '',
+        size: 0,
+    };
+}
+export const QueueSize = {
+    typeUrl: '/agoric.swingset.QueueSize',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.key !== '') {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.size !== 0) {
+            writer.uint32(16).int32(message.size);
+        }
+        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 = createBaseQueueSize();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.string();
+                    break;
+                case 2:
+                    message.size = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? String(object.key) : '',
+            size: isSet(object.size) ? Number(object.size) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.key !== undefined && (obj.key = message.key);
+        message.size !== undefined && (obj.size = Math.round(message.size));
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseQueueSize();
+        message.key = object.key ?? '';
+        message.size = object.size ?? 0;
+        return message;
+    },
+    fromProtoMsg(message) {
+        return QueueSize.decode(message.value);
+    },
+    toProto(message) {
+        return QueueSize.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/agoric.swingset.QueueSize',
+            value: QueueSize.encode(message).finish(),
+        };
+    },
+};
+function createBaseUintMapEntry() {
+    return {
+        key: '',
+        value: '',
+    };
+}
+export const UintMapEntry = {
+    typeUrl: '/agoric.swingset.UintMapEntry',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.key !== '') {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== '') {
+            writer.uint32(18).string(message.value);
+        }
+        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 = createBaseUintMapEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.string();
+                    break;
+                case 2:
+                    message.value = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? String(object.key) : '',
+            value: isSet(object.value) ? String(object.value) : '',
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.key !== undefined && (obj.key = message.key);
+        message.value !== undefined && (obj.value = message.value);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseUintMapEntry();
+        message.key = object.key ?? '';
+        message.value = object.value ?? '';
+        return message;
+    },
+    fromProtoMsg(message) {
+        return UintMapEntry.decode(message.value);
+    },
+    toProto(message) {
+        return UintMapEntry.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/agoric.swingset.UintMapEntry',
+            value: UintMapEntry.encode(message).finish(),
+        };
+    },
+};
+function createBaseEgress() {
+    return {
+        nickname: '',
+        peer: new Uint8Array(),
+        powerFlags: [],
+    };
+}
+export const Egress = {
+    typeUrl: '/agoric.swingset.Egress',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.nickname !== '') {
+            writer.uint32(10).string(message.nickname);
+        }
+        if (message.peer.length !== 0) {
+            writer.uint32(18).bytes(message.peer);
+        }
+        for (const v of message.powerFlags) {
+            writer.uint32(26).string(v);
+        }
+        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 = createBaseEgress();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.nickname = reader.string();
+                    break;
+                case 2:
+                    message.peer = reader.bytes();
+                    break;
+                case 3:
+                    message.powerFlags.push(reader.string());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            nickname: isSet(object.nickname) ? String(object.nickname) : '',
+            peer: isSet(object.peer)
+                ? bytesFromBase64(object.peer)
+                : new Uint8Array(),
+            powerFlags: Array.isArray(object?.powerFlags)
+                ? object.powerFlags.map((e) => String(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.nickname !== undefined && (obj.nickname = message.nickname);
+        message.peer !== undefined &&
+            (obj.peer = base64FromBytes(message.peer !== undefined ? message.peer : new Uint8Array()));
+        if (message.powerFlags) {
+            obj.powerFlags = message.powerFlags.map(e => e);
+        }
+        else {
+            obj.powerFlags = [];
+        }
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseEgress();
+        message.nickname = object.nickname ?? '';
+        message.peer = object.peer ?? new Uint8Array();
+        message.powerFlags = object.powerFlags?.map(e => e) || [];
+        return message;
+    },
+    fromProtoMsg(message) {
+        return Egress.decode(message.value);
+    },
+    toProto(message) {
+        return Egress.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/agoric.swingset.Egress',
+            value: Egress.encode(message).finish(),
+        };
+    },
+};
+function createBaseSwingStoreArtifact() {
+    return {
+        name: '',
+        data: new Uint8Array(),
+    };
+}
+export const SwingStoreArtifact = {
+    typeUrl: '/agoric.swingset.SwingStoreArtifact',
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.name !== '') {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.data.length !== 0) {
+            writer.uint32(18).bytes(message.data);
+        }
+        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 = createBaseSwingStoreArtifact();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                case 2:
+                    message.data = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            name: isSet(object.name) ? String(object.name) : '',
+            data: isSet(object.data)
+                ? bytesFromBase64(object.data)
+                : new Uint8Array(),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.name !== undefined && (obj.name = message.name);
+        message.data !== undefined &&
+            (obj.data = base64FromBytes(message.data !== undefined ? message.data : new Uint8Array()));
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseSwingStoreArtifact();
+        message.name = object.name ?? '';
+        message.data = object.data ?? new Uint8Array();
+        return message;
+    },
+    fromProtoMsg(message) {
+        return SwingStoreArtifact.decode(message.value);
+    },
+    toProto(message) {
+        return SwingStoreArtifact.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: '/agoric.swingset.SwingStoreArtifact',
+            value: SwingStoreArtifact.encode(message).finish(),
+        };
+    },
+};
+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