@agoric/orchestration 0.1.1-dev-ad4cd18.0.ad4cd18 → 0.1.1-dev-a6c0604.0.a6c0604

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/orchestration",
-  "version": "0.1.1-dev-ad4cd18.0.ad4cd18",
+  "version": "0.1.1-dev-a6c0604.0.a6c0604",
   "description": "Chain abstraction for Agoric's orchestration clients",
   "type": "module",
   "main": "index.js",
@@ -35,19 +35,19 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/async-flow": "0.1.1-dev-ad4cd18.0.ad4cd18",
-    "@agoric/cosmic-proto": "0.4.1-dev-ad4cd18.0.ad4cd18",
-    "@agoric/ertp": "0.16.3-dev-ad4cd18.0.ad4cd18",
-    "@agoric/internal": "0.3.3-dev-ad4cd18.0.ad4cd18",
-    "@agoric/network": "0.1.1-dev-ad4cd18.0.ad4cd18",
-    "@agoric/notifier": "0.6.3-dev-ad4cd18.0.ad4cd18",
-    "@agoric/store": "0.9.3-dev-ad4cd18.0.ad4cd18",
-    "@agoric/time": "0.3.3-dev-ad4cd18.0.ad4cd18",
-    "@agoric/vat-data": "0.5.3-dev-ad4cd18.0.ad4cd18",
-    "@agoric/vats": "0.15.2-dev-ad4cd18.0.ad4cd18",
-    "@agoric/vow": "0.1.1-dev-ad4cd18.0.ad4cd18",
-    "@agoric/zoe": "0.26.3-dev-ad4cd18.0.ad4cd18",
-    "@agoric/zone": "0.2.3-dev-ad4cd18.0.ad4cd18",
+    "@agoric/async-flow": "0.1.1-dev-a6c0604.0.a6c0604",
+    "@agoric/cosmic-proto": "0.4.1-dev-a6c0604.0.a6c0604",
+    "@agoric/ertp": "0.16.3-dev-a6c0604.0.a6c0604",
+    "@agoric/internal": "0.3.3-dev-a6c0604.0.a6c0604",
+    "@agoric/network": "0.1.1-dev-a6c0604.0.a6c0604",
+    "@agoric/notifier": "0.6.3-dev-a6c0604.0.a6c0604",
+    "@agoric/store": "0.9.3-dev-a6c0604.0.a6c0604",
+    "@agoric/time": "0.3.3-dev-a6c0604.0.a6c0604",
+    "@agoric/vat-data": "0.5.3-dev-a6c0604.0.a6c0604",
+    "@agoric/vats": "0.15.2-dev-a6c0604.0.a6c0604",
+    "@agoric/vow": "0.1.1-dev-a6c0604.0.a6c0604",
+    "@agoric/zoe": "0.26.3-dev-a6c0604.0.a6c0604",
+    "@agoric/zone": "0.2.3-dev-a6c0604.0.a6c0604",
     "@cosmjs/encoding": "^0.36.0",
     "@endo/base64": "^1.0.12",
     "@endo/errors": "^1.2.13",
@@ -61,7 +61,7 @@
     "bs58": "^6.0.0"
   },
   "devDependencies": {
-    "@agoric/swingset-liveslots": "0.10.3-dev-ad4cd18.0.ad4cd18",
+    "@agoric/swingset-liveslots": "0.10.3-dev-a6c0604.0.a6c0604",
     "@chain-registry/client": "^1.53.194",
     "@cosmjs/amino": "^0.36.0",
     "@cosmjs/proto-signing": "^0.36.0",
@@ -105,5 +105,5 @@
   "typeCoverage": {
     "atLeast": 97.65
   },
-  "gitHead": "ad4cd18c77a8603359827fbe5054c91a2f7211e3"
+  "gitHead": "a6c06040100171553fdf07d11e906d073c019dee"
 }

package/tools/contract-tests.d.ts.map

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

package/tools/contract-tests.ts

@@ -6,7 +6,7 @@ import {
   makeAsyncQueue,
   makeFakeStorageKit,
 } from '@agoric/internal/src/storage-test-utils.js';
