@agoric/orchestration 0.1.1-dev-1af1596.0 → 0.1.1-dev-0ca4b57.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/orchestration",
-  "version": "0.1.1-dev-1af1596.0+1af1596",
+  "version": "0.1.1-dev-0ca4b57.0+0ca4b57",
   "description": "Chain abstraction for Agoric's orchestration clients",
   "type": "module",
   "main": "index.js",
@@ -33,19 +33,19 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/async-flow": "0.1.1-dev-1af1596.0+1af1596",
-    "@agoric/cosmic-proto": "0.4.1-dev-1af1596.0+1af1596",
-    "@agoric/ertp": "0.16.3-dev-1af1596.0+1af1596",
-    "@agoric/internal": "0.3.3-dev-1af1596.0+1af1596",
-    "@agoric/network": "0.1.1-dev-1af1596.0+1af1596",
-    "@agoric/notifier": "0.6.3-dev-1af1596.0+1af1596",
-    "@agoric/store": "0.9.3-dev-1af1596.0+1af1596",
-    "@agoric/time": "0.3.3-dev-1af1596.0+1af1596",
-    "@agoric/vat-data": "0.5.3-dev-1af1596.0+1af1596",
-    "@agoric/vats": "0.15.2-dev-1af1596.0+1af1596",
-    "@agoric/vow": "0.1.1-dev-1af1596.0+1af1596",
-    "@agoric/zoe": "0.26.3-dev-1af1596.0+1af1596",
-    "@agoric/zone": "0.2.3-dev-1af1596.0+1af1596",
+    "@agoric/async-flow": "0.1.1-dev-0ca4b57.0+0ca4b57",
+    "@agoric/cosmic-proto": "0.4.1-dev-0ca4b57.0+0ca4b57",
+    "@agoric/ertp": "0.16.3-dev-0ca4b57.0+0ca4b57",
+    "@agoric/internal": "0.3.3-dev-0ca4b57.0+0ca4b57",
+    "@agoric/network": "0.1.1-dev-0ca4b57.0+0ca4b57",
+    "@agoric/notifier": "0.6.3-dev-0ca4b57.0+0ca4b57",
+    "@agoric/store": "0.9.3-dev-0ca4b57.0+0ca4b57",
+    "@agoric/time": "0.3.3-dev-0ca4b57.0+0ca4b57",
+    "@agoric/vat-data": "0.5.3-dev-0ca4b57.0+0ca4b57",
+    "@agoric/vats": "0.15.2-dev-0ca4b57.0+0ca4b57",
+    "@agoric/vow": "0.1.1-dev-0ca4b57.0+0ca4b57",
+    "@agoric/zoe": "0.26.3-dev-0ca4b57.0+0ca4b57",
+    "@agoric/zone": "0.2.3-dev-0ca4b57.0+0ca4b57",
     "@endo/base64": "^1.0.9",
     "@endo/errors": "^1.2.9",
     "@endo/far": "^1.1.10",
