npm - @agoric/vats - Versions diffs - 0.15.2-dev-00cccfc.0 → 0.15.2-dev-e2e36cc.0 - Mend

@agoric/vats 0.15.2-dev-00cccfc.0 → 0.15.2-dev-e2e36cc.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/package.json CHANGED Viewed

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

package/src/ibc.d.ts CHANGED Viewed

@@ -1,43 +1,61 @@
-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
-     * @param {Bytes} packetBytes
-     * @param {ConnectionHandler} _handler
-     * @param {object} root0
-     * @param {bigint} [root0.relativeTimeoutNs]
-     * @returns {PromiseVow<Bytes>} Acknowledgement data
-     */
-    onReceive(_conn: Connection, packetBytes: Bytes, _handler: ConnectionHandler, { relativeTimeoutNs }?: {
-        relativeTimeoutNs?: bigint | undefined;
-    }): PromiseVow<Bytes>;
-    onClose(_conn: any, _reason: any, _handler: any): Promise<void>;
+export function prepareIBCConnectionHandler(zone: Zone): (args_0: {
+    protocolUtils: any;
+    channelKeyToConnP: MapStore<string, import('@agoric/vow').Remote<Connection>>;
+    channelKeyToSeqAck: MapStore<string, MapStore<number, import('@agoric/vow').VowKit<Bytes>>>;
+}, args_1: {
+    channelID: `channel-${number}`;
+    portID: string;
+    rChannelID: `channel-${number}`;
+    rPortID: string;
+    order: 'ORDERED' | 'UNORDERED';
+}) => import("@endo/exo").Guarded<{
+    /** @type {Required<ConnectionHandler>['onOpen']} */
+    onOpen(connection: globalThis.Remote<Connection>, localAddr: string, remoteAddr: string, c: globalThis.Remote<ConnectionHandler>): PromiseVow<void>;
+    /** @type {Required<ConnectionHandler>['onReceive']} */
+    onReceive(connection: globalThis.Remote<Connection>, ack: string, c: globalThis.Remote<ConnectionHandler>, opts?: Record<string, any> | undefined): PromiseVow<string>;
+    /** @type {Required<ConnectionHandler>['onClose']} */
+    onClose(connection: globalThis.Remote<Connection>, reason?: any, c?: globalThis.Remote<ConnectionHandler> | undefined): PromiseVow<void>;
 }>;
 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>;
