@agoric/vats 0.15.2-dev-81a66f2.0 → 0.15.2-dev-e468caa.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/vats",
-  "version": "0.15.2-dev-81a66f2.0+81a66f2",
+  "version": "0.15.2-dev-e468caa.0+e468caa",
   "description": "Agoric's Vat library",
   "type": "module",
   "main": "./index.js",
@@ -22,18 +22,19 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-81a66f2.0+81a66f2",
-    "@agoric/ertp": "0.16.3-dev-81a66f2.0+81a66f2",
-    "@agoric/governance": "0.10.4-dev-81a66f2.0+81a66f2",
-    "@agoric/internal": "0.3.3-dev-81a66f2.0+81a66f2",
-    "@agoric/network": "0.1.1-dev-81a66f2.0+81a66f2",
-    "@agoric/notifier": "0.6.3-dev-81a66f2.0+81a66f2",
-    "@agoric/store": "0.9.3-dev-81a66f2.0+81a66f2",
-    "@agoric/swingset-vat": "0.32.3-dev-81a66f2.0+81a66f2",
-    "@agoric/time": "0.3.3-dev-81a66f2.0+81a66f2",
-    "@agoric/vat-data": "0.5.3-dev-81a66f2.0+81a66f2",
-    "@agoric/zoe": "0.26.3-dev-81a66f2.0+81a66f2",
-    "@agoric/zone": "0.2.3-dev-81a66f2.0+81a66f2",
+    "@agoric/assert": "0.6.1-dev-e468caa.0+e468caa",
+    "@agoric/cosmic-proto": "0.4.1-dev-e468caa.0+e468caa",
+    "@agoric/ertp": "0.16.3-dev-e468caa.0+e468caa",
+    "@agoric/governance": "0.10.4-dev-e468caa.0+e468caa",
+    "@agoric/internal": "0.3.3-dev-e468caa.0+e468caa",
+    "@agoric/network": "0.1.1-dev-e468caa.0+e468caa",
+    "@agoric/notifier": "0.6.3-dev-e468caa.0+e468caa",
+    "@agoric/store": "0.9.3-dev-e468caa.0+e468caa",
+    "@agoric/swingset-vat": "0.32.3-dev-e468caa.0+e468caa",
+    "@agoric/time": "0.3.3-dev-e468caa.0+e468caa",
+    "@agoric/vat-data": "0.5.3-dev-e468caa.0+e468caa",
+    "@agoric/zoe": "0.26.3-dev-e468caa.0+e468caa",
+    "@agoric/zone": "0.2.3-dev-e468caa.0+e468caa",
     "@endo/far": "^1.1.1",
     "@endo/import-bundle": "^1.1.1",
     "@endo/marshal": "^1.4.1",
@@ -44,7 +45,7 @@
     "jessie.js": "^0.3.4"
   },
   "devDependencies": {
-    "@agoric/swingset-liveslots": "0.10.3-dev-81a66f2.0+81a66f2",
+    "@agoric/swingset-liveslots": "0.10.3-dev-e468caa.0+e468caa",
     "@endo/bundle-source": "^3.2.2",
     "@endo/init": "^1.1.1",
     "ava": "^5.3.0",
@@ -77,5 +78,5 @@
   "typeCoverage": {
     "atLeast": 89.58
   },
-  "gitHead": "81a66f2f88ba213ace95a598e9ef1f95b0ff9e39"
+  "gitHead": "e468caafe7b1bb0a4b105d2acadb30874c5c30d5"
 }

package/src/ibc.d.ts