-import { setupFakeNetwork } from '@agoric/orchestration/test/network-fakes.js';
+import { setupFakeNetwork } from '@agoric/orchestration/tools/network-fakes.js';
 import { eventLoopIteration } from '@agoric/internal/src/testing-utils.js';
 import { buildVTransferEvent } from '@agoric/orchestration/tools/ibc-mocks.js';
 import {

package/tools/ibc-mock-fixtures.d.ts

@@ -0,0 +1,49 @@
+/**
+ * TODO: provide mappings to cosmos error codes (and module specific error codes)
+ * see https://github.com/Agoric/agoric-sdk/issues/9629 for more details about
+ * error messages over ibc
+ */
+export declare const errorAcknowledgments: {
+    error5: string;
+};
+export declare const UNBOND_PERIOD_SECONDS = 5n;
+export declare const protoMsgMocks: {
+    delegate: {
+        msg: string;
+        ack: string;
+    };
+    undelegate: {
+        msg: string;
+        ack: string;
+    };
+    redelegate: {
+        msg: string;
+        ack: string;
+    };
+    withdrawReward: {
+        msg: string;
+        ack: string;
+    };
+    queryBalance: {
+        msg: string;
+        ack: string;
+    };
+    bankSend: {
+        msg: string;
+        ack: string;
+    };
+    bankSendMulti: {
+        msg: string;
+        ack: string;
+    };
+    depositForBurn: {
+        msg: string;
+        ack: string;
+    };
+    depositForBurnForBase: {
+        msg: string;
+        ack: string;
+    };
+};
+export declare const defaultMockAckMap: Record<string, string>;
+//# sourceMappingURL=ibc-mock-fixtures.d.ts.map

package/tools/ibc-mock-fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ibc-mock-fixtures.d.ts","sourceRoot":"","sources":["ibc-mock-fixtures.ts"],"names":[],"mappings":"AAoCA;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;CAIhC,CAAC;AAiCF,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAOxC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwEzB,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CACpB,CAAC"}

package/tools/ibc-mock-fixtures.ts

@@ -0,0 +1,161 @@
+/** @file Canned IBC message and acknowledgement fixtures for tests and fakes */
+import {
+  QueryBalanceRequest,
+  QueryBalanceResponse,
+} from '@agoric/cosmic-proto/cosmos/bank/v1beta1/query.js';
+import {
+  MsgSend,
+  MsgSendResponse,
+} from '@agoric/cosmic-proto/cosmos/bank/v1beta1/tx.js';
+import {
+  MsgDepositForBurn,
+  MsgDepositForBurnResponse,
+} from '@agoric/cosmic-proto/circle/cctp/v1/tx.js';
+import {
+  MsgWithdrawDelegatorReward,
+  MsgWithdrawDelegatorRewardResponse,
+} from '@agoric/cosmic-proto/cosmos/distribution/v1beta1/tx.js';
+import type { Timestamp } from '@agoric/cosmic-proto/google/protobuf/timestamp.js';
+import {
+  MsgBeginRedelegate,
+  MsgBeginRedelegateResponse,
+  MsgDelegate,
+  MsgDelegateResponse,
+  MsgUndelegate,
+  MsgUndelegateResponse,
+} from '@agoric/cosmic-proto/cosmos/staking/v1beta1/tx.js';
+import {
+  buildMsgErrorString,
+  buildMsgResponseString,
+  buildQueryPacketString,
+  buildQueryResponseString,
+  buildTxPacketString,
+  createMockAckMap,
+} from './ibc-mocks.js';
+import { leftPadEthAddressTo32Bytes } from '../src/utils/address.js';
+
+/**
+ * TODO: provide mappings to cosmos error codes (and module specific error codes)
+ * see https://github.com/Agoric/agoric-sdk/issues/9629 for more details about
+ * error messages over ibc
+ */
+export const errorAcknowledgments = {
+  error5: buildMsgErrorString(
+    'ABCI code: 5: error handling packet: see events for details',
+  ),
+};
+
+const delegation = {
+  amount: {
+    denom: 'uatom',
+    amount: '10',
+  },
+  delegatorAddress: 'cosmos1test',
+  validatorAddress: 'cosmosvaloper1test',
+};
+const redelegation = {
+  delegatorAddress: 'cosmos1test',
+  validatorSrcAddress: 'cosmosvaloper1test',
+  validatorDstAddress: 'cosmosvaloper2test',
+  amount: {
+    denom: 'uatom',
+    amount: '10',
+  },
+};
+const bankSend = {
+  fromAddress: 'cosmos1test',
+  toAddress: 'cosmos1testrecipient',
+  amount: [{ denom: 'uatom', amount: '10' }],
+};
+const bankSendMulti = {
+  fromAddress: 'cosmos1test',
+  toAddress: 'cosmos1testrecipient',
+  amount: [
+    { denom: 'uatom', amount: '10' },
+    { denom: 'ibc/1234', amount: '10' },
+  ],
+};
+
+export const UNBOND_PERIOD_SECONDS = 5n;
+
+const getUnbondingTime = (): Timestamp => ({
+  seconds: UNBOND_PERIOD_SECONDS,
+  nanos: 0,
+});
+
+export const protoMsgMocks = {
+  delegate: {
+    msg: buildTxPacketString([MsgDelegate.toProtoMsg(delegation)]),
+    ack: buildMsgResponseString(MsgDelegateResponse, {}),
+  },
+  undelegate: {
+    msg: buildTxPacketString([MsgUndelegate.toProtoMsg(delegation)]),
+    ack: buildMsgResponseString(MsgUndelegateResponse, {
+      completionTime: getUnbondingTime(),
+    }),
+  },
+  redelegate: {
+    msg: buildTxPacketString([MsgBeginRedelegate.toProtoMsg(redelegation)]),
+    ack: buildMsgResponseString(MsgBeginRedelegateResponse, {
+      completionTime: getUnbondingTime(),
+    }),
+  },
+  withdrawReward: {
+    msg: buildTxPacketString([
+      MsgWithdrawDelegatorReward.toProtoMsg(delegation),
+    ]),
+    ack: buildMsgResponseString(MsgWithdrawDelegatorRewardResponse, {
+      amount: [{ amount: '1', denom: 'uatom' }],
+    }),
+  },
+  queryBalance: {
+    msg: buildQueryPacketString([
+      QueryBalanceRequest.toProtoMsg({
+        address: 'cosmos1test',
+        denom: 'uatom',
+      }),
+    ]),
+    ack: buildQueryResponseString(QueryBalanceResponse, {
+      balance: { amount: '0', denom: 'uatom' },
+    }),
+  },
+  bankSend: {
+    msg: buildTxPacketString([MsgSend.toProtoMsg(bankSend)]),
+    ack: buildMsgResponseString(MsgSendResponse, {}),
+  },
+  bankSendMulti: {
+    msg: buildTxPacketString([MsgSend.toProtoMsg(bankSendMulti)]),
+    ack: buildMsgResponseString(MsgSendResponse, {}),
+  },
+  depositForBurn: {
+    msg: buildTxPacketString([
+      MsgDepositForBurn.toProtoMsg({
+        amount: '4250000',
+        burnToken: 'uusdc',
+        from: 'cosmos1test',
+        destinationDomain: 6,
+        mintRecipient: leftPadEthAddressTo32Bytes(
+          '0x20E68F6c276AC6E297aC46c84Ab260928276691D',
+        ),
+      }),
+    ]),
+    ack: buildMsgResponseString(MsgDepositForBurnResponse, {}),
+  },
+  depositForBurnForBase: {
+    msg: buildTxPacketString([
+      MsgDepositForBurn.toProtoMsg({
+        amount: '10',
+        burnToken: 'uusdc',
+        from: 'cosmos1test',
+        destinationDomain: 0,
+        mintRecipient: leftPadEthAddressTo32Bytes(
+          '0xe0d43135EBd2593907F8f56c25ADC1Bf94FCf993',
+        ),
+      }),
+    ]),
+    ack: buildMsgResponseString(MsgDepositForBurnResponse, {}),
+  },
+};
+
+export const defaultMockAckMap: Record<string, string> =
+  createMockAckMap(protoMsgMocks);

package/tools/network-fakes.d.ts

@@ -0,0 +1,142 @@
+import type { VowTools } from '@agoric/vow';
+import type { Zone } from '@agoric/zone';
+import type { IBCChannelID, IBCMethod, IBCEvent, ScopedBridgeManagerMethods } from '@agoric/vats';
+import type { Guarded } from '@endo/exo';
+type ImplementedIBCEvents = 'channelOpenAck' | 'acknowledgementPacket';
+export declare const ibcBridgeMocks: {
+    [T in ImplementedIBCEvents]: T extends 'channelOpenAck' ? (obj: IBCMethod<'startChannelOpenInit'>, opts: {
+        channelID: IBCChannelID;
+        counterpartyChannelID: IBCChannelID;
+        mockChainAddress: string;
+    }) => IBCEvent<'channelOpenAck'> : T extends 'acknowledgementPacket' ? (obj: IBCMethod<'sendPacket'>, opts: {
+        sequence: bigint;
+        acknowledgement: string;
+    }) => IBCEvent<'acknowledgementPacket'> : never;
+};
+type BridgeEvents = Array<IBCEvent<'channelOpenAck'> | IBCEvent<'acknowledgementPacket'> | IBCEvent<'channelCloseConfirm'> | IBCEvent<'sendPacket'>>;
+type BridgeDowncalls = Array<IBCMethod<'startChannelOpenInit'> | IBCMethod<'startChannelCloseInit'> | IBCMethod<'bindPort'> | IBCMethod<'sendPacket'>>;
+/**
+ * Make a fake IBC Bridge, extended from the dibc ScopedBridgeManager.
+ *
+ * Has extra `setMockAck` and `setAddressPrefix` methods.
+ *
+ * @param zone
+ */
+export declare const makeFakeIBCBridge: (zone: Zone) => Guarded<ScopedBridgeManagerMethods<"dibc"> & {
+    addMockAck: (msgData: string, ackData: string) => void;
+    setMockAck: (mockAckMap: Record<string, string>) => void;
+    setAddressPrefix: (addressPrefix: string) => void;
+    inspectDibcBridge: () => {
+        bridgeEvents: BridgeEvents;
+        bridgeDowncalls: BridgeDowncalls;
+    };
+}>;
+export declare const setupFakeNetwork: (zone: Zone, { vowTools }: {
+    vowTools: VowTools;
+}) => {
+    portAllocator: Guarded<{
+        allocateCustomIBCPort(specifiedName?: string): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
+        allocateICAControllerPort(): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
+        allocateICQControllerPort(): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
+        allocateCustomLocalPort(specifiedName?: string): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
+    }>;
+    protocol: Guarded<{
+        registerProtocolHandler(paths: string[], protocolHandler: import("@agoric/vow").Remote<import("@agoric/network").ProtocolHandler>): void;
+        unregisterProtocolHandler(prefix: string, protocolHandler: import("@agoric/vow").Remote<import("@agoric/network").ProtocolHandler>): void;
+        bindPort(localAddr: import("@agoric/network").Endpoint): Promise<import("@agoric/network").Port | import("@agoric/vow").Vow<import("@agoric/network").Port>>;
+    }>;
+    ibcBridge: Guarded<ScopedBridgeManagerMethods<"dibc"> & {
+        addMockAck: (msgData: string, ackData: string) => void;
+        setMockAck: (mockAckMap: Record<string, string>) => void;
+        setAddressPrefix: (addressPrefix: string) => void;
+        inspectDibcBridge: () => {
+            bridgeEvents: BridgeEvents;
+            bridgeDowncalls: BridgeDowncalls;
+        };
+    }>;
+    networkVat: {
+        registerProtocolHandler: (prefixes: any, handler: any) => void;
+        makeLoopbackProtocolHandler: (instancePrefix?: string) => Guarded<{
+            onCreate(_impl: any, _protocolHandler: any): Promise<void>;
+            generatePortID(_localAddr: any, _protocolHandler: any): Promise<string>;
+            onBind(_port: any, _localAddr: any, _protocolHandler: any): Promise<void>;
+            onConnect(_port: any, localAddr: import("@agoric/network").Endpoint, remoteAddr: import("@agoric/network").Endpoint): import("@agoric/vow").PromiseVow<import("@agoric/network").AttemptDescription>;
+            onInstantiate(_port: any, _localAddr: any, _remote: any, _protocol: any): Promise<string>;
+            onListen(port: any, localAddr: any, listenHandler: any, _protocolHandler: any): Promise<void>;
+            onListenRemove(port: import("@agoric/vow").Remote<import("@agoric/network").Port>, localAddr: import("@agoric/network").Endpoint, listenHandler: import("@agoric/vow").Remote<import("@agoric/network").ListenHandler>, _protocolHandler: any): Promise<void>;
+            onRevoke(_port: any, _localAddr: any, _protocolHandler: any): Promise<void>;
+        }>;
+        makeEchoConnectionKit: () => import("@endo/exo").GuardedKit<{
+            handler: {
+                onReceive(_connection: import("@agoric/network").Connection, bytes: import("@agoric/network").Bytes, _connectionHandler: import("@agoric/network").ConnectionHandler): Promise<string>;
+                onClose(_connection: import("@agoric/network").Connection, reason?: import("@agoric/network").CloseReason, _connectionHandler?: import("@agoric/network").ConnectionHandler): Promise<void>;
+            };
+            listener: {
+                onAccept(_port: any, _localAddr: any, _remoteAddr: any, _listenHandler: any): Promise<Guarded<{
+                    onReceive(_connection: import("@agoric/network").Connection, bytes: import("@agoric/network").Bytes, _connectionHandler: import("@agoric/network").ConnectionHandler): Promise<string>;
+                    onClose(_connection: import("@agoric/network").Connection, reason?: import("@agoric/network").CloseReason, _connectionHandler?: import("@agoric/network").ConnectionHandler): Promise<void>;
+                }>>;
+                onListen(port: any, _listenHandler: any): Promise<void>;
+            };
+        }>;
+        unregisterProtocolHandler: (prefix: any, handler: any) => void;
+        getPortAllocator: () => Guarded<{
+            allocateCustomIBCPort(specifiedName?: string): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
+            allocateICAControllerPort(): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
+            allocateICQControllerPort(): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
+            allocateCustomLocalPort(specifiedName?: string): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
+        }>;
+    } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+        registerProtocolHandler: (prefixes: any, handler: any) => void;
+        makeLoopbackProtocolHandler: (instancePrefix?: string) => Guarded<{
+            onCreate(_impl: any, _protocolHandler: any): Promise<void>;
+            generatePortID(_localAddr: any, _protocolHandler: any): Promise<string>;
+            onBind(_port: any, _localAddr: any, _protocolHandler: any): Promise<void>;
+            onConnect(_port: any, localAddr: import("@agoric/network").Endpoint, remoteAddr: import("@agoric/network").Endpoint): import("@agoric/vow").PromiseVow<import("@agoric/network").AttemptDescription>;
+            onInstantiate(_port: any, _localAddr: any, _remote: any, _protocol: any): Promise<string>;
+            onListen(port: any, localAddr: any, listenHandler: any, _protocolHandler: any): Promise<void>;
+            onListenRemove(port: import("@agoric/vow").Remote<import("@agoric/network").Port>, localAddr: import("@agoric/network").Endpoint, listenHandler: import("@agoric/vow").Remote<import("@agoric/network").ListenHandler>, _protocolHandler: any): Promise<void>;
+            onRevoke(_port: any, _localAddr: any, _protocolHandler: any): Promise<void>;
+        }>;
+        makeEchoConnectionKit: () => import("@endo/exo").GuardedKit<{
+            handler: {
+                onReceive(_connection: import("@agoric/network").Connection, bytes: import("@agoric/network").Bytes, _connectionHandler: import("@agoric/network").ConnectionHandler): Promise<string>;
+                onClose(_connection: import("@agoric/network").Connection, reason?: import("@agoric/network").CloseReason, _connectionHandler?: import("@agoric/network").ConnectionHandler): Promise<void>;
+            };
+            listener: {
+                onAccept(_port: any, _localAddr: any, _remoteAddr: any, _listenHandler: any): Promise<Guarded<{
+                    onReceive(_connection: import("@agoric/network").Connection, bytes: import("@agoric/network").Bytes, _connectionHandler: import("@agoric/network").ConnectionHandler): Promise<string>;
+                    onClose(_connection: import("@agoric/network").Connection, reason?: import("@agoric/network").CloseReason, _connectionHandler?: import("@agoric/network").ConnectionHandler): Promise<void>;
+                }>>;
+                onListen(port: any, _listenHandler: any): Promise<void>;
+            };
+        }>;
+        unregisterProtocolHandler: (prefix: any, handler: any) => void;
+        getPortAllocator: () => Guarded<{
+            allocateCustomIBCPort(specifiedName?: string): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
+            allocateICAControllerPort(): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
+            allocateICQControllerPort(): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
+            allocateCustomLocalPort(specifiedName?: string): Promise<import("@agoric/vow").Vow<import("@agoric/network").Port>>;
+        }>;
+    }>;
+    ibcVat: {
+        makeCallbacks: (dibcBridgeManager: import("@agoric/vats").ScopedBridgeManager<"dibc">) => Guarded<{
+            downcall(method: string, obj: any): Promise<any>;
+        }>;
+        createHandlers(callbacks: any): {
+            protocolHandler: import("@agoric/network").ProtocolHandler;
+            bridgeHandler: import("@agoric/vats").BridgeHandler;
+        };
+    } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+        makeCallbacks: (dibcBridgeManager: import("@agoric/vats").ScopedBridgeManager<"dibc">) => Guarded<{
+            downcall(method: string, obj: any): Promise<any>;
+        }>;
+        createHandlers(callbacks: any): {
+            protocolHandler: import("@agoric/network").ProtocolHandler;
+            bridgeHandler: import("@agoric/vats").BridgeHandler;
+        };
+    }>;
+    setupIBCProtocol: () => Promise<void>;
+};
+export {};
+//# sourceMappingURL=network-fakes.d.ts.map