+    watch: <T_1 = unknown, TResult1_1 = T_1, TResult2_1 = T_1, C = unknown>(specimenP: import("@agoric/vow").ERef<T_1 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1, any> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<TResult1_1 | TResult2_1>;
     makeVowKit: <T_2>() => VowKit<T_2>;
     allVows: (vows: any) => import("@agoric/vow").Vow<any>;
-}): (ibcdev: any) => {
+}): (ibcdev: {
+    downcall: (method: string, args: object) => Promise<any>;
+}) => {
     protocolHandler: ProtocolHandler;
     bridgeHandler: BridgeHandler;
 } | {
     protocolHandler: import("@endo/exo").Guarded<{
-        onCreate(impl: any, _protocolHandler: any): Promise<void>;
-        onInstantiate(): Promise<string>;
-        generatePortID(_localAddr: any, _protocolHandler: any): Promise<string>;
-        onBind(port: any, localAddr: any, _protocolHandler: any): Promise<any>;
-        onConnect(port: any, localAddr: any, remoteAddr: any, _chandler: any, _protocolHandler: any): Promise<import("@agoric/vow").Vow<any>>;
-        onListen(_port: any, localAddr: any, _listenHandler: any): Promise<void>;
-        onListenRemove(_port: any, localAddr: any, _listenHandler: any): Promise<void>;
-        onRevoke(_port: any, localAddr: any, _protocolHandler: any): Promise<void>;
+        /** @type {Required<ProtocolHandler>['onCreate']} */
+        onCreate(protocol: globalThis.Remote<ProtocolImpl>, p: globalThis.Remote<ProtocolHandler>): PromiseVow<void>;
+        /** @type {Required<ProtocolHandler>['onInstantiate']} */
+        onInstantiate(port: globalThis.Remote<Port>, localAddr: string, remote: string, p: globalThis.Remote<ProtocolHandler>): PromiseVow<string>;
+        /** @type {Required<ProtocolHandler>['generatePortID']} */
+        generatePortID(localAddr: string, p: globalThis.Remote<ProtocolHandler>): PromiseVow<string>;
+        /** @type {Required<ProtocolHandler>['onBind']} */
+        onBind(port: globalThis.Remote<Port>, localAddr: string, p: globalThis.Remote<ProtocolHandler>): PromiseVow<void>;
+        /** @type {Required<ProtocolHandler>['onConnect']} */
+        onConnect(port: globalThis.Remote<Port>, localAddr: string, remote: string, c: globalThis.Remote<ConnectionHandler>, p: globalThis.Remote<ProtocolHandler>): PromiseVow<AttemptDescription>;
+        /** @type {Required<ProtocolHandler>['onListen']} */
+        onListen(port: globalThis.Remote<Port>, localAddr: string, listenHandler: globalThis.Remote<ListenHandler>, p: globalThis.Remote<ProtocolHandler>): PromiseVow<void>;
+        /** @type {Required<ProtocolHandler>['onListenRemove']} */
+        onListenRemove(port: globalThis.Remote<Port>, localAddr: string, listenHandler: globalThis.Remote<ListenHandler>, p: globalThis.Remote<ProtocolHandler>): PromiseVow<void>;
+        /** @type {Required<ProtocolHandler>['onRevoke']} */
+        onRevoke(port: globalThis.Remote<Port>, localAddr: string, p: globalThis.Remote<ProtocolHandler>): PromiseVow<void>;
     }>;
     bridgeHandler: import("@endo/exo").Guarded<{
-        fromBridge(obj: any): Promise<import("@agoric/vow").Vow<any> | undefined>;
+        /** @param {IBCEvent<IBCBridgeEvent>} obj */
+        fromBridge(obj: IBCEvent<IBCBridgeEvent>): Promise<import("@agoric/vow").Vow<any> | undefined>;
     }>;
 };
 export function prepareCallbacks(zone: Zone): (dibcBridgeManager: ScopedBridgeManager) => import("@endo/exo").Guarded<{
-    downcall(method: any, obj: any): Promise<any>;
+    /**
+     * @param {string} method
+     * @param {any} obj
+     */
+    downcall(method: string, obj: any): Promise<any>;
 }>;
 export type OnConnectP = {
     vow: import("@agoric/vow").Vow<AttemptDescription>;
@@ -53,6 +71,8 @@ export type Outbound = Omit<ConnectingInfo, "counterparty" | "channelID" | "coun
 import type { Zone } from '@agoric/base-zone';
 import type { VowKit } from '@agoric/vow';
 import type { BridgeHandler } from './types.js';
+import type { IBCBridgeEvent } from './types.js';
+import type { IBCEvent } from './types.js';
 import type { ScopedBridgeManager } from './types.js';
 import type { VowResolver } from '@agoric/vow';
 import type { ConnectingInfo } from './types.js';

package/src/ibc.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"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"}
1	+ {"version":3,"file":"ibc.d.ts","sourceRoot":"","sources":["ibc.js"],"names":[],"mappings":"AA6CO;mBAciB,GAAG;uBACC,SACvB,MAAY,EACZ,OAAa,aAAa,EAAE,MAAM,CAAC,UAAU,CAAC,CACzC;wBACmB,SACxB,MAAY,EACZ,SAAe,MAAM,EAAE,OAAO,aAAa,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CACtD;;;YAIO,MAAM;;aAEL,MAAM;WACR,SAAS,GAAG,WAAW;;IAuBjC,oDAAoD;;IAepD,uDAAuD;;IAoBvD,qDAAqD;;GA0B1D;AAMM;;;;;;cAOS,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,QAAQ,GAAG,CAAC;;qBAOpC,eAAe;;;;QAoDjC,oDAAoD;;QAKpD,yDAAyD;;QAKzD,0DAA0D;;QAK1D,kDAAkD;;QAalD,qDAAqD;;QAiDrD,oDAAoD;;QAIpD,0DAA0D;;QAI1D,oDAAoD;;;;QAgBpD,4CAA4C;;;EAudnD;AAIM;IAOD;;;OAGG;qBAFQ,MAAM,OACN,GAAG;GAYnB;;;;;;eArxBe,QAAQ;gBACP,UAAU;kBACR;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE;;0BAbf,mBAAmB;4BACc,aAAa;mCAFqI,YAAY;oCAAZ,YAAY;8BAAZ,YAAY;yCAAZ,YAAY;iCAE9J,aAAa;oCAFqI,YAAY"}

package/src/ibc.js CHANGED Viewed

@@ -7,6 +7,14 @@ import { dataToBase64, base64ToBytes } from '@agoric/network';
 import '@agoric/store/exported.js';
 import '@agoric/network/exported.js';
+import {
+  localAddrToPortID,
+  decodeRemoteIbcAddress,
+  encodeLocalIbcAddress,
+  encodeRemoteIbcAddress,
+} from '../tools/ibc-utils.js';
+/** @import {LocalIbcAddress, RemoteIbcAddress} from '../tools/ibc-utils.js' */
 // CAVEAT: IBC acks cannot be empty, as the Cosmos IAVL tree cannot represent
 // empty acknowledgements as distinct from unacknowledged packets.
@@ -16,14 +24,14 @@ const DEFAULT_ACKNOWLEDGEMENT = '\x00';
 const DEFAULT_PACKET_TIMEOUT_NS = 60n * 60n * 1_000_000_000n;
 /**
- * @import {BridgeHandler, ScopedBridgeManager, ConnectingInfo, IBCChannelID, IBCChannelOrdering, IBCEvent, IBCPacket, IBCPortID, IBCDowncall, IBCDowncallPacket, IBCDowncallMethod} from './types.js';
+ * @import {BridgeHandler, ScopedBridgeManager, ConnectingInfo, IBCChannelID, IBCChannelOrdering, IBCEvent, IBCPacket, IBCPortID, IBCDowncallPacket, IBCDowncallMethod, IBCDowncall, IBCBridgeEvent} from './types.js';
  * @import {Zone} from '@agoric/base-zone';
  * @import {Remote, VowKit, VowResolver, VowTools} from '@agoric/vow';
  */