@@ -54,7 +54,7 @@
     "@noble/hashes": "^1.5.0"
   },
   "devDependencies": {
-    "@agoric/swingset-liveslots": "0.10.3-dev-1af1596.0+1af1596",
+    "@agoric/swingset-liveslots": "0.10.3-dev-0ca4b57.0+0ca4b57",
     "@chain-registry/client": "^1.47.4",
     "@cosmjs/amino": "^0.32.3",
     "@cosmjs/proto-signing": "^0.32.3",
@@ -88,7 +88,8 @@
   "files": [
     "*.js",
     "*.ts",
-    "src"
+    "src",
+    "tools"
   ],
   "publishConfig": {
     "access": "public"
@@ -96,5 +97,5 @@
   "typeCoverage": {
     "atLeast": 97.77
   },
-  "gitHead": "1af1596ffa4d14c089c231825fbe5729be4b3ce3"
+  "gitHead": "0ca4b5765e8afd14987ff909e6bd4d5d1c453c18"
 }

package/tools/ibc-mocks.d.ts

@@ -0,0 +1,116 @@
+/** @file Tools to support making IBC mocks */
+import { type JsonSafe } from '@agoric/cosmic-proto';
+import { TxBody } from '@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js';
+import { Any } from '@agoric/cosmic-proto/google/protobuf/any.js';
+import type { PacketSDKType } from '@agoric/cosmic-proto/ibc/core/channel/v1/channel.js';
+import { RequestQuery, ResponseQuery } from '@agoric/cosmic-proto/tendermint/abci/types.js';
+import type { IBCChannelID, IBCEvent, VTransferIBCEvent } from '@agoric/vats';
+import type { ChainAddress } from '../src/orchestration-api.js';
+interface EncoderCommon<T> {
+    encode: (message: T) => {
+        finish: () => Uint8Array;
+    };
+    fromPartial: (partial: Partial<T>) => T;
+    typeUrl: string;
+}
+/**
+ * Build a response "packet bytes string" we'd expect to see from a Msg
+ * Response
+ *
+ * XXX support multiple responses in a single message
+ *
+ * @param Encoder
+ * @param message
+ */
+export declare function buildMsgResponseString<T>(Encoder: EncoderCommon<T>, message: Partial<T>): string;
+/**
+ * Build an example error packet for a failed Tx Msg
+ * @param msg
+ */
+export declare function buildMsgErrorString(msg?: string): string;
+/**
+ * Build a response "packet bytes string" we'd expect to see from a Query
+ * request
+ *
+ * XXX accept multiple queries at once
+ *
+ * @param Encoder
+ * @param query
+ * @param opts
+ */
+export declare function buildQueryResponseString<T>(Encoder: EncoderCommon<T>, query: Partial<T>, opts?: Omit<ResponseQuery, 'key'>): string;
+/**
+ * Build a tx packet string for the mocked dibc bridge handler
+ * @param msgs
+ * @returns {string}
+ */
+export declare function buildTxPacketString(msgs: {
+    value: Uint8Array;
+    typeUrl: string;
+}[]): string;
+/**
+ * Parse an outgoing ica tx packet. Useful for testing when inspecting
+ * outgoing dibc bridge messages.
+ *
+ * @param b64 base64 encoded string
+ */
+export declare const parseOutgoingTxPacket: (b64: string) => TxBody;
+/**
+ * Build a query packet string for the mocked dibc bridge handler
+ * @param msgs
+ * @param opts
+ * @returns {string}
+ */
+export declare function buildQueryPacketString(msgs: Any[], opts?: Partial<Omit<RequestQuery, 'path' | 'data'>>): string;
+type BuildVTransferEventParams = {
+    event?: VTransferIBCEvent['event'];
+    sender?: ChainAddress['value'];
+    receiver?: ChainAddress['value'];
+    target?: ChainAddress['value'];
+    amount?: bigint;
+    denom?: string;
+    destinationChannel?: IBCChannelID;
+    sourceChannel?: IBCChannelID;
+    sequence?: PacketSDKType['sequence'] | JsonSafe<PacketSDKType['sequence']>;
+};
+/**
+ * `buildVTransferEvent` can be used with `transferBridge` to simulate incoming
+ * and outgoing IBC fungible tokens transfers to a LocalChain account.
+ *
+ * It defaults to simulating incoming transfers. To simulate an outgoing one,
+ * ensure `sender=agoric1fakeLCAAddress` and  this after LocalChainBridge
+ * receives the outgoing MsgTransfer,
+ *
+ * @example
+ * ```js
+ * const { mocks: { transferBridge } = await commonSetup(t);
+ * await E(transferBridge).fromBridge(
+ *  buildVTransferEvent({
+ *    receiver: 'agoric1fakeLCAAddress',
+ *    amount: 10n,
+ *    denom: 'uatom',
+ *  }),
+ * );
+ * ```
+ *
+ * XXX integrate vlocalchain and vtransfer ScopedBridgeManagers
+ * in test supports.
+ *
+ * @param {{BuildVTransferEventParams}} args
+ */
+export declare const buildVTransferEvent: ({ event, sender, receiver, target, amount, denom, destinationChannel, sourceChannel, sequence, }?: BuildVTransferEventParams) => VTransferIBCEvent;
+export declare function createMockAckMap(mockMap: Record<string, {
+    msg: string;
+    ack: string;
+}>): {};
+/**
+ * Simulate an IBC channelCloseConfirm event. This can be used to simulate an
+ * ICA channel closing for an unexpected reason from a remote chain, _or
+ * anything besides the Connection holder calling `.close()`_. If `close()` is
+ * called, we'd instead expect to see a Downcall for channelCloseInit.
+ *
+ * @param {Pick<IBCEvent<'channelCloseConfirm'>, 'portID' | 'channelID'>} event
+ */
+export declare const buildChannelCloseConfirmEvent: ({ channelID, portID, }?: Partial<IBCEvent<"channelCloseConfirm">>) => Partial<IBCEvent<"channelCloseConfirm">>;
+export {};
+//# sourceMappingURL=ibc-mocks.d.ts.map

package/tools/ibc-mocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ibc-mocks.d.ts","sourceRoot":"","sources":["ibc-mocks.ts"],"names":[],"mappings":"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"}

package/tools/ibc-mocks.ts

@@ -0,0 +1,262 @@
+/** @file Tools to support making IBC mocks */
+import { type JsonSafe, toRequestQueryJson } from '@agoric/cosmic-proto';
+import { TxBody } from '@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js';
+import { Any } from '@agoric/cosmic-proto/google/protobuf/any.js';
+import { FungibleTokenPacketData } from '@agoric/cosmic-proto/ibc/applications/transfer/v2/packet.js';
+import type { PacketSDKType } from '@agoric/cosmic-proto/ibc/core/channel/v1/channel.js';
+import { CosmosResponse } from '@agoric/cosmic-proto/icq/v1/packet.js';
+import {
+  RequestQuery,
+  ResponseQuery,
+} from '@agoric/cosmic-proto/tendermint/abci/types.js';
+import {
+  IBC_EVENT,
+  VTRANSFER_IBC_EVENT,
+} from '@agoric/internal/src/action-types.js';
+import type {
+  IBCChannelID,
+  IBCEvent,
+  IBCPacket,
+  VTransferIBCEvent,
+} from '@agoric/vats';
+import { LOCALCHAIN_DEFAULT_ADDRESS } from '@agoric/vats/tools/fake-bridge.js';
+import { atob, btoa, decodeBase64, encodeBase64 } from '@endo/base64';
+import type { ChainAddress } from '../src/orchestration-api.js';
+import { makeQueryPacket, makeTxPacket } from '../src/utils/packet.js';
+
+interface EncoderCommon<T> {
+  encode: (message: T) => {
+    finish: () => Uint8Array;
+  };
+  fromPartial: (partial: Partial<T>) => T;
+  typeUrl: string;
+}
+
+const toPacket = (obj: Record<string, any>): string =>
+  btoa(JSON.stringify(obj));
+
+/**
+ * Build a response "packet bytes string" we'd expect to see from a Msg
+ * Response
+ *
+ * XXX support multiple responses in a single message
+ *
+ * @param Encoder
+ * @param message
+ */
+export function buildMsgResponseString<T>(
+  Encoder: EncoderCommon<T>,
+  message: Partial<T>,
+): string {
+  const encodedMsg = Encoder.encode(Encoder.fromPartial(message)).finish();
+
+  // cosmos-sdk double Any encodes
+  const encodedAny = Any.encode(
+    Any.fromPartial({
+      value: Any.encode(
+        Any.fromPartial({
+          typeUrl: Encoder.typeUrl,
+          value: encodedMsg,
+        }),
+      ).finish(),
+    }),
+  ).finish();
+
+  return toPacket({
+    result: encodeBase64(encodedAny),
+  });
+}
+
+/**
+ * Build an example error packet for a failed Tx Msg
+ * @param msg
+ */
+export function buildMsgErrorString(
+  msg = 'ABCI code: 5: error handling packet: see events for details',
+): string {
+  return toPacket({
+    error: msg,
+  });
+}
+
+/**
+ * Build a response "packet bytes string" we'd expect to see from a Query
+ * request
+ *
+ * XXX accept multiple queries at once
+ *
+ * @param Encoder
+ * @param query
+ * @param opts
+ */
+export function buildQueryResponseString<T>(
+  Encoder: EncoderCommon<T>,
+  query: Partial<T>,
+  opts: Omit<ResponseQuery, 'key'> = {
+    value: new Uint8Array(),
+    height: 0n,
+    index: 0n,
+    code: 0,
+    log: '',
+    info: '',
+    codespace: '',
+  },
+): string {
+  const encodedResp = CosmosResponse.encode(
+    CosmosResponse.fromPartial({
+      responses: [
+        {
+          key: Encoder.encode(Encoder.fromPartial(query)).finish(),
+          ...opts,
+        },
+      ],
+    }),
+  ).finish();
+
+  return toPacket({
+    result: toPacket({ data: encodeBase64(encodedResp) }),
+  });
+}
+
+/**
+ * Build a tx packet string for the mocked dibc bridge handler
+ * @param msgs
+ * @returns {string}
+ */
+export function buildTxPacketString(
+  msgs: { value: Uint8Array; typeUrl: string }[],
+): string {
+  return btoa(makeTxPacket(msgs.map(Any.toJSON)));
+}
+
+/**
+ * Parse an outgoing ica tx packet. Useful for testing when inspecting
+ * outgoing dibc bridge messages.
+ *
+ * @param b64 base64 encoded string
+ */
+export const parseOutgoingTxPacket = (b64: string) => {
+  return TxBody.decode(decodeBase64(JSON.parse(atob(b64)).data));
+};
+
+/**
+ * Build a query packet string for the mocked dibc bridge handler
+ * @param msgs
+ * @param opts
+ * @returns {string}
+ */
+export function buildQueryPacketString(
+  msgs: Any[],
+  opts: Partial<Omit<RequestQuery, 'path' | 'data'>> = {},
+): string {
+  return btoa(makeQueryPacket(msgs.map(msg => toRequestQueryJson(msg, opts))));
+}
+
+type BuildVTransferEventParams = {
+  event?: VTransferIBCEvent['event'];
+  /* defaults to cosmos1AccAddress. set to `agoric1fakeLCAAddress` to simulate an outgoing transfer event */
+  sender?: ChainAddress['value'];
+  /*  defaults to agoric1fakeLCAAddress. set to a different value to simulate an outgoing transfer event */
+  receiver?: ChainAddress['value'];
+  target?: ChainAddress['value'];
+  amount?: bigint;
+  denom?: string;
+  destinationChannel?: IBCChannelID;
+  sourceChannel?: IBCChannelID;
+  /* support bigint and string, to facilitate bootstrap testing */
+  sequence?: PacketSDKType['sequence'] | JsonSafe<PacketSDKType['sequence']>;
+};
+
+/**
+ * `buildVTransferEvent` can be used with `transferBridge` to simulate incoming
+ * and outgoing IBC fungible tokens transfers to a LocalChain account.
+ *
+ * It defaults to simulating incoming transfers. To simulate an outgoing one,
+ * ensure `sender=agoric1fakeLCAAddress` and  this after LocalChainBridge
+ * receives the outgoing MsgTransfer,
+ *
+ * @example
+ * ```js
+ * const { mocks: { transferBridge } = await commonSetup(t);
+ * await E(transferBridge).fromBridge(
+ *  buildVTransferEvent({
+ *    receiver: 'agoric1fakeLCAAddress',
+ *    amount: 10n,
+ *    denom: 'uatom',
+ *  }),
+ * );
+ * ```
+ *
+ * XXX integrate vlocalchain and vtransfer ScopedBridgeManagers
+ * in test supports.
+ *
+ * @param {{BuildVTransferEventParams}} args
+ */
+export const buildVTransferEvent = ({
+  event = 'acknowledgementPacket' as const,
+  sender = 'cosmos1AccAddress',
+  receiver = LOCALCHAIN_DEFAULT_ADDRESS,
+  target = LOCALCHAIN_DEFAULT_ADDRESS,
+  amount = 10n,
+  denom = 'uatom',
+  destinationChannel = 'channel-0' as IBCChannelID,
+  sourceChannel = 'channel-405' as IBCChannelID,
+  sequence = 0n,
+}: BuildVTransferEventParams = {}): VTransferIBCEvent => ({
+  type: VTRANSFER_IBC_EVENT,
+  blockHeight: 0,
+  blockTime: 0,
+  event,
+  acknowledgement: btoa(JSON.stringify({ result: 'AQ==' })),
+  relayer: 'agoric123',
+  target,
+  packet: {
+    data: btoa(
+      JSON.stringify(
+        FungibleTokenPacketData.fromPartial({
+          amount: String(amount),
+          denom,
+          sender,
+          receiver,
+        }),
+      ),
+    ),
+    destination_channel: destinationChannel,
+    source_channel: sourceChannel,
+    destination_port: 'transfer',
+    source_port: 'transfer',
+    sequence,
+  } as IBCPacket,
+});
+
+export function createMockAckMap(
+  mockMap: Record<string, { msg: string; ack: string }>,
+) {
+  const res = Object.values(mockMap).reduce((acc, { msg, ack }) => {
+    acc[msg] = ack;
+    return acc;
+  }, {});
+  return res;
+}
+
+/**
+ * Simulate an IBC channelCloseConfirm event. This can be used to simulate an
+ * ICA channel closing for an unexpected reason from a remote chain, _or
+ * anything besides the Connection holder calling `.close()`_. If `close()` is
+ * called, we'd instead expect to see a Downcall for channelCloseInit.
+ *
+ * @param {Pick<IBCEvent<'channelCloseConfirm'>, 'portID' | 'channelID'>} event
+ */
+export const buildChannelCloseConfirmEvent = ({
+  channelID = 'channel-0',
+  portID = 'icacontroller-1',
+}: Partial<IBCEvent<'channelCloseConfirm'>> = {}): Partial<
+  IBCEvent<'channelCloseConfirm'>
+> => ({
+  blockHeight: 0,
+  blockTime: 0,
+  channelID,
+  event: 'channelCloseConfirm',
+  portID,
+  type: IBC_EVENT,
+});

package/tools/make-test-address.d.ts

@@ -0,0 +1,2 @@
+export function makeTestAddress(index?: number, prefix?: string, byteLength?: number): string;
+//# sourceMappingURL=make-test-address.d.ts.map

package/tools/make-test-address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-test-address.d.ts","sourceRoot":"","sources":["make-test-address.js"],"names":[],"mappings":"AASO,wCALI,MAAM,WACN,MAAM,eACN,MAAM,GACJ,MAAM,CAalB"}

package/tools/make-test-address.js

@@ -0,0 +1,21 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { bech32 } from 'bech32';
+
+/**
+ * @param {number} index
+ * @param {string} prefix
+ * @param {number} byteLength
+ * @returns {string} a mock bech32 address for tests
+ */
+export const makeTestAddress = (
+  index = 0,
+  prefix = 'agoric',
+  byteLength = 20,
+) => {
+  // create a simple 20-byte array (common address length)
+  const bytes = new Uint8Array(byteLength).fill(0);
+  // if index provided, put it in the first byte
+  if (index !== 0) bytes[0] = Number(index);
+  const words = bech32.toWords(bytes);
+  return bech32.encode(prefix, words);
+};

package/tools/protobuf-decoder.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Decodes a protobuf message from the given buffer.
+ *
+ * @param {Buffer} buffer
+ */
+export function decodeProtobuf(buffer: Buffer): {
+    value: {};
+    bytesRead: number;
+};
+/**
+ * Decodes a protobuf message from the given base64-encoded data.
+ *
+ * @param {string} base64String
+ */
+export function decodeProtobufBase64(base64String: string): {
+    value: {};
+    bytesRead: number;
+};
+//# sourceMappingURL=protobuf-decoder.d.ts.map

package/tools/protobuf-decoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protobuf-decoder.d.ts","sourceRoot":"","sources":["protobuf-decoder.js"],"names":[],"mappings":"AA8HA;;;;GAIG;AACH,uCAFW,MAAM;;;EAchB;AACD;;;;GAIG;AACH,mDAFW,MAAM;;;EAKhB"}

package/tools/protobuf-decoder.js

@@ -0,0 +1,153 @@
+/* eslint-env node */
+/* eslint-disable -- generated by Sonnet, easier to leave alone */
+
+const WIRE_TYPES = {
+  VARINT: 0,
+  FIXED64: 1,
+  LENGTH_DELIMITED: 2,
+  START_GROUP: 3,
+  END_GROUP: 4,
+  FIXED32: 5,
+};
+
+function decodeVarint(buffer, offset) {
+  let result = 0n;
+  let shift = 0;
+  let byte;
+
+  do {
+    if (offset >= buffer.length) {
+      throw new Error('Buffer overflow while decoding varint');
+    }
+    byte = buffer[offset];
+    result |= BigInt(byte & 0x7f) << BigInt(shift);
+    shift += 7;
+    offset++;
+  } while (byte & 0x80);
+
+  return { value: result, bytesRead: shift / 7 };
+}
+
+function decodeFixed32(buffer, offset) {
+  if (offset + 4 > buffer.length) {
+    throw new Error('Buffer overflow while decoding fixed32');
+  }
+  return {
+    value: buffer.readUInt32LE(offset),
+    bytesRead: 4,
+  };
+}
+
+function decodeFixed64(buffer, offset) {
+  if (offset + 8 > buffer.length) {
+    throw new Error('Buffer overflow while decoding fixed64');
+  }
+  const low = buffer.readUInt32LE(offset);
+  const high = buffer.readUInt32LE(offset + 4);
+  return {
+    value: BigInt(high) * 2n ** 32n + BigInt(low),
+    bytesRead: 8,
+  };
+}
+
+function decodeString(buffer, offset, length) {
+  if (offset + length > buffer.length) {
+    throw new Error('Buffer overflow while decoding string');
+  }
+  return {
+    value: buffer.toString('utf8', offset, offset + length),
+    bytesRead: length,
+  };
+}
+
+function decodeField(buffer, offset) {
+  const tag = decodeVarint(buffer, offset);
+  offset += tag.bytesRead;
+
+  const fieldNumber = Number(tag.value >> 3n);
+  const wireType = Number(tag.value & 0x7n);
+
+  let value;
+  let bytesRead;
+
+  switch (wireType) {
+    case WIRE_TYPES.VARINT:
+      ({ value, bytesRead } = decodeVarint(buffer, offset));
+      break;
+    case WIRE_TYPES.FIXED64:
+      ({ value, bytesRead } = decodeFixed64(buffer, offset));
+      break;
+    case WIRE_TYPES.LENGTH_DELIMITED:
+      const length = decodeVarint(buffer, offset);
+      offset += length.bytesRead;
+      // Try to decode as a nested message first
+      try {
+        ({ value, bytesRead } = decodeProtobuf(
+          buffer.slice(offset, offset + Number(length.value)),
+        ));
+      } catch (e) {
+        // If it fails, decode as a string
+        ({ value, bytesRead } = decodeString(
+          buffer,
+          offset,
+          Number(length.value),
+        ));
+      }
+      bytesRead += length.bytesRead;
+      break;
+    case WIRE_TYPES.FIXED32:
+      ({ value, bytesRead } = decodeFixed32(buffer, offset));
+      break;
+    default:
+      throw new Error(`Unsupported wire type: ${wireType}`);
+  }
+
+  return {
+    fieldNumber,
+    wireType,
+    value,
+    bytesRead: tag.bytesRead + bytesRead,
+  };
+}
+
+function getFieldName(fieldNumber, wireType) {
+  const typePrefix =
+    wireType === WIRE_TYPES.LENGTH_DELIMITED
+      ? 'subMessage'
+      : wireType === WIRE_TYPES.VARINT
+        ? 'int'
+        : wireType === WIRE_TYPES.FIXED32
+          ? 'fixed32'
+          : wireType === WIRE_TYPES.FIXED64
+            ? 'fixed64'
+            : 'string';
+  return `${typePrefix}_${fieldNumber}`;
+}
+
+/**
+ * Decodes a protobuf message from the given buffer.
+ *
+ * @param {Buffer} buffer
+ */
+export function decodeProtobuf(buffer) {
+  let offset = 0;
+  const message = {};
+
+  while (offset < buffer.length) {
+    const field = decodeField(buffer, offset);
+    const fieldName = getFieldName(field.fieldNumber, field.wireType);
+    message[fieldName] = field.value;
+    offset += field.bytesRead;
+  }
+
+  return { value: message, bytesRead: offset };
+}
+/**
+ * Decodes a protobuf message from the given base64-encoded data.
+ *
+ * @param {string} base64String
+ */
+export function decodeProtobufBase64(base64String) {
+  const buffer = Buffer.from(base64String, 'base64');
+  return decodeProtobuf(buffer);
+}