package/tools/network-fakes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-fakes.d.ts","sourceRoot":"","sources":["network-fakes.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAS5C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,EACV,YAAY,EACZ,SAAS,EACT,QAAQ,EACR,0BAA0B,EAG3B,MAAM,cAAc,CAAC;AAOtB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmCzC,KAAK,oBAAoB,GAAG,gBAAgB,GAAG,uBAAuB,CAAC;AAEvE,eAAO,MAAM,cAAc,EAAE;KAC1B,CAAC,IAAI,oBAAoB,GAAG,CAAC,SAAS,gBAAgB,GACnD,CACE,GAAG,EAAE,SAAS,CAAC,sBAAsB,CAAC,EACtC,IAAI,EAAE;QACJ,SAAS,EAAE,YAAY,CAAC;QACxB,qBAAqB,EAAE,YAAY,CAAC;QACpC,gBAAgB,EAAE,MAAM,CAAC;KAC1B,KACE,QAAQ,CAAC,gBAAgB,CAAC,GAC/B,CAAC,SAAS,uBAAuB,GAC/B,CACE,GAAG,EAAE,SAAS,CAAC,YAAY,CAAC,EAC5B,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,MAAM,CAAA;KAAE,KAChD,QAAQ,CAAC,uBAAuB,CAAC,GACtC,KAAK;CAyDZ,CAAC;AAEF,KAAK,YAAY,GAAG,KAAK,CACrB,QAAQ,CAAC,gBAAgB,CAAC,GAC1B,QAAQ,CAAC,uBAAuB,CAAC,GACjC,QAAQ,CAAC,qBAAqB,CAAC,GAC/B,QAAQ,CAAC,YAAY,CAAC,CACzB,CAAC;AAEF,KAAK,eAAe,GAAG,KAAK,CACxB,SAAS,CAAC,sBAAsB,CAAC,GACjC,SAAS,CAAC,uBAAuB,CAAC,GAClC,SAAS,CAAC,UAAU,CAAC,GACrB,SAAS,CAAC,YAAY,CAAC,CAC1B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAC5B,MAAM,IAAI,KACT,OAAO,CACR,0BAA0B,CAAC,MAAM,CAAC,GAAG;IACnC,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACvD,UAAU,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,IAAI,CAAC;IACzD,gBAAgB,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,IAAI,CAAC;IAClD,iBAAiB,EAAE,MAAM;QACvB,YAAY,EAAE,YAAY,CAAC;QAC3B,eAAe,EAAE,eAAe,CAAC;KAClC,CAAC;CACH,CAkKF,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC3B,MAAM,IAAI,EACV,cAAc;IAAE,QAAQ,EAAE,QAAQ,CAAA;CAAE;;;;;;;;;;;;;oBA7KtB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI;oBAC1C,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,IAAI;0BACtC,CAAC,aAAa,EAAE,MAAM,KAAK,IAAI;2BAC9B,MAAM;YACvB,YAAY,EAAE,YAAY,CAAC;YAC3B,eAAe,EAAE,eAAe,CAAC;SAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4NJ,CAAC"}