+/** @typedef {VowKit<AttemptDescription>} OnConnectP */
 /**
- * @typedef {VowKit<AttemptDescription>} OnConnectP
- *
  * @typedef {Omit<
  *   ConnectingInfo,
  *   'counterparty' | 'channelID' | 'counterpartyVersion'
@@ -47,6 +55,26 @@ export const prepareIBCConnectionHandler = zone => {
   const makeIBCConnectionHandler = zone.exoClass(
     'IBCConnectionHandler',
     undefined,
+    /**
+     * @param {{
+     *   protocolUtils: any;
+     *   channelKeyToConnP: MapStore<
+     *     string,
+     *     import('@agoric/vow').Remote<Connection>
+     *   >;
+     *   channelKeyToSeqAck: MapStore<
+     *     string,
+     *     MapStore<number, import('@agoric/vow').VowKit<Bytes>>
+     *   >;
+     * }} param0
+     * @param {{
+     *   channelID: IBCChannelID;
+     *   portID: string;
+     *   rChannelID: IBCChannelID;
+     *   rPortID: string;
+     *   order: 'ORDERED' | 'UNORDERED';
+     * }} param1
+     */
     (
       { protocolUtils, channelKeyToConnP, channelKeyToSeqAck },
       { channelID, portID, rChannelID, rPortID, order },
@@ -67,6 +95,7 @@ export const prepareIBCConnectionHandler = zone => {
       };
     },
     {
+      /** @type {Required<ConnectionHandler>['onOpen']} */
       async onOpen(conn, localAddr, remoteAddr, _handler) {
         const { channelID, portID, channelKeyToConnP } = this.state;
@@ -81,14 +110,7 @@ export const prepareIBCConnectionHandler = zone => {
         channelKeyToConnP.init(channelKey, conn);
       },
-      /**
-       * @param {Connection} _conn
-       * @param {Bytes} packetBytes
-       * @param {ConnectionHandler} _handler
-       * @param {object} root0
-       * @param {bigint} [root0.relativeTimeoutNs]
-       * @returns {PromiseVow<Bytes>} Acknowledgement data
-       */
+      /** @type {Required<ConnectionHandler>['onReceive']} */
       async onReceive(
         _conn,
         packetBytes,
@@ -108,7 +130,8 @@ export const prepareIBCConnectionHandler = zone => {
         };
         return protocolUtils.ibcSendPacket(packet, relativeTimeoutNs);
       },
-      async onClose(_conn, _reason, _handler) {
+      /** @type {Required<ConnectionHandler>['onClose']} */
+      async onClose() {
         const { portID, channelID } = this.state;
         const { protocolUtils, channelKeyToSeqAck } = this.state;
@@ -166,12 +189,11 @@ export const prepareIBCProtocol = (zone, powers) => {
   /**
    * Create a handler for the IBC protocol, both from the network and from the
    * bridge.
-   *
-   * @param {IBCDevice} ibcdev
    */
   const makeIBCProtocolKit = zone.exoClassKit(
     'IBCProtocolHandler',
     undefined,
+    /** @param {IBCDevice} ibcdev */
     ibcdev => {
       /** @type {MapStore<string, Remote<Connection>>} */
       const channelKeyToConnP = detached.mapStore('channelKeyToConnP');
@@ -206,73 +228,46 @@ export const prepareIBCProtocol = (zone, powers) => {
     },
     {
       protocolHandler: {
-        async onCreate(impl, _protocolHandler) {
+        /** @type {Required<ProtocolHandler>['onCreate']} */
+        async onCreate(impl) {
           console.debug('IBC onCreate');
           this.state.protocolImpl = impl;
         },
+        /** @type {Required<ProtocolHandler>['onInstantiate']} */
         async onInstantiate() {
           // The IBC channel is not known until after handshake.
           return '';
         },
-        async generatePortID(_localAddr, _protocolHandler) {
+        /** @type {Required<ProtocolHandler>['generatePortID']} */
+        async generatePortID() {
           this.state.lastPortID += 1n;
           return `port-${this.state.lastPortID}`;
         },
-        async onBind(port, localAddr, _protocolHandler) {
+        /** @type {Required<ProtocolHandler>['onBind']} */
+        async onBind(_port, localAddr) {
           const { util } = this.facets;
           const { portToPendingConns } = this.state;
-          const portID = util.localAddrToPortID(localAddr);
+          // @ts-expect-error may not be LocalIbcAddress
+          const portID = localAddrToPortID(localAddr);
           portToPendingConns.init(portID, detached.setStore('pendingConns'));
           const packet = {
             source_port: portID,
           };
           return util.downcall('bindPort', { packet });
         },
-        async onConnect(
-          port,
-          localAddr,
-          remoteAddr,
-          _chandler,
-          _protocolHandler,
-        ) {
+        /** @type {Required<ProtocolHandler>['onConnect']} */
+        async onConnect(_port, localAddr, remoteAddr) {
           const { util } = this.facets;
           const { portToPendingConns, srcPortToOutbounds } = this.state;
           console.debug('IBC onConnect', localAddr, remoteAddr);
-          const portID = util.localAddrToPortID(localAddr);
+          // @ts-expect-error may not be LocalIbcAddress
+          const portID = localAddrToPortID(localAddr);
           const pendingConns = portToPendingConns.get(portID);
-          const match = remoteAddr.match(
-            /^(\/ibc-hop\/[^/]+)*\/ibc-port\/([^/]+)\/(ordered|unordered)\/([^/]+)$/s,
-          );
-          if (!match) {
-            throw TypeError(
-              `Remote address ${remoteAddr} must be '(/ibc-hop/CONNECTION)*/ibc-port/PORT/(ordered|unordered)/VERSION'`,
-            );
-          }
-          const hops = [];
-          let h = match[1];
-          while (h) {
-            const m = h.match(/^\/ibc-hop\/([^/]+)/);
-            if (!m) {
-              throw Error(
-                `internal: ${JSON.stringify(
-                  h,
-                )} did not begin with "/ibc-hop/XXX"`,
-              );
-            }
-            h = h.substr(m[0].length);
-            hops.push(m[1]);
-          }
-          // Generate a circuit.
-          /** @type {IBCPortID} */
-          const rPortID = match[2];
-          /** @type {IBCChannelOrdering} */
-          const order = match[3] === 'ordered' ? 'ORDERED' : 'UNORDERED';
-          const version = match[4];
+          const { rPortID, hops, order, version } =
+            decodeRemoteIbcAddress(remoteAddr);
           const kit = makeVowKit();
@@ -310,18 +305,20 @@ export const prepareIBCProtocol = (zone, powers) => {
           return kit.vow;
         },
-        async onListen(_port, localAddr, _listenHandler) {
+        /** @type {Required<ProtocolHandler>['onListen']} */
+        async onListen(_port, localAddr) {
           console.debug('IBC onListen', localAddr);
         },
-        async onListenRemove(_port, localAddr, _listenHandler) {
+        /** @type {Required<ProtocolHandler>['onListenRemove']} */
+        async onListenRemove(_port, localAddr) {
           console.debug('IBC onListenRemove', localAddr);
         },
-        async onRevoke(_port, localAddr, _protocolHandler) {
-          const { util } = this.facets;
+        /** @type {Required<ProtocolHandler>['onRevoke']} */
+        async onRevoke(_port, localAddr) {
           const { portToPendingConns } = this.state;
           console.debug('IBC onRevoke', localAddr);
-          const portID = util.localAddrToPortID(localAddr);
+          // @ts-expect-error may not be LocalIbcAddress
+          const portID = localAddrToPortID(localAddr);
           const pendingConns = portToPendingConns.get(portID);
           portToPendingConns.delete(portID);
@@ -332,6 +329,7 @@ export const prepareIBCProtocol = (zone, powers) => {
         },
       },
       bridgeHandler: {
+        /** @param {IBCEvent<IBCBridgeEvent>} obj */
         async fromBridge(obj) {
           const {
             protocolImpl,
@@ -348,7 +346,6 @@ export const prepareIBCProtocol = (zone, powers) => {
           await null;
           switch (obj.event) {
             case 'channelOpenInit': {
-              /** @type {IBCEvent<'channelOpenInit'>} */
               const {
                 channelID,
                 portID,
@@ -357,7 +354,7 @@ export const prepareIBCProtocol = (zone, powers) => {
                 order,
                 version,
                 asyncVersions,
-              } = obj;
+              } = /** @type {IBCEvent<'channelOpenInit'>} */ (obj);
               if (!asyncVersions) {
                 // Synchronous versions have already been negotiated.
                 break;
@@ -381,7 +378,6 @@ 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 },
@@ -389,11 +385,16 @@ export const prepareIBCProtocol = (zone, powers) => {
                 order,
                 version,
                 counterpartyVersion: rVersion,
-              } = obj;
+              } = /** @type {IBCEvent<'channelOpenTry'>} */ (obj);
-              const localAddr = `/ibc-port/${portID}/${order.toLowerCase()}/${version}`;
-              const ibcHops = hops.map(hop => `/ibc-hop/${hop}`).join('/');
-              const remoteAddr = `${ibcHops}/ibc-port/${rPortID}/${order.toLowerCase()}/${rVersion}/ibc-channel/${rChannelID}`;
+              const localAddr = encodeLocalIbcAddress(portID, order, version);
+              const remoteAddr = encodeRemoteIbcAddress(
+                hops,
+                rPortID,
+                order,
+                rVersion,
+                rChannelID,
+              );
               // See if we allow an inbound attempt for this address pair (without
               // rejecting).
@@ -420,14 +421,14 @@ export const prepareIBCProtocol = (zone, powers) => {
             case 'channelOpenAck': {
               // Complete the pending outbound connection.
-              /** @type {IBCEvent<'channelOpenAck'>} */
               const {
                 portID,
                 channelID,
                 counterparty: { port_id: rPortID, channel_id: rChannelID },
                 counterpartyVersion: rVersion,
                 connectionHops: rHops,
-              } = obj;
+              } = /** @type {IBCEvent<'channelOpenAck'>} */ (obj);
               const outbounds = this.state.srcPortToOutbounds.has(portID)
                 ? [...this.state.srcPortToOutbounds.get(portID)]
                 : [];
@@ -460,8 +461,13 @@ export const prepareIBCProtocol = (zone, powers) => {
               }
               // Finish the outbound connection.
-              const ibcHops = rHops.map(hop => `/ibc-hop/${hop}`).join('/');
-              const remoteAddress = `${ibcHops}/ibc-port/${rPortID}/${chanInfo.order.toLowerCase()}/${rVersion}/ibc-channel/${rChannelID}`;
+              const remoteAddress = encodeRemoteIbcAddress(
+                rHops,
+                rPortID,
+                chanInfo.order,
+                rVersion,
+                rChannelID,
+              );
               const localAddress = `${localAddr}/${chanInfo.order.toLowerCase()}/${rVersion}/ibc-channel/${channelID}`;
               const rchandler = makeIBCConnectionHandler(
                 {
@@ -486,8 +492,9 @@ export const prepareIBCProtocol = (zone, powers) => {
             }
             case 'channelOpenConfirm': {
-              /** @type {IBCEvent<'channelOpenConfirm'>} */
-              const { portID, channelID } = obj;
+              const { portID, channelID } =
+                /** @type {IBCEvent<'channelOpenConfirm'>} */ (obj);
               const channelKey = `${channelID}:${portID}`;
               channelKeyToAttempt.has(channelKey) ||
                 Fail`${channelKey}: did not expect channelOpenConfirm`;
@@ -525,8 +532,7 @@ export const prepareIBCProtocol = (zone, powers) => {
             }
             case 'receivePacket': {
-              /** @type {IBCEvent<'receivePacket'>} */
-              const { packet } = obj;
+              const { packet } = /** @type {IBCEvent<'receivePacket'>} */ (obj);
               const {
                 data: data64,
                 destination_port: portID,
@@ -542,26 +548,30 @@ export const prepareIBCProtocol = (zone, powers) => {
             }
             case 'acknowledgementPacket': {
-              /** @type {IBCEvent<'acknowledgementPacket'>} */
-              const { packet, acknowledgement } = obj;
+              const { packet, acknowledgement } =
+                /** @type {IBCEvent<'acknowledgementPacket'>} */ (obj);
               const {
                 sequence,
                 source_channel: channelID,
                 source_port: portID,
               } = packet;
+              if (sequence === undefined)
+                throw TypeError('acknowledgementPacket without sequence');
               const ackKit = util.findAckKit(channelID, portID, sequence);
               ackKit.resolver.resolve(base64ToBytes(acknowledgement));
               break;
             }
             case 'timeoutPacket': {
-              /** @type {IBCEvent<'timeoutPacket'>} */
-              const { packet } = obj;
+              const { packet } = /** @type {IBCEvent<'timeoutPacket'>} */ (obj);
               const {
                 sequence,
                 source_channel: channelID,
                 source_port: portID,
               } = packet;
+              if (sequence === undefined)
+                throw TypeError('timeoutPacket without sequence');
               const ackKit = util.findAckKit(channelID, portID, sequence);
               ackKit.resolver.reject(Error(`Packet timed out`));
               break;
@@ -569,7 +579,9 @@ export const prepareIBCProtocol = (zone, powers) => {
             case 'channelCloseInit':
             case 'channelCloseConfirm': {
-              const { portID, channelID } = obj;
+              const { portID, channelID } =
+                // could be either but that complicates line wrapping
+                /** @type {IBCEvent<'channelCloseInit'>} */ (obj);
               const channelKey = `${channelID}:${portID}`;
               if (channelKeyToConnP.has(channelKey)) {
                 const conn = channelKeyToConnP.get(channelKey);
@@ -580,8 +592,8 @@ export const prepareIBCProtocol = (zone, powers) => {
             }
             case 'sendPacket': {
-              /** @type {IBCEvent<'sendPacket'>} */
-              const { packet, relativeTimeoutNs } = obj;
+              const { packet, relativeTimeoutNs } =
+                /** @type {IBCEvent<'sendPacket'>} */ (obj);
               util.ibcSendPacket(packet, relativeTimeoutNs).then(
                 ack => console.info('Manual packet', packet, 'acked:', ack),
                 e => console.warn('Manual packet', packet, 'failed:', e),
@@ -633,17 +645,12 @@ export const prepareIBCProtocol = (zone, powers) => {
           const { vow } = util.findAckKit(channelID, portID, sequence);
           return vow;
         },
-        /** @param {string} localAddr */
-        localAddrToPortID(localAddr) {
-          const m = localAddr.match(/^\/ibc-port\/([-a-zA-Z0-9._+#[\]<>]+)$/);
-          if (!m) {
-            throw TypeError(
-              `Invalid port specification ${localAddr}; expected "/ibc-port/PORT"`,
-            );
-          }
-          return m[1];
-        },
+        /**
+         * @param {IBCChannelID} channelID
+         * @param {IBCPortID} portID
+         * @param {number} sequence
+         */
         findAckKit(channelID, portID, sequence) {
           const { channelKeyToSeqAck } = this.state;
           const channelKey = `${channelID}:${portID}`;
@@ -657,6 +664,10 @@ export const prepareIBCProtocol = (zone, powers) => {
         },
       },
       ackWatcher: {
+        /**
+         * @param {string} ack
+         * @param {{ packet: any }} watcherContext
+         */
         onFulfilled(ack, watcherContext) {
           const { packet } = watcherContext;
@@ -674,6 +685,21 @@ export const prepareIBCProtocol = (zone, powers) => {
         },
       },
       protocolImplAttemptWatcher: {
+        /**
+         * @param {string} attemptedLocal
+         * @param {{
+         *   channelID: IBCChannelID;
+         *   portID: string;
+         *   attempt: any;
+         *   obj: any;
+         *   asyncVersions: any;
+         *   rPortID: string;
+         *   rChannelID: IBCChannelID;
+         *   order: IBCChannelOrdering;
+         *   hops: any;
+         *   version: string;
+         * }} watcherContext
+         */
         onFulfilled(attemptedLocal, watcherContext) {
           const {
             channelID,
@@ -736,6 +762,10 @@ export const prepareIBCProtocol = (zone, powers) => {
         },
       },
       protocolImplInboundWatcher: {
+        /**
+         * @param {any} attempt
+         * @param {Record<string, any>} watchContext
+         */
         onFulfilled(attempt, watchContext) {
           const { obj } = watchContext;
@@ -754,11 +784,13 @@ export const prepareIBCProtocol = (zone, powers) => {
     },
   );
+  /** @param {IBCDevice} ibcdev */
   const makeIBCProtocolHandlerKit = ibcdev => {
     const { protocolHandler, bridgeHandler } = makeIBCProtocolKit(ibcdev);
     return harden({ protocolHandler, bridgeHandler });
   };
+  /** @param {IBCDevice} ibcdev */
   const provideIBCProtocolHandlerKit = ibcdev => {
     if (ibcdevToKit.has(ibcdev)) {
       return ibcdevToKit.get(ibcdev);
@@ -769,7 +801,6 @@ export const prepareIBCProtocol = (zone, powers) => {
   };
   return provideIBCProtocolHandlerKit;
 };
 harden(prepareIBCProtocol);
 /** @param {Zone} zone */
@@ -780,6 +811,10 @@ export const prepareCallbacks = zone => {
     /** @param {ScopedBridgeManager} dibcBridgeManager */
     dibcBridgeManager => ({ dibcBridgeManager }),
     {
+      /**
+       * @param {string} method
+       * @param {any} obj
+       */
       downcall(method, obj) {
         const { dibcBridgeManager } = this.state;
         return E(dibcBridgeManager).toBridge({

package/src/types.d.ts CHANGED Viewed

@@ -167,8 +167,8 @@ type IBCPacketEvents = {
   timeoutPacket: {
     packet: IBCPacket;
   };
-  channelCloseInit: {}; // TODO update
-  channelCloseConfirm: {}; // TODO update
+  channelCloseInit: ConnectingInfo; // TODO update
+  channelCloseConfirm: ConnectingInfo; // TODO update
   sendPacket: { relativeTimeoutNs: bigint; packet: IBCPacket };
 };

package/src/vat-ibc.d.ts CHANGED Viewed

@@ -4,21 +4,21 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
         bridgeHandler: import("./types.js").BridgeHandler;
     } | {
         protocolHandler: import("@endo/exo").Guarded<{
-            onCreate(impl: any, _protocolHandler: any): Promise<void>;
-            onInstantiate(): Promise<string>;
-            generatePortID(_localAddr: any, _protocolHandler: any): Promise<string>;
-            onBind(port: any, localAddr: any, _protocolHandler: any): Promise<any>;
-            onConnect(port: any, localAddr: any, remoteAddr: any, _chandler: any, _protocolHandler: any): Promise<import("@agoric/vow").Vow<any>>;
-            onListen(_port: any, localAddr: any, _listenHandler: any): Promise<void>;
-            onListenRemove(_port: any, localAddr: any, _listenHandler: any): Promise<void>;
-            onRevoke(_port: any, localAddr: any, _protocolHandler: any): Promise<void>;
+            onCreate(protocol: Remote<ProtocolImpl>, p: Remote<ProtocolHandler>): PromiseVow<void>;
+            onInstantiate(port: Remote<Port>, localAddr: string, remote: string, p: Remote<ProtocolHandler>): PromiseVow<string>;
+            generatePortID(localAddr: string, p: Remote<ProtocolHandler>): PromiseVow<string>;
+            onBind(port: Remote<Port>, localAddr: string, p: Remote<ProtocolHandler>): PromiseVow<void>;
+            onConnect(port: Remote<Port>, localAddr: string, remote: string, c: Remote<ConnectionHandler>, p: Remote<ProtocolHandler>): PromiseVow<AttemptDescription>;
+            onListen(port: Remote<Port>, localAddr: string, listenHandler: Remote<ListenHandler>, p: Remote<ProtocolHandler>): PromiseVow<void>;
+            onListenRemove(port: Remote<Port>, localAddr: string, listenHandler: Remote<ListenHandler>, p: Remote<ProtocolHandler>): PromiseVow<void>;
+            onRevoke(port: Remote<Port>, localAddr: string, p: Remote<ProtocolHandler>): PromiseVow<void>;
         }>;
         bridgeHandler: import("@endo/exo").Guarded<{
-            fromBridge(obj: any): Promise<import("@agoric/vow").Vow<any> | undefined>;
+            fromBridge(obj: import("./types.js").IBCEvent<import("./types.js").IBCBridgeEvent>): Promise<import("@agoric/vow").Vow<any> | undefined>;
         }>;
     };
     makeCallbacks: (dibcBridgeManager: import("./types.js").ScopedBridgeManager) => import("@endo/exo").Guarded<{
-        downcall(method: any, obj: any): Promise<any>;
+        downcall(method: string, obj: any): Promise<any>;
     }>;
 } & import("@endo/eventual-send").RemotableBrand<{}, {
     createHandlers: (callbacks: any) => {
@@ -26,21 +26,21 @@ export function buildRootObject(_vatPowers: any, _args: any, baggage: any): {
         bridgeHandler: import("./types.js").BridgeHandler;
     } | {
         protocolHandler: import("@endo/exo").Guarded<{
-            onCreate(impl: any, _protocolHandler: any): Promise<void>;
-            onInstantiate(): Promise<string>;
-            generatePortID(_localAddr: any, _protocolHandler: any): Promise<string>;
-            onBind(port: any, localAddr: any, _protocolHandler: any): Promise<any>;
-            onConnect(port: any, localAddr: any, remoteAddr: any, _chandler: any, _protocolHandler: any): Promise<import("@agoric/vow").Vow<any>>;
-            onListen(_port: any, localAddr: any, _listenHandler: any): Promise<void>;
-            onListenRemove(_port: any, localAddr: any, _listenHandler: any): Promise<void>;
-            onRevoke(_port: any, localAddr: any, _protocolHandler: any): Promise<void>;
+            onCreate(protocol: Remote<ProtocolImpl>, p: Remote<ProtocolHandler>): PromiseVow<void>;
+            onInstantiate(port: Remote<Port>, localAddr: string, remote: string, p: Remote<ProtocolHandler>): PromiseVow<string>;
+            generatePortID(localAddr: string, p: Remote<ProtocolHandler>): PromiseVow<string>;
+            onBind(port: Remote<Port>, localAddr: string, p: Remote<ProtocolHandler>): PromiseVow<void>;
+            onConnect(port: Remote<Port>, localAddr: string, remote: string, c: Remote<ConnectionHandler>, p: Remote<ProtocolHandler>): PromiseVow<AttemptDescription>;
+            onListen(port: Remote<Port>, localAddr: string, listenHandler: Remote<ListenHandler>, p: Remote<ProtocolHandler>): PromiseVow<void>;
+            onListenRemove(port: Remote<Port>, localAddr: string, listenHandler: Remote<ListenHandler>, p: Remote<ProtocolHandler>): PromiseVow<void>;
+            onRevoke(port: Remote<Port>, localAddr: string, p: Remote<ProtocolHandler>): PromiseVow<void>;
         }>;
         bridgeHandler: import("@endo/exo").Guarded<{
-            fromBridge(obj: any): Promise<import("@agoric/vow").Vow<any> | undefined>;
+            fromBridge(obj: import("./types.js").IBCEvent<import("./types.js").IBCBridgeEvent>): Promise<import("@agoric/vow").Vow<any> | undefined>;
         }>;
     };
     makeCallbacks: (dibcBridgeManager: import("./types.js").ScopedBridgeManager) => import("@endo/exo").Guarded<{
-        downcall(method: any, obj: any): Promise<any>;
+        downcall(method: string, obj: any): Promise<any>;
     }>;
 }>;
 //# sourceMappingURL=vat-ibc.d.ts.map

package/tools/ibc-utils.d.ts ADDED Viewed

@@ -0,0 +1,15 @@
+export const REMOTE_ADDR_RE: RegExp;
+/** @typedef {`/${string}ibc-port/${string}/${'ordered' | 'unordered'}/${string}`} RemoteIbcAddress */
+export const LOCAL_ADDR_RE: RegExp;
+export function decodeRemoteIbcAddress(remoteAddr: string): {
+    rPortID: string;
+    hops: `connection-${number}`[];
+    order: import("../src/types.js").IBCChannelOrdering;
+    version: string;
+};
+export function localAddrToPortID(localAddr: LocalIbcAddress): string;
+export function encodeRemoteIbcAddress(hops: string[], rPortID: string, order: 'ordered' | 'unordered' | 'ORDERED' | 'UNORDERED', rVersion: string, rChannelID: string): RemoteIbcAddress;
+export function encodeLocalIbcAddress(portID: string, order: 'ordered' | 'unordered' | 'ORDERED' | 'UNORDERED', version: string): string;
+export type RemoteIbcAddress = `/${string}ibc-port/${string}/${'ordered' | 'unordered'}/${string}`;
+export type LocalIbcAddress = `/ibc-port/${string}`;
+//# sourceMappingURL=ibc-utils.d.ts.map

package/tools/ibc-utils.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"ibc-utils.d.ts","sourceRoot":"","sources":["ibc-utils.js"],"names":[],"mappings":"AAAA,oCAC8G;AAE9G,sGAAsG;AAEtG,mCAA+E;AAIxE,mDADK,MAAM;;;;;EA8BjB;AAOM,6CAHI,eAAe,GACb,MAAM,CAWlB;AAWM,6CAPI,MAAM,EAAE,WACR,MAAM,SACN,SAAS,GAAG,WAAW,GAAG,SAAS,GAAG,WAAW,YACjD,MAAM,cACN,MAAM,GACJ,gBAAgB,CAa5B;AAQM,8CAJI,MAAM,SACN,SAAS,GAAG,WAAW,GAAG,SAAS,GAAG,WAAW,WACjD,MAAM,UAIhB;+BAnFa,IAAI,MAAM,YAAY,MAAM,IAAI,SAAS,GAAG,WAAW,IAAI,MAAM,EAAE;8BAGnE,aAAa,MAAM,EAAE"}

package/tools/ibc-utils.js ADDED Viewed

@@ -0,0 +1,89 @@
+export const REMOTE_ADDR_RE =
+  /^(?<hops>\/ibc-hop\/[^/]+)*\/ibc-port\/(?<portID>[^/]+)\/(?<order>ordered|unordered)\/(?<version>[^/]+)$/s;
+harden(REMOTE_ADDR_RE);
+/** @typedef {`/${string}ibc-port/${string}/${'ordered' | 'unordered'}/${string}`} RemoteIbcAddress */
+export const LOCAL_ADDR_RE = /^\/ibc-port\/(?<portID>[-a-zA-Z0-9._+#[\]<>]+)$/;
+/** @typedef {`/ibc-port/${string}`} LocalIbcAddress */
+/** @param {string} remoteAddr */
+export const decodeRemoteIbcAddress = remoteAddr => {
+  const match = remoteAddr.match(REMOTE_ADDR_RE);
+  // .groups is to inform TS https://github.com/microsoft/TypeScript/issues/32098
+  if (!(match && match.groups)) {
+    throw TypeError(
+      `Remote address ${remoteAddr} must be '(/ibc-hop/CONNECTION)*/ibc-port/PORT/(ordered|unordered)/VERSION'`,
+    );
+  }
+  /** @type {import('../src/types.js').IBCConnectionID[]} */
+  const hops = [];
+  let h = match.groups.hops;
+  while (h) {
+    const m = h.match(/^\/ibc-hop\/(?<hop>[^/]+)/);
+    if (!m) {
+      throw Error(
+        `internal: ${JSON.stringify(h)} did not begin with "/ibc-hop/XXX"`,
+      );
+    }
+    h = h.substr(m[0].length);
+    // @ts-expect-error unchecked cast
+    hops.push(m.groups.hop);
+  }
+  // Generate a circuit.
+  const { portID: rPortID, version } = match.groups;
+  /** @type {import('../src/types.js').IBCChannelOrdering} */
+  const order = match.groups.order === 'ordered' ? 'ORDERED' : 'UNORDERED';
+  return { rPortID, hops, order, version };
+};
+harden(decodeRemoteIbcAddress);
+/**
+ * @param {LocalIbcAddress} localAddr
+ * @returns {string}
+ */
+export const localAddrToPortID = localAddr => {
+  const m = localAddr.match(LOCAL_ADDR_RE);
+  // .groups is to inform TS https://github.com/microsoft/TypeScript/issues/32098
+  if (!(m && m.groups)) {
+    throw TypeError(
+      `Invalid port specification ${localAddr}; expected "/ibc-port/PORT"`,
+    );
+  }
+  return m.groups.portID;
+};
+harden(localAddrToPortID);
+/**
+ * @param {string[]} hops
+ * @param {string} rPortID
+ * @param {'ordered' | 'unordered' | 'ORDERED' | 'UNORDERED'} order
+ * @param {string} rVersion
+ * @param {string} rChannelID
+ * @returns {RemoteIbcAddress}
+ */
+export const encodeRemoteIbcAddress = (
+  hops,
+  rPortID,
+  order,
+  rVersion,
+  rChannelID,
+) => {
+  const ibcHops = hops.map(hop => `/ibc-hop/${hop}`).join('/');
+  return /** @type {RemoteIbcAddress} */ (
+    `${ibcHops}/ibc-port/${rPortID}/${order.toLowerCase()}/${rVersion}/ibc-channel/${rChannelID}`
+  );
+};
+harden(encodeRemoteIbcAddress);
+/**
+ * @param {string} portID
+ * @param {'ordered' | 'unordered' | 'ORDERED' | 'UNORDERED'} order
+ * @param {string} version
+ */
+export const encodeLocalIbcAddress = (portID, order, version) => {
+  return `/ibc-port/${portID}/${order.toLowerCase()}/${version}`;
+};
+harden(encodeLocalIbcAddress);