@@ -1,4 +1,4 @@
-export function prepareIBCConnectionHandler(zone: import('@agoric/base-zone').Zone): (args_0?: any, args_1?: any) => import("@endo/exo").Guarded<{
+export function prepareIBCConnectionHandler(zone: Zone): (args_0?: any, args_1?: any) => import("@endo/exo").Guarded<{
     onOpen(conn: any, localAddr: any, remoteAddr: any, _handler: any): Promise<void>;
     /**
      * @param {Connection} _conn
@@ -13,15 +13,12 @@ export function prepareIBCConnectionHandler(zone: import('@agoric/base-zone').Zo
     }): PromiseVow<Bytes>;
     onClose(_conn: any, _reason: any, _handler: any): Promise<void>;
 }>;
-export function prepareIBCProtocol(zone: import('@agoric/base-zone').Zone, powers: ReturnType<(zone: import("@agoric/base-zone").Zone, powers?: {
-    isRetryableReason?: ((reason: any) => boolean) | undefined;
-    watchPromise?: ((p: PromiseLike<any>, watcher: import("@agoric/vow/src/watch-promise.js").PromiseWatcher, ...args: unknown[]) => void) | undefined;
-} | undefined) => {
+export function prepareIBCProtocol(zone: Zone, powers: {
     when: <T, TResult1 = import("@agoric/vow").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
     watch: <T_1 = any, TResult1_1 = T_1, TResult2_1 = T_1>(specimenP: import("@agoric/vow").ERef<T_1 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: unknown) => import("@agoric/vow").Vow<TResult1_1 | TResult2_1>;
-    makeVowKit: <T_2>() => import("@agoric/vow").VowKit<T_2>;
+    makeVowKit: <T_2>() => VowKit<T_2>;
     allVows: (vows: any) => import("@agoric/vow").Vow<any>;
-}>): (ibcdev: any) => {
+}): (ibcdev: any) => {
     protocolHandler: ProtocolHandler;
     bridgeHandler: BridgeHandler;
 } | {
@@ -39,38 +36,24 @@ export function prepareIBCProtocol(zone: import('@agoric/base-zone').Zone, power
         fromBridge(obj: any): Promise<import("@agoric/vow").Vow<any> | undefined>;
     }>;
 };
-export function prepareCallbacks(zone: import('@agoric/base-zone').Zone): (dibcBridgeManager: import("@agoric/vats").ScopedBridgeManager) => import("@endo/exo").Guarded<{
+export function prepareCallbacks(zone: Zone): (dibcBridgeManager: ScopedBridgeManager) => import("@endo/exo").Guarded<{
     downcall(method: any, obj: any): Promise<any>;
 }>;
-export type IBCPortID = string;
-export type IBCChannelID = string;
-export type IBCConnectionID = string;
-export type IBCPacket = {
-    data?: string | undefined;
-    source_channel: IBCChannelID;
-    source_port: IBCPortID;
-    destination_channel: IBCChannelID;
-    destination_port: IBCPortID;
+export type OnConnectP = {
+    vow: import("@agoric/vow").Vow<AttemptDescription>;
+    resolver: VowResolver<AttemptDescription>;
 };
-export type Counterparty = {
-    port_id: string;
-    channel_id: string;
-};
-export type ConnectingInfo = {
-    order: 'ORDERED' | 'UNORDERED';
-    connectionHops: string[];
-    portID: string;
-    channelID: string;
-    counterparty: Counterparty;
-    version: string;
-};
-export type OnConnectP = import('@agoric/vow').VowKit<AttemptDescription>;
-export type Outbound = Omit<ConnectingInfo, 'counterparty' | 'channelID'> & {
+export type Outbound = Omit<ConnectingInfo, "counterparty" | "channelID" | "counterpartyVersion"> & {
     localAddr: Endpoint;
     onConnectP: OnConnectP;
     counterparty: {
         port_id: string;
     };
 };
+import type { Zone } from '@agoric/base-zone';
+import type { VowKit } from '@agoric/vow';
 import type { BridgeHandler } from './types.js';
+import type { ScopedBridgeManager } from './types.js';
+import type { VowResolver } from '@agoric/vow';
+import type { ConnectingInfo } from './types.js';
 //# sourceMappingURL=ibc.d.ts.map

package/src/ibc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ibc.d.ts","sourceRoot":"","sources":["ibc.js"],"names":[],"mappings":"AA2DO,kDADK,OAAO,mBAAmB,EAAE,IAAI;;IA+CtC;;;;;;;OAOG;qBANQ,UAAU,eACV,KAAK,YACL,iBAAiB;QAEF,iBAAiB;QAC9B,WAAW,KAAK,CAAC;;GA6CnC;AAMM,yCAHI,OAAO,mBAAmB,EAAE,IAAI,UAChC;;;;;;;;EAAiD;qBAgBlC,eAAe;;;;;;;;;;;;;;;;EAsmBxC;AAKM,uCADK,OAAO,mBAAmB,EAAE,IAAI;;GAkB3C;wBAxxBY,MAAM;2BAEN,MAAM;8BAEN,MAAM;;;oBAML,YAAY;iBACZ,SAAS;yBACT,YAAY;sBACZ,SAAS;;;aAKT,MAAM;gBACN,MAAM;;;WAGN,SAAS,GAAG,WAAW;oBACvB,MAAM,EAAE;YACR,MAAM;eACN,MAAM;kBACN,YAAY;aACZ,MAAM;;yBAEP,OAAO,aAAa,EAAE,MAAM,CAAC,kBAAkB,CAAC;uBAEhD,KAAK,cAAc,EAAE,cAAc,GAAG,WAAW,CAAC,GAAG;IACjE,SAAa,EAAE,QAAQ,CAAC;IACxB,UAAc,EAAE,UAAU,CAAC;IAC3B,YAAgB,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CACnC;mCAtC6B,YAAY"}
+{"version":3,"file":"ibc.d.ts","sourceRoot":"","sources":["ibc.js"],"names":[],"mappings":"AAqCO;;IA8CD;;;;;;;OAOG;qBANQ,UAAU,eACV,KAAK,YACL,iBAAiB;QAEF,iBAAiB;QAC9B,WAAW,KAAK,CAAC;;GA8CnC;AAMM;;;;;;qBAcmB,eAAe;;;;;;;;;;;;;;;;EAumBxC;AAKM;;GAiBN;;;;;;eA1vBe,QAAQ;gBACP,UAAU;kBACR;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE;;0BAbf,mBAAmB;4BACc,aAAa;mCAFqH,YAAY;yCAAZ,YAAY;iCAE9I,aAAa;oCAFqH,YAAY"}

package/src/ibc.js

@@ -15,55 +15,33 @@ const DEFAULT_ACKNOWLEDGEMENT = '\x00';
 // Default timeout after 60 minutes.
 const DEFAULT_PACKET_TIMEOUT_NS = 60n * 60n * 1_000_000_000n;
 
-/** @import {BridgeHandler} from './types.js' */
-
-/**
- * @typedef {string} IBCPortID
- *
- * @typedef {string} IBCChannelID
- *
- * @typedef {string} IBCConnectionID
- */
-
 /**
- * @typedef {object} IBCPacket
- * @property {Bytes} [data]
- * @property {IBCChannelID} source_channel
- * @property {IBCPortID} source_port
- * @property {IBCChannelID} destination_channel
- * @property {IBCPortID} destination_port
+ * @import {BridgeHandler, ScopedBridgeManager, ConnectingInfo, IBCChannelID, IBCChannelOrdering, IBCEvent, IBCPacket, IBCPortID, IBCDowncall, IBCDowncallPacket, IBCDowncallMethod} from './types.js';
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {Remote, VowKit, VowResolver, VowTools} from '@agoric/vow';
  */
 
 /**
- * @typedef {object} Counterparty
- * @property {string} port_id
- * @property {string} channel_id
- *
- * @typedef {object} ConnectingInfo
- * @property {'ORDERED' | 'UNORDERED'} order
- * @property {string[]} connectionHops
- * @property {string} portID
- * @property {string} channelID
- * @property {Counterparty} counterparty
- * @property {string} version
- *
- * @typedef {import('@agoric/vow').VowKit<AttemptDescription>} OnConnectP
+ * @typedef {VowKit<AttemptDescription>} OnConnectP
  *
- * @typedef {Omit<ConnectingInfo, 'counterparty' | 'channelID'> & {
+ * @typedef {Omit<
+ *   ConnectingInfo,
+ *   'counterparty' | 'channelID' | 'counterpartyVersion'
+ * > & {
  *   localAddr: Endpoint;
  *   onConnectP: OnConnectP;
  *   counterparty: { port_id: string };
  * }} Outbound
  */
 
-/** @param {import('@agoric/base-zone').Zone} zone */
+/** @param {Zone} zone */
 export const prepareIBCConnectionHandler = zone => {
   /**
-   * @param {string} channelID
-   * @param {string} portID
-   * @param {string} rChannelID
-   * @param {string} rPortID
-   * @param {'ORDERED' | 'UNORDERED'} order
+   * @param {IBCChannelID} channelID
+   * @param {IBCPortID} portID
+   * @param {IBCChannelID} rChannelID
+   * @param {IBCPortID} rPortID
+   * @param {IBCChannelOrdering} order
    * @returns {ConnectionHandler}
    */
   const makeIBCConnectionHandler = zone.exoClass(
@@ -120,6 +98,7 @@ export const prepareIBCConnectionHandler = zone => {
         const { portID, channelID, rPortID, rChannelID } = this.state;
         const { protocolUtils } = this.state;
         // console.error(`Remote IBC Handler ${portID} ${channelID}`);
+        /** @type {IBCPacket} */
         const packet = {
           source_port: portID,
           source_channel: channelID,
@@ -157,8 +136,8 @@ export const prepareIBCConnectionHandler = zone => {
 };
 
 /**
- * @param {import('@agoric/base-zone').Zone} zone
- * @param {ReturnType<import('@agoric/vow').prepareVowTools>} powers
+ * @param {Zone} zone
+ * @param {VowTools} powers
  */
 export const prepareIBCProtocol = (zone, powers) => {
   const { makeVowKit, watch } = powers;
@@ -194,37 +173,22 @@ export const prepareIBCProtocol = (zone, powers) => {
     'IBCProtocolHandler',
     undefined,
     ibcdev => {
-      /** @type {MapStore<string, import('@agoric/vow').Remote<Connection>>} */
+      /** @type {MapStore<string, Remote<Connection>>} */
       const channelKeyToConnP = detached.mapStore('channelKeyToConnP');
 
       /** @type {MapStore<string, ConnectingInfo>} */
       const channelKeyToInfo = detached.mapStore('channelKeyToInfo');
 
-      /**
-       * @type {MapStore<
-       *   string,
-       *   import('@agoric/vow').Remote<InboundAttempt>
-       * >}
-       */
+      /** @type {MapStore<string, Remote<InboundAttempt>>} */
       const channelKeyToAttempt = detached.mapStore('channelKeyToAttempt');
 
       /** @type {MapStore<string, Outbound[]>} */
       const srcPortToOutbounds = detached.mapStore('srcPortToOutbounds');
 
-      /**
-       * @type {MapStore<
-       *   string,
-       *   MapStore<number, import('@agoric/vow').VowKit<Bytes>>
-       * >}
-       */
+      /** @type {MapStore<string, MapStore<number, VowKit<Bytes>>>} */
       const channelKeyToSeqAck = detached.mapStore('channelKeyToSeqAck');
 
-      /**
-       * @type {MapStore<
-       *   string,
-       *   SetStore<import('@agoric/vow').VowResolver>
-       * >}
-       */
+      /** @type {MapStore<string, SetStore<VowResolver>>} */
       const portToPendingConns = detached.mapStore('portToPendingConns');
 
       return {
@@ -236,7 +200,7 @@ export const prepareIBCProtocol = (zone, powers) => {
         channelKeyToSeqAck,
         portToPendingConns,
         lastPortID: 0n, // Nonce for creating port identifiers.
-        /** @type {import('@agoric/vow').Remote<ProtocolImpl> | null} */
+        /** @type {Remote<ProtocolImpl> | null} */
         protocolImpl: null,
       };
     },
@@ -304,7 +268,9 @@ export const prepareIBCProtocol = (zone, powers) => {
           }
 
           // Generate a circuit.
+          /** @type {IBCPortID} */
           const rPortID = match[2];
+          /** @type {IBCChannelOrdering} */
           const order = match[3] === 'ordered' ? 'ORDERED' : 'UNORDERED';
           const version = match[4];
 
@@ -329,6 +295,7 @@ export const prepareIBCProtocol = (zone, powers) => {
           }
 
           // Initialise the channel, which a listening relayer should pick up.
+          /** @type {IBCDowncallPacket<'startChannelOpenInit'>} */
           const packet = {
             source_port: portID,
             destination_port: rPortID,
@@ -381,6 +348,7 @@ export const prepareIBCProtocol = (zone, powers) => {
           await null;
           switch (obj.event) {
             case 'channelOpenInit': {
+              /** @type {IBCEvent<'channelOpenInit'>} */
               const {
                 channelID,
                 portID,
@@ -413,6 +381,7 @@ export const prepareIBCProtocol = (zone, powers) => {
             }
             case 'channelOpenTry': {
               // They're (more or less politely) asking if we are listening, so make an attempt.
+              /** @type {IBCEvent<'channelOpenTry'>} */
               const {
                 portID,
                 counterparty: { port_id: rPortID, channel_id: rChannelID },
@@ -451,6 +420,7 @@ export const prepareIBCProtocol = (zone, powers) => {
 
             case 'channelOpenAck': {
               // Complete the pending outbound connection.
+              /** @type {IBCEvent<'channelOpenAck'>} */
               const {
                 portID,
                 channelID,
@@ -516,6 +486,7 @@ export const prepareIBCProtocol = (zone, powers) => {
             }
 
             case 'channelOpenConfirm': {
+              /** @type {IBCEvent<'channelOpenConfirm'>} */
               const { portID, channelID } = obj;
               const channelKey = `${channelID}:${portID}`;
               channelKeyToAttempt.has(channelKey) ||
@@ -554,6 +525,7 @@ export const prepareIBCProtocol = (zone, powers) => {
             }
 
             case 'receivePacket': {
+              /** @type {IBCEvent<'receivePacket'>} */
               const { packet } = obj;
               const {
                 data: data64,
@@ -570,6 +542,7 @@ export const prepareIBCProtocol = (zone, powers) => {
             }
 
             case 'acknowledgementPacket': {
+              /** @type {IBCEvent<'acknowledgementPacket'>} */
               const { packet, acknowledgement } = obj;
               const {
                 sequence,
@@ -582,6 +555,7 @@ export const prepareIBCProtocol = (zone, powers) => {
             }
 
             case 'timeoutPacket': {
+              /** @type {IBCEvent<'timeoutPacket'>} */
               const { packet } = obj;
               const {
                 sequence,
@@ -606,6 +580,7 @@ export const prepareIBCProtocol = (zone, powers) => {
             }
 
             case 'sendPacket': {
+              /** @type {IBCEvent<'sendPacket'>} */
               const { packet, relativeTimeoutNs } = obj;
               util.ibcSendPacket(packet, relativeTimeoutNs).then(
                 ack => console.info('Manual packet', packet, 'acked:', ack),
@@ -621,6 +596,11 @@ export const prepareIBCProtocol = (zone, powers) => {
         },
       },
       util: {
+        /**
+         * @template {IBCDowncallMethod} M
+         * @param {M} method
+         * @param {IBCDowncall<M>} args
+         */
         downcall(method, args) {
           return E(this.state.ibcdev).downcall(method, args);
         },
@@ -649,7 +629,7 @@ export const prepareIBCProtocol = (zone, powers) => {
             source_port: portID,
           } = fullPacket;
 
-          /** @type {import('@agoric/vow').VowKit<Bytes>} */
+          /** @type {VowKit<Bytes>} */
           const { vow } = util.findAckKit(channelID, portID, sequence);
           return vow;
         },
@@ -792,12 +772,12 @@ export const prepareIBCProtocol = (zone, powers) => {
 
 harden(prepareIBCProtocol);
 
-/** @param {import('@agoric/base-zone').Zone} zone */
+/** @param {Zone} zone */
 export const prepareCallbacks = zone => {
   return zone.exoClass(
     'callbacks',
     undefined,
-    /** @param {import('@agoric/vats').ScopedBridgeManager} dibcBridgeManager */
+    /** @param {ScopedBridgeManager} dibcBridgeManager */
     dibcBridgeManager => ({ dibcBridgeManager }),
     {
       downcall(method, obj) {

package/src/localchain.d.ts

@@ -44,39 +44,40 @@ export function prepareLocalChainTools(zone: import('@agoric/base-zone').Zone):
                  */
                 deposit(payment: Payment): Promise<globalThis.Amount<globalThis.AssetKind>>;
                 /**
-                 * @param {Proto3Jsonable[]} messages
-                 * @returns {Promise<Proto3Jsonable[]>}
+                 * @param {import('@agoric/cosmic-proto').TypedJson<unknown>[]} messages
+                 * @returns {Promise<import('@agoric/cosmic-proto').TypedJson[]>}
                  */
-                executeTx(messages: Proto3Jsonable[]): Promise<Proto3Jsonable[]>;
+                executeTx(messages: import('@agoric/cosmic-proto').TypedJson<unknown>[]): Promise<import('@agoric/cosmic-proto').TypedJson[]>;
             }>>;
             /**
              * Make a single query to the local chain. Will reject with an error if
              * the query fails. Otherwise, return the response as a JSON-compatible
              * object.
              *
-             * @param {Proto3Jsonable} request
-             * @returns {Promise<Proto3Jsonable>}
+             * @param {import('@agoric/cosmic-proto').TypedJson} request
+             * @returns {Promise<import('@agoric/cosmic-proto').TypedJson>}
              */
-            query(request: Proto3Jsonable): Promise<Proto3Jsonable>;
+            query(request: import('@agoric/cosmic-proto').TypedJson): Promise<import('@agoric/cosmic-proto').TypedJson>;
             /**
              * Send a batch of query requests to the local chain. Unless there is a
              * system error, will return all results to indicate their success or
              * failure.
              *
-             * @param {Proto3Jsonable[]} requests
-             * @returns {Promise<{ error?: string; reply: Proto3Jsonable }[]>}
+             * @param {import('@agoric/cosmic-proto').TypedJson[]} requests
+             * @returns {Promise<
+             *   {
+             *     error?: string;
+             *     reply: import('@agoric/cosmic-proto').TypedJson;
+             *   }[]
+             * >}
              */
-            queryMany(requests: Proto3Jsonable[]): Promise<{
+            queryMany(requests: import('@agoric/cosmic-proto').TypedJson[]): Promise<{
                 error?: string;
-                reply: Proto3Jsonable;
+                reply: import('@agoric/cosmic-proto').TypedJson;
             }[]>;
         };
     }>;
 };
-export type Proto3Jsonable = {
-    '@type': string;
-    [x: string]: unknown;
-};
 export type LocalChainPowers = {
     system: import('./types.js').ScopedBridgeManager;
     bankManager: import('./vat-bank.js').BankManager;
@@ -98,10 +99,10 @@ declare function prepareLocalChainAccount(zone: import('@agoric/base-zone').Zone
      */
     deposit(payment: Payment): Promise<globalThis.Amount<globalThis.AssetKind>>;
     /**
-     * @param {Proto3Jsonable[]} messages
-     * @returns {Promise<Proto3Jsonable[]>}
+     * @param {import('@agoric/cosmic-proto').TypedJson<unknown>[]} messages
+     * @returns {Promise<import('@agoric/cosmic-proto').TypedJson[]>}
      */
-    executeTx(messages: Proto3Jsonable[]): Promise<Proto3Jsonable[]>;
+    executeTx(messages: import('@agoric/cosmic-proto').TypedJson<unknown>[]): Promise<import('@agoric/cosmic-proto').TypedJson[]>;
 }>;
 export {};
 //# sourceMappingURL=localchain.d.ts.map

package/src/localchain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localchain.d.ts","sourceRoot":"","sources":["localchain.js"],"names":[],"mappings":"AAoCA;;;;GAMG;AAqDH;;;;GAIG;AAEH;;;;GAIG;AAEH;;GAEG;AAiGI,6CADK,OAAO,mBAAmB,EAAE,IAAI;;;YAzEpC;;;;eAIG;;;;YAgBH;;;;;eAKG;;;gBAlGL;;;;;;mBAMG;iCADQ,OAAO;gBAYlB;;;mBAGG;oCAFQ,cAAc,EAAE,GACd,QAAQ,cAAc,EAAE,CAAC;;YAwFpC;;;;;;;eAOG;2BAFQ,cAAc,GACZ,QAAQ,cAAc,CAAC;YAapC;;;;;;;eAOG;gCAFQ,cAAc,EAAE,GACd,QAAQ;gBAAE,KAAK,CAAC,EAAE,MAAM,CAAC;gBAAC,KAAK,EAAE,cAAc,CAAA;aAAE,EAAE,CAAC;;;EAoBxE;6BA3MY;IACZ,OAAW,EAAE,MAAM,CAAC;IACpB,CAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACtB;+BAIS;IACZ,MAAU,EAAE,OAAO,YAAY,EAAE,mBAAmB,CAAC;IACrD,WAAe,EAAE,OAAO,eAAe,EAAE,WAAW,CAAC;CAClD;yBAES,SACZ,MAAU,gBAAgB,EAC1B,gBAAoB,CAAC,MAAM,gBAAgB,CAAC,CACzC;gCAyES,QACZ,WAAe,QAAQ,WAAW,+BAA+B,CAAC,CAAC,CAAC,CACjE;8BAoHU,WAAW,6BAA6B,CAAC;4BACzC,WAAW,eAAe,CAAC,gBAAgB,CAAC,CAAC;yBAC7C,aAAa,CAAC,QAAQ,CAAC;AA5KrC,qDAAqD;AACrD,gDADY,OAAO,mBAAmB,EAAE,IAAI;;IAetC;;;;;;OAMG;qBADQ,OAAO;IAYlB;;;OAGG;wBAFQ,cAAc,EAAE,GACd,QAAQ,cAAc,EAAE,CAAC;GAgBzC"}
+{"version":3,"file":"localchain.d.ts","sourceRoot":"","sources":["localchain.js"],"names":[],"mappings":"AA6BA;;;;GAMG;AAuDH;;;;GAIG;AAEH;;;;GAIG;AAEH;;GAEG;AAsGI,6CADK,OAAO,mBAAmB,EAAE,IAAI;;;YA9EpC;;;;eAIG;;;;YAgBH;;;;;eAKG;;;gBApGL;;;;;;mBAMG;iCADQ,OAAO;gBAYlB;;;mBAGG;oCAFQ,OAAO,sBAAsB,EAAE,SAAS,CAAC,OAAO,CAAC,EAAE,GACjD,QAAQ,OAAO,sBAAsB,EAAE,SAAS,EAAE,CAAC;;YA0F9D;;;;;;;eAOG;2BAFQ,OAAO,sBAAsB,EAAE,SAAS,GACtC,QAAQ,OAAO,sBAAsB,EAAE,SAAS,CAAC;YAa9D;;;;;;;;;;;;eAYG;gCAPQ,OAAO,sBAAsB,EAAE,SAAS,EAAE,GACxC,QACZ;gBACA,KAAW,CAAC,EAAE,MAAM,CAAC;gBACrB,KAAW,EAAE,OAAO,sBAAsB,EAAE,SAAS,CAAC;aACjD,EAAE,CACJ;;;EAoBX;+BA3MY;IACZ,MAAU,EAAE,OAAO,YAAY,EAAE,mBAAmB,CAAC;IACrD,WAAe,EAAE,OAAO,eAAe,EAAE,WAAW,CAAC;CAClD;yBAES,SACZ,MAAU,gBAAgB,EAC1B,gBAAoB,CAAC,MAAM,gBAAgB,CAAC,CACzC;gCA2ES,QACZ,WAAe,QAAQ,WAAW,+BAA+B,CAAC,CAAC,CAAC,CACjE;8BAyHU,WAAW,6BAA6B,CAAC;4BACzC,WAAW,eAAe,CAAC,gBAAgB,CAAC,CAAC;yBAC7C,aAAa,CAAC,QAAQ,CAAC;AAnLrC,qDAAqD;AACrD,gDADY,OAAO,mBAAmB,EAAE,IAAI;;IAetC;;;;;;OAMG;qBADQ,OAAO;IAYlB;;;OAGG;wBAFQ,OAAO,sBAAsB,EAAE,SAAS,CAAC,OAAO,CAAC,EAAE,GACjD,QAAQ,OAAO,sBAAsB,EAAE,SAAS,EAAE,CAAC;GAkBnE"}

package/src/localchain.js

@@ -5,13 +5,6 @@ import { AmountShape } from '@agoric/ertp';
 
 const { Fail, bare } = assert;
 
-/**
- * @typedef {{
- *   '@type': string;
- *   [x: string]: unknown;
- * }} Proto3Jsonable
- */
-
 /**
  * @typedef {{
  *   system: import('./types.js').ScopedBridgeManager;
@@ -75,11 +68,13 @@ const prepareLocalChainAccount = zone =>
         return E(allegedPurse).deposit(payment);
       },
       /**
-       * @param {Proto3Jsonable[]} messages
-       * @returns {Promise<Proto3Jsonable[]>}
+       * @param {import('@agoric/cosmic-proto').TypedJson<unknown>[]} messages
+       * @returns {Promise<import('@agoric/cosmic-proto').TypedJson[]>}
        */
       async executeTx(messages) {
         const { address, powers } = this.state;
+        messages.length > 0 || Fail`need at least one message to execute`;
+
         const obj = {
           type: 'VLOCALCHAIN_EXECUTE_TX',
           // This address is the only one that `VLOCALCHAIN_EXECUTE_TX` will
@@ -169,8 +164,8 @@ const prepareLocalChain = (zone, createAccount) =>
          * the query fails. Otherwise, return the response as a JSON-compatible
          * object.
          *
-         * @param {Proto3Jsonable} request
-         * @returns {Promise<Proto3Jsonable>}
+         * @param {import('@agoric/cosmic-proto').TypedJson} request
+         * @returns {Promise<import('@agoric/cosmic-proto').TypedJson>}
          */
         async query(request) {
           const requests = harden([request]);
@@ -188,8 +183,13 @@ const prepareLocalChain = (zone, createAccount) =>
          * system error, will return all results to indicate their success or
          * failure.
          *
-         * @param {Proto3Jsonable[]} requests
-         * @returns {Promise<{ error?: string; reply: Proto3Jsonable }[]>}
+         * @param {import('@agoric/cosmic-proto').TypedJson[]} requests
+         * @returns {Promise<
+         *   {
+         *     error?: string;
+         *     reply: import('@agoric/cosmic-proto').TypedJson;
+         *   }[]
+         * >}
          */
         async queryMany(requests) {
           const { powers } = this.state;

package/src/proposals/localchain-proposal.d.ts

@@ -68,12 +68,24 @@ export type LocalChainVats = {
                 createAccount(): Promise<import("@endo/exo").Guarded<{
                     getAddress(): Promise<string>;
                     deposit(payment: globalThis.Payment): Promise<globalThis.Amount<globalThis.AssetKind>>;
-                    executeTx(messages: import("../localchain.js").Proto3Jsonable[]): Promise<import("../localchain.js").Proto3Jsonable[]>;
+                    executeTx(messages: {
+                        '@type': string;
+                    }[]): Promise<{
+                        '@type': string;
+                    }[]>;
                 }>>;
-                query(request: import("../localchain.js").Proto3Jsonable): Promise<import("../localchain.js").Proto3Jsonable>;
-                queryMany(requests: import("../localchain.js").Proto3Jsonable[]): Promise<{
+                query(request: {
+                    '@type': string;
+                }): Promise<{
+                    '@type': string;
+                }>;
+                queryMany(requests: {
+                    '@type': string;
+                }[]): Promise<{
                     error?: string | undefined;
-                    reply: import("../localchain.js").Proto3Jsonable;
+                    reply: {
+                        '@type': string;
+                    };
                 }[]>;
             };
         }>;
@@ -86,12 +98,24 @@ export type LocalChainVats = {
                 createAccount(): Promise<import("@endo/exo").Guarded<{
                     getAddress(): Promise<string>;
                     deposit(payment: globalThis.Payment): Promise<globalThis.Amount<globalThis.AssetKind>>;
-                    executeTx(messages: import("../localchain.js").Proto3Jsonable[]): Promise<import("../localchain.js").Proto3Jsonable[]>;
+                    executeTx(messages: {
+                        '@type': string;
+                    }[]): Promise<{
+                        '@type': string;
+                    }[]>;
                 }>>;
-                query(request: import("../localchain.js").Proto3Jsonable): Promise<import("../localchain.js").Proto3Jsonable>;
-                queryMany(requests: import("../localchain.js").Proto3Jsonable[]): Promise<{
+                query(request: {
+                    '@type': string;
+                }): Promise<{
+                    '@type': string;
+                }>;
+                queryMany(requests: {
+                    '@type': string;
+                }[]): Promise<{
                     error?: string | undefined;
-                    reply: import("../localchain.js").Proto3Jsonable;
+                    reply: {
+                        '@type': string;
+                    };
                 }[]>;
             };
         }>;

package/src/proposals/localchain-test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localchain-test.d.ts","sourceRoot":"","sources":["localchain-test.js"],"names":[],"mappings":"AAYO,0EARI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,UAAgB,EAAE,OAAO,kBAAkB,EAAE,UAAU,CAAC;KACnD,CAAC;CACH;IAE2C,OAAO,EAA3C;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE;kBA2DpC;AAEM;;;;;;;;;;;;;;EAYL"}
+{"version":3,"file":"localchain-test.d.ts","sourceRoot":"","sources":["localchain-test.js"],"names":[],"mappings":"AAaO,0EARI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,UAAgB,EAAE,OAAO,kBAAkB,EAAE,UAAU,CAAC;KACnD,CAAC;CACH;IAE2C,OAAO,EAA3C;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE;kBA4DpC;AAEM;;;;;;;;;;;;;;EAYL"}

package/src/proposals/localchain-test.js

@@ -1,5 +1,6 @@
 // @ts-check
 import { E } from '@endo/far';
+import { typedJson } from '@agoric/cosmic-proto';
 
 /**
  * @param {BootstrapPowers & {
@@ -31,19 +32,20 @@ export const testLocalChain = async (
     console.info('created account', lca);
     const address = await E(lca).getAddress();
     console.info('address', address);
-    const balances = await E(localchain).query({
-      '@type': '/cosmos.bank.v1beta1.QueryAllBalancesRequest',
+
+    const queryMsg = typedJson('/cosmos.bank.v1beta1.QueryAllBalancesRequest', {
       address,
     });
+    const balances = await E(localchain).query(queryMsg);
     console.info('balances', balances);
+
     await E(lca)
       .executeTx([
-        {
-          '@type': '/cosmos.bank.v1beta1.MsgSend',
-          from_address: address,
-          to_address: address,
+        typedJson('/cosmos.bank.v1beta1.MsgSend', {
+          fromAddress: address,
+          toAddress: address,
           amount: [{ denom: 'ucosm', amount: '1' }],
-        },
+        }),
       ])
       .then(
         res => console.info('unexpected executeTx result', res),

package/src/types.d.ts

@@ -105,3 +105,140 @@ export type BridgeManager = {
     handler?: ERef<BridgeHandler | undefined>,
   ) => ScopedBridgeManager;
 };
+
+export type IBCPortID = string;
+export type IBCChannelID = `channel-${number}`;
+export type IBCConnectionID = `connection-${number}`;
+export type IBCChannelOrdering = 'ORDERED' | 'UNORDERED';
+
+export type IBCPacket = {
+  data: Bytes;
+  source_channel: IBCChannelID;
+  source_port: IBCPortID;
+  destination_channel: IBCChannelID;
+  destination_port: IBCPortID;
+  sequence?: number;
+  timeout_height?: number;
+  timeout_timestamp?: number;
+};
+
+export type IBCCounterParty = {
+  port_id: IBCPortID;
+  channel_id: IBCChannelID;
+};
+
+export type ConnectingInfo = {
+  order: IBCChannelOrdering;
+  connectionHops: IBCConnectionID[];
+  portID: IBCPortID;
+  channelID: IBCChannelID;
+  counterparty: IBCCounterParty;
+  counterpartyVersion: string;
+  version: string;
+  asyncVersions?: boolean;
+};
+
+/** see [ibc_module.go](../../../golang/cosmos/x/vibc/types/ibc_module.go) */
+type IBCBridgeEvent =
+  | 'channelOpenInit'
+  | 'channelOpenTry'
+  | 'channelOpenAck'
+  | 'channelOpenConfirm'
+  | 'receivePacket'
+  | 'acknowledgementPacket'
+  | 'timeoutPacket'
+  | 'channelCloseInit'
+  | 'channelCloseConfirm'
+  | 'sendPacket';
+
+type IBCPacketEvents = {
+  channelOpenInit: ConnectingInfo;
+  channelOpenTry: ConnectingInfo;
+  channelOpenAck: ConnectingInfo;
+  channelOpenConfirm: ConnectingInfo;
+  receivePacket: {
+    packet: IBCPacket;
+  };
+  acknowledgementPacket: {
+    acknowledgement: Bytes;
+    packet: IBCPacket;
+    relayer: string; // chain address
+  };
+  timeoutPacket: {
+    packet: IBCPacket;
+  };
+  channelCloseInit: {}; // TODO update
+  channelCloseConfirm: {}; // TODO update
+  sendPacket: { relativeTimeoutNs: bigint; packet: IBCPacket };
+};
+
+export type IBCEvent<E extends IBCBridgeEvent> = {
+  type: 'IBC_EVENT';
+  blockHeight: number;
+  blockTime: number;
+  event: E;
+} & {
+  [K in keyof IBCPacketEvents[E]]: IBCPacketEvents[E][K];
+};
+
+/** see [receiver.go](../../../golang/cosmos/x/vibc/types/receiver.go) */
+type IBCDowncallMethod =
+  | 'sendPacket'
+  | 'tryOpenExecuted'
+  | 'receiveExecuted'
+  | 'startChannelOpenInit'
+  | 'startChannelCloseInit'
+  | 'bindPort'
+  | 'timeoutExecuted'
+  | 'initOpenExecuted';
+
+type IBCMethodEvents = {
+  sendPacket: SendPacketDownCall;
+  tryOpenExecuted: ChannelOpenAckDowncall;
+  receiveExecuted: {}; // TODO update
+  startChannelOpenInit: ChannelOpenInitDowncall;
+  startChannelCloseInit: {}; // TODO update
+  bindPort: {}; // TODO update
+  timeoutExecuted: {}; // TODO update
+  // XXX why isn't this in receiver.go?
+  initOpenExecuted: ChannelOpenAckDowncall;
+};
+
+export type IBCMethod<M extends IBCDowncallMethod> = {
+  type: 'IBC_METHOD';
+  method: M;
+} & {
+  [K in keyof IBCMethodEvents[M]]: IBCMethodEvents[M][K];
+};
+
+export type IBCDowncall<M extends IBCDowncallMethod> = {
+  [K in keyof IBCMethodEvents[M]]: IBCMethodEvents[M][K];
+};
+
+export type IBCDowncallPacket<M extends IBCDowncallMethod> =
+  IBCMethodEvents[M] extends { packet: infer P } ? P : never;
+
+type ChannelOpenDowncallBase = {
+  hops: IBCConnectionID[];
+  order: IBCChannelOrdering;
+  version: string;
+};
+
+type ChannelOpenInitDowncall = ChannelOpenDowncallBase & {
+  packet: Pick<IBCPacket, 'destination_port' | 'source_port'>;
+};
+
+type ChannelOpenAckDowncall = ChannelOpenDowncallBase & {
+  packet: Pick<
+    IBCPacket,
+    | 'destination_port'
+    | 'source_port'
+    | 'destination_channel'
+    | 'source_channel'
+  >;
+};
+
+type SendPacketDownCall = {
+  packet: IBCPacket;
+  relativeTimeoutNs: bigint;
+};

package/src/vat-localchain.d.ts

@@ -13,12 +13,24 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
             createAccount(): Promise<import("@endo/exo").Guarded<{
                 getAddress(): Promise<string>;
                 deposit(payment: globalThis.Payment): Promise<globalThis.Amount<globalThis.AssetKind>>;
-                executeTx(messages: import("./localchain.js").Proto3Jsonable[]): Promise<import("./localchain.js").Proto3Jsonable[]>;
+                executeTx(messages: {
+                    '@type': string;
+                }[]): Promise<{
+                    '@type': string;
+                }[]>;
             }>>;
-            query(request: import("./localchain.js").Proto3Jsonable): Promise<import("./localchain.js").Proto3Jsonable>;
-            queryMany(requests: import("./localchain.js").Proto3Jsonable[]): Promise<{
+            query(request: {
+                '@type': string;
+            }): Promise<{
+                '@type': string;
+            }>;
+            queryMany(requests: {
+                '@type': string;
+            }[]): Promise<{
                 error?: string | undefined;
-                reply: import("./localchain.js").Proto3Jsonable;
+                reply: {
+                    '@type': string;
+                };
             }[]>;
         };
     }>;
@@ -37,12 +49,24 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
             createAccount(): Promise<import("@endo/exo").Guarded<{
                 getAddress(): Promise<string>;
                 deposit(payment: globalThis.Payment): Promise<globalThis.Amount<globalThis.AssetKind>>;
-                executeTx(messages: import("./localchain.js").Proto3Jsonable[]): Promise<import("./localchain.js").Proto3Jsonable[]>;
+                executeTx(messages: {
+                    '@type': string;
+                }[]): Promise<{
+                    '@type': string;
+                }[]>;
             }>>;
-            query(request: import("./localchain.js").Proto3Jsonable): Promise<import("./localchain.js").Proto3Jsonable>;
-            queryMany(requests: import("./localchain.js").Proto3Jsonable[]): Promise<{
+            query(request: {
+                '@type': string;
+            }): Promise<{
+                '@type': string;
+            }>;
+            queryMany(requests: {
+                '@type': string;
+            }[]): Promise<{
                 error?: string | undefined;
-                reply: import("./localchain.js").Proto3Jsonable;
+                reply: {
+                    '@type': string;
+                };
             }[]>;
         };
     }>;

package/src/vat-localchain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vat-localchain.d.ts","sourceRoot":"","sources":["vat-localchain.js"],"names":[],"mappings":"AAMO;IAKH;;;;;OAKG;;;;;;;;;;;;;;;;;;;IALH;;;;;OAKG;;;;;;;;;;;;;;;;;;GAKN;4BAEa,WAAW,sBAAsB,CAAC"}
+{"version":3,"file":"vat-localchain.d.ts","sourceRoot":"","sources":["vat-localchain.js"],"names":[],"mappings":"AAMO;IAKH;;;;;OAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IALH;;;;;OAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAKN;4BAEa,WAAW,sBAAsB,CAAC"}