package/tools/network-fakes.ts

@@ -0,0 +1,389 @@
+import { inspect } from 'node:util';
+
+import type { VowTools } from '@agoric/vow';
+import {
+  base64ToBytes,
+  prepareEchoConnectionKit,
+  prepareLoopbackProtocolHandler,
+  prepareNetworkPowers,
+  preparePortAllocator,
+  prepareRouterProtocol,
+} from '@agoric/network';
+import type { Zone } from '@agoric/zone';
+import type {
+  IBCChannelID,
+  IBCMethod,
+  IBCEvent,
+  ScopedBridgeManagerMethods,
+  IBCConnectionID,
+  IBCPortID,
+} from '@agoric/vats';
+import {
+  prepareCallbacks as prepareIBCCallbacks,
+  prepareIBCProtocol,
+} from '@agoric/vats/src/ibc.js';
+import { BridgeId, makeTracer } from '@agoric/internal';
+import { E, Far } from '@endo/far';
+import type { Guarded } from '@endo/exo';
+import {
+  defaultMockAckMap,
+  errorAcknowledgments,
+} from './ibc-mock-fixtures.js';
+import { decodeProtobufBase64 } from './protobuf-decoder.js';
+
+const trace = makeTracer('NetworkFakes');
+
+/**
+ * Mimic IBC Channel version negotiation
+ *
+ * As part of the IBC Channel initialization, the version field is negotiated
+ * with the host. `version` is a String or JSON string as determined by the IBC
+ * Application protocol.
+ *
+ * @param version requested version string
+ * @param params mock parameters to add to version string
+ * @param params.address for ICS-27, the bech32 address provided by the host
+ */
+const addParamsIfJsonVersion = (
+  version: string,
+  params: { address: string },
+): string => {
+  try {
+    const parsed = JSON.parse(version);
+    return JSON.stringify({
+      ...parsed,
+      ...params,
+    });
+  } catch {
+    return version;
+  }
+};
+
+type ImplementedIBCEvents = 'channelOpenAck' | 'acknowledgementPacket';
+
+export const ibcBridgeMocks: {
+  [T in ImplementedIBCEvents]: T extends 'channelOpenAck'
+    ? (
+        obj: IBCMethod<'startChannelOpenInit'>,
+        opts: {
+          channelID: IBCChannelID;
+          counterpartyChannelID: IBCChannelID;
+          mockChainAddress: string;
+        },
+      ) => IBCEvent<'channelOpenAck'>
+    : T extends 'acknowledgementPacket'
+      ? (
+          obj: IBCMethod<'sendPacket'>,
+          opts: { sequence: bigint; acknowledgement: string },
+        ) => IBCEvent<'acknowledgementPacket'>
+      : never;
+} = {
+  channelOpenAck: (
+    obj: IBCMethod<'startChannelOpenInit'>,
+    {
+      channelID,
+      counterpartyChannelID,
+      mockChainAddress,
+    }: {
+      channelID: IBCChannelID;
+      counterpartyChannelID: IBCChannelID;
+      mockChainAddress: string;
+    },
+  ): IBCEvent<'channelOpenAck'> => {
+    return {
+      type: 'IBC_EVENT',
+      blockHeight: 99,
+      blockTime: 1711571357,
+      event: 'channelOpenAck',
+      portID: obj.packet.source_port,
+      channelID,
+      counterparty: {
+        port_id: obj.packet.destination_port,
+        channel_id: counterpartyChannelID,
+      },
+      counterpartyVersion: addParamsIfJsonVersion(obj.version, {
+        address: mockChainAddress,
+      }),
+      connectionHops: obj.hops,
+      order: obj.order,
+      version: obj.version,
+    };
+  },
+
+  acknowledgementPacket: (
+    obj: IBCMethod<'sendPacket'>,
+    opts: { sequence: bigint; acknowledgement: string },
+  ): IBCEvent<'acknowledgementPacket'> => {
+    const { sequence, acknowledgement } = opts;
+    return {
+      acknowledgement,
+      blockHeight: 289,
+      blockTime: 1712180320,
+      event: 'acknowledgementPacket',
+      packet: {
+        data: obj.packet.data,
+        destination_channel: obj.packet.destination_channel,
+        destination_port: obj.packet.destination_port,
+        sequence: String(sequence),
+        source_channel: obj.packet.source_channel,
+        source_port: obj.packet.source_port,
+        timeout_timestamp: '1712183910866313000',
+      },
+      relayer: 'agoric1gtkg0g6x8lqc734ht3qe2sdkrfugpdp2h7fuu0',
+      type: 'IBC_EVENT',
+    };
+  },
+};
+
+type BridgeEvents = Array<
+  | IBCEvent<'channelOpenAck'>
+  | IBCEvent<'acknowledgementPacket'>
+  | IBCEvent<'channelCloseConfirm'>
+  | IBCEvent<'sendPacket'>
+>;
+
+type BridgeDowncalls = Array<
+  | IBCMethod<'startChannelOpenInit'>
+  | IBCMethod<'startChannelCloseInit'>
+  | IBCMethod<'bindPort'>
+  | IBCMethod<'sendPacket'>
+>;
+
+/**
+ * Make a fake IBC Bridge, extended from the dibc ScopedBridgeManager.
+ *
+ * Has extra `setMockAck` and `setAddressPrefix` methods.
+ *
+ * @param zone
+ */
+export const makeFakeIBCBridge = (
+  zone: Zone,
+): Guarded<
+  ScopedBridgeManagerMethods<'dibc'> & {
+    addMockAck: (msgData: string, ackData: string) => void;
+    setMockAck: (mockAckMap: Record<string, string>) => void;
+    setAddressPrefix: (addressPrefix: string) => void;
+    inspectDibcBridge: () => {
+      bridgeEvents: BridgeEvents;
+      bridgeDowncalls: BridgeDowncalls;
+    };
+  }
+> => {
+  let bridgeHandler: any;
+  /**
+   * Intended to mock an individual account's sequence, but is global for all
+   * accounts.
+   * XXX teach this about IBCConnections and store sequence on a
+   * per-channel basis.
+   */
+  let ibcSequenceNonce = 0n;
+  /**
+   * The number of channels created. Currently used as a proxy to increment
+   * fake account addresses and channels.
+   */
+  let channelCount = 0;
+  let icaAccountCount = 0;
+  let bech32Prefix = 'cosmos';
+
+  /**
+   * Keep track channels requested by remote chain. Used as a proxy for
+   * counterparty channel ids.
+   */
+  const remoteChannelMap: Record<IBCConnectionID, number> = {};
+
+  /**
+   * Packet byte string map of requests to responses
+   */
+  let mockAckMap = defaultMockAckMap;
+  let bridgeEvents: BridgeEvents = [];
+  let bridgeDowncalls: BridgeDowncalls = [];
+
+  /**
+   * Store remote mock addresses that have been distributed.
+   * If there's a `channelOpenInit` request for a PortId:ConnnectionId
+   * pair that's been previously established, let's reuse it to mimic
+   * the behavior of the ICS-27 protocol.
+   */
+  type AddressKey = `${IBCPortID}:${IBCConnectionID}`;
+  const getAddressKey = (
+    obj: IBCMethod<'startChannelOpenInit'>,
+  ): AddressKey => {
+    return `${obj.packet.source_port as IBCPortID}:${obj.hops[0] as IBCConnectionID}`;
+  };
+  const addressMap = new Map<AddressKey, string>();
+
+  return zone.exo('Fake IBC Bridge Manager', undefined, {
+    getBridgeId: () => BridgeId.DIBC,
+    toBridge: async obj => {
+      trace(
+        'toBridge',
+        obj,
+        obj.packet?.data ? base64ToBytes(obj.packet.data) : undefined,
+      );
+      if (obj.type === 'IBC_METHOD') {
+        bridgeDowncalls = bridgeDowncalls.concat(obj);
+        switch (obj.method) {
+          case 'startChannelOpenInit': {
+            const connectionChannelCount = remoteChannelMap[obj.hops[0]] || 0;
+            const addressKey = getAddressKey(obj);
+            let mockChainAddress;
+            if (addressMap.has(addressKey)) {
+              mockChainAddress = addressMap.get(addressKey);
+            } else {
+              mockChainAddress =
+                icaAccountCount > 0
+                  ? `${bech32Prefix}1test${icaAccountCount}`
+                  : `${bech32Prefix}1test`;
+              addressMap.set(addressKey, mockChainAddress);
+            }
+            const ackEvent = ibcBridgeMocks.channelOpenAck(obj, {
+              mockChainAddress,
+              channelID: `channel-${channelCount}`,
+              counterpartyChannelID: `channel-${connectionChannelCount}`,
+            });
+            bridgeHandler?.fromBridge(ackEvent);
+            bridgeEvents = bridgeEvents.concat(ackEvent);
+            channelCount += 1;
+            if (obj.packet.source_port.includes('icacontroller')) {
+              icaAccountCount += 1;
+            }
+            remoteChannelMap[obj.hops[0]] = connectionChannelCount + 1;
+            return undefined;
+          }
+          case 'sendPacket': {
+            const mockAckMapHasData = obj.packet.data in mockAckMap;
+            if (!mockAckMapHasData) {
+              trace(
+                `sendPacket acking err because no mock ack for b64 data key: '${obj.packet.data}'`,
+              );
+              try {
+                const decoded = decodeProtobufBase64(
+                  JSON.parse(base64ToBytes(obj.packet.data)).data,
+                );
+                trace(
+                  'Fix the source of this request or define a ack mapping for it:',
+                  inspect(decoded, { depth: null }),
+                );
+              } catch (err) {
+                trace('Could not decode packet data', err);
+              }
+            }
+            const ackEvent = ibcBridgeMocks.acknowledgementPacket(obj, {
+              sequence: ibcSequenceNonce,
+              acknowledgement: mockAckMapHasData
+                ? mockAckMap[obj.packet.data]
+                : errorAcknowledgments.error5,
+            });
+            bridgeEvents = bridgeEvents.concat(ackEvent);
+            ibcSequenceNonce += 1n;
+            bridgeHandler?.fromBridge(ackEvent);
+            return ackEvent.packet;
+          }
+          default:
+            return undefined;
+        }
+      }
+      return undefined;
+    },
+    fromBridge: async obj => {
+      trace('fromBridge', obj);
+      bridgeEvents = bridgeEvents.concat(obj);
+      if (!bridgeHandler) throw Error('no handler!');
+      return bridgeHandler.fromBridge(obj);
+    },
+    initHandler: handler => {
+      if (bridgeHandler) throw Error('already init');
+      bridgeHandler = handler;
+    },
+    setHandler: handler => {
+      if (!bridgeHandler) throw Error('must init first');
+      bridgeHandler = handler;
+    },
+    /**
+     * Set a map of requests to responses to simulate different scenarios. Defaults to `defaultMockAckMap`.
+     * See `@agoric/orchestration/tools/ibc-mocks.js` for helpers to build this map.
+     *
+     * @param ackMap
+     */
+    setMockAck: (ackMap: typeof mockAckMap) => {
+      trace('setMockAck', ackMap);
+      mockAckMap = ackMap;
+    },
+    addMockAck: (msgData: string, ackData: string) => {
+      trace('addMockAck', msgData, ackData);
+      mockAckMap[msgData] = ackData;
+    },
+    /**
+     * Set a new bech32 prefix for the mocked ICA channel. Defaults to `cosmos`.
+     *
+     * @param newPrefix
+     */
+    setAddressPrefix: (newPrefix: typeof bech32Prefix) => {
+      trace('setAddressPrefix', newPrefix);
+      bech32Prefix = newPrefix;
+    },
+    /**
+     * for debugging and testing
+     */
+    inspectDibcBridge() {
+      return { bridgeEvents, bridgeDowncalls };
+    },
+  });
+};
+
+export const setupFakeNetwork = (
+  zone: Zone,
+  { vowTools }: { vowTools: VowTools },
+) => {
+  const powers = prepareNetworkPowers(zone, vowTools);
+  const makeRouterProtocol = prepareRouterProtocol(zone, powers);
+  const makePortAllocator = preparePortAllocator(zone, powers);
+  const makeLoopbackProtocolHandler = prepareLoopbackProtocolHandler(
+    zone,
+    vowTools,
+  );
+  const makeEchoConnectionKit = prepareEchoConnectionKit(zone);
+  const makeIBCProtocolHandler = prepareIBCProtocol(zone, vowTools);
+
+  const protocol = makeRouterProtocol();
+  const portAllocator = makePortAllocator({ protocol });
+  const ibcBridge = makeFakeIBCBridge(zone);
+
+  const networkVat = Far('vat-network', {
+    registerProtocolHandler: (prefixes, handler) =>
+      protocol.registerProtocolHandler(prefixes, handler),
+    makeLoopbackProtocolHandler,
+    makeEchoConnectionKit,
+    unregisterProtocolHandler: (prefix, handler) =>
+      protocol.unregisterProtocolHandler(prefix, handler),
+    getPortAllocator: () => portAllocator,
+  });
+
+  const ibcVat = Far('vat-ibc', {
+    makeCallbacks: prepareIBCCallbacks(zone),
+    createHandlers(callbacks) {
+      const ibcHandler = makeIBCProtocolHandler(callbacks);
+      return harden(ibcHandler);
+    },
+  });
+
+  const setupIBCProtocol = async () => {
+    const callbacks = await E(ibcVat).makeCallbacks(ibcBridge);
+    const { protocolHandler, bridgeHandler } =
+      await E(ibcVat).createHandlers(callbacks);
+    await E(ibcBridge).initHandler(bridgeHandler);
+    await E(networkVat).registerProtocolHandler(
+      ['/ibc-port', '/ibc-hop'],
+      protocolHandler,
+    );
+  };
+
+  return {
+    portAllocator,
+    protocol,
+    ibcBridge,
+    networkVat,
+    ibcVat,
+    setupIBCProtocol,
+  };
+};