@agoric/vats 0.15.2-dev-c19f1b5.0 → 0.15.2-dev-27cc9b8.0

package/src/ibc.js

@@ -3,7 +3,7 @@
 import { assert, details as X, Fail } from '@agoric/assert';
 import { E } from '@endo/far';
 
-import { dataToBase64, base64ToBytes } from '@agoric/network';
+import { byteSourceToBase64, base64ToBytes } from '@agoric/network';
 
 import {
   localAddrToPortID,
@@ -132,7 +132,7 @@ export const prepareIBCConnectionHandler = zone => {
           source_channel: channelID,
           destination_port: rPortID,
           destination_channel: rChannelID,
-          data: dataToBase64(packetBytes),
+          data: byteSourceToBase64(packetBytes),
         };
         return protocolUtils.ibcSendPacket(packet, relativeTimeoutNs);
       },
@@ -678,7 +678,7 @@ export const prepareIBCProtocol = (zone, powers) => {
           const { packet } = watcherContext;
 
           const realAck = ack || DEFAULT_ACKNOWLEDGEMENT;
-          const ack64 = dataToBase64(realAck);
+          const ack64 = byteSourceToBase64(realAck);
           this.facets.util
             .downcall('receiveExecuted', {
               packet,

package/src/localchain.d.ts

@@ -7,12 +7,14 @@
  * @typedef {{
  *   system: ScopedBridgeManager<'vlocalchain'>;
  *   bank: Bank;
+ *   transfer: import('./transfer.js').TransferMiddleware;
  * }} AccountPowers
  */
 /**
  * @typedef {{
  *   system: ScopedBridgeManager<'vlocalchain'>;
  *   bankManager: BankManager;
+ *   transfer: import('./transfer.js').TransferMiddleware;
  * }} LocalChainPowers
  */
 export const LocalChainAccountI: import("@endo/patterns").InterfaceGuard<{
@@ -21,6 +23,7 @@ export const LocalChainAccountI: import("@endo/patterns").InterfaceGuard<{
     deposit: import("@endo/patterns").MethodGuard;
     withdraw: import("@endo/patterns").MethodGuard;
     executeTx: import("@endo/patterns").MethodGuard;
+    monitorTransfers: import("@endo/patterns").MethodGuard;
 }>;
 /**
  * @typedef {Awaited<
@@ -74,6 +77,7 @@ export function prepareLocalChainTools(zone: import("@agoric/base-zone").Zone):
             executeTx<MT extends {
                 '@type': string;
             }[]>(messages: MT): Promise<{ [K in keyof MT]: JsonSafe<ResponseTo<MT[K]>>; }>;
+            monitorTransfers(tap: any): Promise<any>;
         }>>;
         /**
          * Make a single query to the local chain. Will reject with an error if
@@ -106,6 +110,7 @@ export function prepareLocalChainTools(zone: import("@agoric/base-zone").Zone):
 export type AccountPowers = {
     system: ScopedBridgeManager<"vlocalchain">;
     bank: Bank;
+    transfer: import("./transfer.js").TransferMiddleware;
 };
 export type LocalChainPowers = {
     system: ScopedBridgeManager<"vlocalchain">;
@@ -128,6 +133,7 @@ export type LocalChainPowers = {
         }): Promise<void>;
         getBankForAddress(address: string): Promise<Bank>;
     }>;
+    transfer: import("./transfer.js").TransferMiddleware;
 };
 export type LocalChainAccount = Awaited<ReturnType<Awaited<ReturnType<typeof prepareLocalChainAccount>>>>;
 export type LocalChainTools = ReturnType<typeof prepareLocalChainTools>;
@@ -171,6 +177,7 @@ declare function prepareLocalChainAccount(zone: import("@agoric/base-zone").Zone
     executeTx<MT extends {
         '@type': string;
     }[]>(messages: MT): Promise<{ [K in keyof MT]: JsonSafe<ResponseTo<MT[K]>>; }>;
+    monitorTransfers(tap: any): Promise<any>;
 }>;
 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":"AAOA;;;;GAIG;AAEH;;;;;GAKG;AAEH;;;;;GAKG;AAEH;;;;;;GAMG;AA4EH;;;;GAIG;AAEH;;;;GAIG;AAwEI,6CADK,OAAO,mBAAmB,EAAE,IAAI;;QAxDtC;;;;;WAKG;;;YAzFH,kCAAkC;8BAAtB,KAAK,CAAC,KAAK,CAAC;YAMxB;;;;;;;;;eASG;6BAJQ,OAAO,CAAC,KAAK,CAAC,mBACd,OAAO,GAEL,OAAO,CAAC,MAAM,CAAC;YAS5B;;;;;eAKG;6BAFQ,MAAM,CAAC,KAAK,CAAC,GACX,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAOpC;;;;;;;;eAQG;sBADyD,EAAE;;2BAAF,EAAE,AADjD;;QA0Db;;;;;;;WAOG;uBAFQ,OAAO,sBAAsB,EAAE,SAAS,GACtC,OAAO,CAAC,OAAO,sBAAsB,EAAE,SAAS,CAAC;QAa9D;;;;;;;;;;;;WAYG;4BAPQ,OAAO,sBAAsB,EAAE,SAAS,EAAE,GACxC,OAAO,CACnB;YACA,KAAW,CAAC,EAAE,MAAM,CAAC;YACrB,KAAW,EAAE,OAAO,sBAAsB,EAAE,SAAS,CAAC;SACjD,EAAE,CACJ;;EAkBT;;;;;;;;;gEAKs7Y,cAAc;;;;;;;;;;;;+EAAiiD,cAAc,GAAE;YAAE,OAAQ,CAAC,EAAC,KAAM,QAAQ,KAAK,CAAC,CAAC,CAAA;SAAE;;;;gCA3F5gc,OAAO,CACnB,UAAc,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC,CAAC,CACjE;8BAuFU,UAAU,CAAC,OAAO,sBAAsB,CAAC;yBACzC,UAAU,CAAC,eAAe,CAAC,gBAAgB,CAAC,CAAC;gCAhMT,sBAAsB;8BAAtB,sBAAsB;yCAElC,YAAY;0BADd,eAAe;AA0BnD,qDAAqD;AACrD,gDADY,OAAO,mBAAmB,EAAE,IAAI;;IAetC,kCAAkC;sBAAtB,KAAK,CAAC,KAAK,CAAC;IAMxB;;;;;;;;;OASG;qBAJQ,OAAO,CAAC,KAAK,CAAC,mBACd,OAAO,GAEL,OAAO,CAAC,MAAM,CAAC;IAS5B;;;;;OAKG;qBAFQ,MAAM,CAAC,KAAK,CAAC,GACX,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAOpC;;;;;;;;OAQG;cADyD,EAAE;;mBAAF,EAAE,AADjD;GAkBhB"}
+{"version":3,"file":"localchain.d.ts","sourceRoot":"","sources":["localchain.js"],"names":[],"mappings":"AAOA;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;;;;GAMG;AAEH;;;;;;;GASG;AAgFH;;;;GAIG;AAEH;;;;GAIG;AAwEI,6CADK,OAAO,mBAAmB,EAAE,IAAI;;QAxDtC;;;;;WAKG;;;YA7FH,kCAAkC;8BAAtB,KAAK,CAAC,KAAK,CAAC;YAMxB;;;;;;;;;eASG;6BAJQ,OAAO,CAAC,KAAK,CAAC,mBACd,OAAO,GAEL,OAAO,CAAC,MAAM,CAAC;YAS5B;;;;;eAKG;6BAFQ,MAAM,CAAC,KAAK,CAAC,GACX,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAOpC;;;;;;;;eAQG;sBADyD,EAAE;;2BAAF,EAAE,AADjD;;;QA8Db;;;;;;;WAOG;uBAFQ,OAAO,sBAAsB,EAAE,SAAS,GACtC,OAAO,CAAC,OAAO,sBAAsB,EAAE,SAAS,CAAC;QAa9D;;;;;;;;;;;;WAYG;4BAPQ,OAAO,sBAAsB,EAAE,SAAS,EAAE,GACxC,OAAO,CACnB;YACA,KAAW,CAAC,EAAE,MAAM,CAAC;YACrB,KAAW,EAAE,OAAO,sBAAsB,EAAE,SAAS,CAAC;SACjD,EAAE,CACJ;;EAkBT;;;;cA5Lc,OAAO,eAAe,EAAE,kBAAkB;;;;;;gEAiM++X,cAAc;;;;;;;;;;;;+EAAiiD,cAAc,GAAE;YAAE,OAAQ,CAAC,EAAC,KAAM,QAAQ,KAAK,CAAC,CAAC,CAAA;SAAE;;;cAzL3nb,OAAO,eAAe,EAAE,kBAAkB;;gCA8F5C,OAAO,CACnB,UAAc,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC,CAAC,CACjE;8BAuFU,UAAU,CAAC,OAAO,sBAAsB,CAAC;yBACzC,UAAU,CAAC,eAAe,CAAC,gBAAgB,CAAC,CAAC;gCAzMT,sBAAsB;8BAAtB,sBAAsB;yCAElC,YAAY;0BADd,eAAe;AA+BnD,qDAAqD;AACrD,gDADY,OAAO,mBAAmB,EAAE,IAAI;;IAetC,kCAAkC;sBAAtB,KAAK,CAAC,KAAK,CAAC;IAMxB;;;;;;;;;OASG;qBAJQ,OAAO,CAAC,KAAK,CAAC,mBACd,OAAO,GAEL,OAAO,CAAC,MAAM,CAAC;IAS5B;;;;;OAKG;qBAFQ,MAAM,CAAC,KAAK,CAAC,GACX,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAOpC;;;;;;;;OAQG;cADyD,EAAE;;mBAAF,EAAE,AADjD;;GAsBhB"}

package/src/localchain.js

@@ -15,6 +15,7 @@ const { Fail } = assert;
  * @typedef {{
  *   system: ScopedBridgeManager<'vlocalchain'>;
  *   bank: Bank;
+ *   transfer: import('./transfer.js').TransferMiddleware;
  * }} AccountPowers
  */
 
@@ -22,6 +23,7 @@ const { Fail } = assert;
  * @typedef {{
  *   system: ScopedBridgeManager<'vlocalchain'>;
  *   bankManager: BankManager;
+ *   transfer: import('./transfer.js').TransferMiddleware;
  * }} LocalChainPowers
  */
 
@@ -31,6 +33,9 @@ export const LocalChainAccountI = M.interface('LocalChainAccount', {
   deposit: M.callWhen(PaymentShape).optional(M.pattern()).returns(AmountShape),
   withdraw: M.callWhen(AmountShape).returns(PaymentShape),
   executeTx: M.callWhen(M.arrayOf(M.record())).returns(M.arrayOf(M.record())),
+  monitorTransfers: M.callWhen(M.remotable('TransferTap')).returns(
+    M.remotable('TargetRegistration'),
+  ),
 });
 
 /** @param {import('@agoric/base-zone').Zone} zone */
@@ -105,6 +110,10 @@ const prepareLocalChainAccount = zone =>
         };
         return E(system).toBridge(obj);
       },
+      async monitorTransfers(tap) {
+        const { address, transfer } = this.state;
+        return E(transfer).registerTap(address, tap);
+      },
     },
   );
 /**
@@ -139,12 +148,12 @@ const prepareLocalChain = (zone, makeAccount) =>
        * hash and block data hash.
        */
       async makeAccount() {
-        const { system, bankManager } = this.state;
+        const { system, bankManager, transfer } = this.state;
         const address = await E(system).toBridge({
           type: 'VLOCALCHAIN_ALLOCATE_ADDRESS',
         });
         const bank = await E(bankManager).getBankForAddress(address);
-        return makeAccount(address, { system, bank });
+        return makeAccount(address, { system, bank, transfer });
       },
       /**
        * Make a single query to the local chain. Will reject with an error if

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

@@ -1,7 +1,10 @@
-export function setupLocalChainVat({ consume: { loadCriticalVat, bridgeManager: bridgeManagerP, localchainBridgeManager: localchainBridgeManagerP, bankManager, }, produce: { localchainVat, localchain, localchainBridgeManager }, }: BootstrapPowers & {
+export function setupLocalChainVat({ consume: { loadCriticalVat, bridgeManager: bridgeManagerP, localchainBridgeManager: localchainBridgeManagerP, bankManager, transferMiddleware, }, produce: { localchainVat, localchain, localchainBridgeManager }, }: BootstrapPowers & {
     consume: {
         loadCriticalVat: VatLoader<any>;
+        bridgeManager: import("../types").BridgeManager;
         localchainBridgeManager: import("../types").ScopedBridgeManager<"vlocalchain">;
+        bankManager: Promise<import("../vat-bank.js").BankManager>;
+        transferMiddleware: Promise<import("../transfer.js").TransferMiddleware>;
     };
     produce: {
         localchain: Producer<any>;

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

@@ -1 +1 @@
-{"version":3,"file":"localchain-proposal.d.ts","sourceRoot":"","sources":["localchain-proposal.js"],"names":[],"mappings":"AAuBO,uOAlBI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,eAAqB,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;QACtC,uBAA6B,EAAE,OAAO,UAAU,EAAE,mBAAmB,CAAC,aAAa,CAAC,CAAC;KAChF,CAAC;IACN,OAAW,EAAE;QACb,UAAgB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QAChC,aAAmB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACnC,uBAA6B,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;KACxC,CAAC;CACH;IAEgD,OAAO,EAAhD;QAAE,aAAa,EAAE,YAAY,CAAA;KAAE;kBA4DzC;AAUM,2EAPI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,UAAgB,EAAE,OAAO,kBAAkB,EAAE,UAAU,CAAC;KACnD,CAAC;CACH,YACO,MAAM,iBAOhB;AAEM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BL;6BAtGW;IACZ,UAAc,EAAE,IAAI,CAAC,OAAO,sBAAsB,EAAE,aAAa,CAAC,CAAC;CAChE"}
+{"version":3,"file":"localchain-proposal.d.ts","sourceRoot":"","sources":["localchain-proposal.js"],"names":[],"mappings":"AA0BO,2PArBI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,eAAqB,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;QACtC,aAAmB,EAAE,OAAO,UAAU,EAAE,aAAa,CAAC;QACtD,uBAA6B,EAAE,OAAO,UAAU,EAAE,mBAAmB,CAAC,aAAa,CAAC,CAAC;QACrF,WAAiB,EAAE,OAAO,CAAC,OAAO,gBAAgB,EAAE,WAAW,CAAC,CAAC;QACjE,kBAAwB,EAAE,OAAO,CAAC,OAAO,gBAAgB,EAAE,kBAAkB,CAAC,CAAC;KAC1E,CAAC;IACN,OAAW,EAAE;QACb,UAAgB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QAChC,aAAmB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACnC,uBAA6B,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;KACxC,CAAC;CACH;IAEgD,OAAO,EAAhD;QAAE,aAAa,EAAE,YAAY,CAAA;KAAE;kBA8DzC;AAUM,2EAPI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,UAAgB,EAAE,OAAO,kBAAkB,EAAE,UAAU,CAAC;KACnD,CAAC;CACH,YACO,MAAM,iBAOhB;AAEM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BL;6BAxGW;IACZ,UAAc,EAAE,IAAI,CAAC,OAAO,sBAAsB,EAAE,aAAa,CAAC,CAAC;CAChE"}

package/src/proposals/localchain-proposal.js

@@ -6,7 +6,10 @@ import { BridgeId as BRIDGE_ID } from '@agoric/internal';
  * @param {BootstrapPowers & {
  *   consume: {
  *     loadCriticalVat: VatLoader<any>;
+ *     bridgeManager: import('../types').BridgeManager;
  *     localchainBridgeManager: import('../types').ScopedBridgeManager<'vlocalchain'>;
+ *     bankManager: Promise<import('../vat-bank.js').BankManager>;
+ *     transferMiddleware: Promise<import('../transfer.js').TransferMiddleware>;
  *   };
  *   produce: {
  *     localchain: Producer<any>;
@@ -28,6 +31,7 @@ export const setupLocalChainVat = async (
       bridgeManager: bridgeManagerP,
       localchainBridgeManager: localchainBridgeManagerP,
       bankManager,
+      transferMiddleware,
     },
     produce: { localchainVat, localchain, localchainBridgeManager },
   },
@@ -71,6 +75,7 @@ export const setupLocalChainVat = async (
   const newLocalChain = await E(vats.localchain).makeLocalChain({
     system: scopedManager,
     bankManager: await bankManager,
+    transfer: await transferMiddleware,
   });
 
   localchain.reset();

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

@@ -1 +1 @@
-{"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"}
+{"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;kBA+DpC;AAEM;;;;;;;;;;;;;;EAYL"}

package/src/proposals/localchain-test.js

@@ -19,13 +19,10 @@ export const testLocalChain = async (
   /** @type {null | ERef<StorageNode>} */
   let node = await chainStorage;
   if (!node) {
+    console.error('testLocalChain no chainStorage');
     throw new Error('no chainStorage');
   }
 
-  for (const nodeName of testResultPath.split('.')) {
-    node = E(node).makeChildNode(nodeName);
-  }
-
   let result;
   try {
     const lca = await E(localchain).makeAccount();
@@ -60,6 +57,9 @@ export const testLocalChain = async (
 
     const emptyQuery = await E(localchain).queryMany([]);
     console.info('emptyQuery', emptyQuery);
+    if (emptyQuery.length !== 0) {
+      throw new Error('emptyQuery results should be empty');
+    }
 
     result = { success: true };
   } catch (e) {
@@ -68,6 +68,9 @@ export const testLocalChain = async (
   }
 
   console.warn('=== localchain test done, setting', { result });
+  for (const nodeName of testResultPath.split('.')) {
+    node = E(node).makeChildNode(nodeName);
+  }
   await E(node).setValue(JSON.stringify(result));
 };
 

package/src/proposals/restart-vats-proposal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"restart-vats-proposal.d.ts","sourceRoot":"","sources":["restart-vats-proposal.js"],"names":[],"mappings":"AA+BO,yCALI,eAAe,GACzB,OAAW,wDAAwD,EAAE,qBAAqB;IAErD,OAAO,EAAlC;QAAE,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE;kBAkH5B;AAGM;;;;;;;;;;;;;;;;;;;;EAoBL"}
+{"version":3,"file":"restart-vats-proposal.d.ts","sourceRoot":"","sources":["restart-vats-proposal.js"],"names":[],"mappings":"AAiCO,yCALI,eAAe,GACzB,OAAW,wDAAwD,EAAE,qBAAqB;IAErD,OAAO,EAAlC;QAAE,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE;kBAoH5B;AAGM;;;;;;;;;;;;;;;;;;;;EAoBL"}

package/src/proposals/restart-vats-proposal.js

@@ -17,9 +17,11 @@ const vatUpgradeStatus = {
   board: 'covered by test-upgrade-vats: upgrade vat-board',
   bridge: 'covered by test-upgrade-vats: upgrade vat-bridge',
   ibc: 'upgradeable',
+  localchain: 'UNTESTED',
   network: 'upgradeable',
   priceAuthority: 'covered by test-upgrade-vats: upgrade vat-priceAuthority',
   provisioning: 'UNTESTED',
+  transfer: 'UNTESTED',
   zoe: 'tested in @agoric/zoe',
 };
 
@@ -128,8 +130,10 @@ export const restartVats = async ({ consume }, { options }) => {
       console.log('upgrading vat', name);
       const { vatAdminSvc } = consume;
       const info = await consume.vatUpgradeInfo;
-      const { bundleID } = info.get(name);
-      const bcap = await E(vatAdminSvc).getBundleCap(bundleID);
+      const { bundleID, bundleName } = info.get(name);
+      const bcap = await (bundleID
+        ? E(vatAdminSvc).getBundleCap(bundleID)
+        : E(vatAdminSvc).getNamedBundleCap(bundleName));
       await E(adminNode).upgrade(bcap);
     }
     console.log('VAT', name, status);

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

@@ -0,0 +1,41 @@
+export function setupTransferMiddleware({ consume: { loadCriticalVat, bridgeManager: bridgeManagerP, vtransferBridgeManager: vtransferBridgeManagerP, }, produce: { transferMiddleware: produceTransferMiddleware, transferVat: produceTransferVat, vtransferBridgeManager: produceVtransferBridgeManager, }, }: BootstrapPowers & {
+    consume: {
+        loadCriticalVat: VatLoader<any>;
+        bridgeManager: import("../types").BridgeManager;
+        vtransferBridgeManager: import("../types").ScopedBridgeManager<"vtransfer">;
+    };
+    produce: {
+        transferMiddleware: Producer<any>;
+        transferVat: Producer<any>;
+        vtransferBridgeManager: Producer<any>;
+    };
+}, options: {
+    options: {
+        transferRef: VatSourceRef;
+    };
+}): Promise<void>;
+export function getManifestForTransfer(_powers: any, { transferRef }: {
+    transferRef: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                loadCriticalVat: boolean;
+                bridgeManager: string;
+                vtransferBridgeManager: string;
+            };
+            produce: {
+                transferMiddleware: string;
+                transferVat: string;
+                vtransferBridgeManager: string;
+            };
+        };
+    };
+    options: {
+        transferRef: any;
+    };
+};
+export type TransferVats = {
+    transfer: ERef<import("../vat-transfer.js").TransferVat>;
+};
+//# sourceMappingURL=transfer-proposal.d.ts.map

package/src/proposals/transfer-proposal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer-proposal.d.ts","sourceRoot":"","sources":["transfer-proposal.js"],"names":[],"mappings":"AAwBO,iTAnBI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,eAAqB,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;QACtC,aAAmB,EAAE,OAAO,UAAU,EAAE,aAAa,CAAC;QACtD,sBAA4B,EAAE,OAAO,UAAU,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;KAC7E,CAAC;IACN,OAAW,EAAE;QACb,kBAAwB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACxC,WAAiB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QACjC,sBAA4B,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;KACvC,CAAC;CACH;IAE8C,OAAO,EAA9C;QAAE,WAAW,EAAE,YAAY,CAAA;KAAE;kBAiFvC;AAEM;;;;;;;;;;;;;;;;;;;;EAkBL;2BAnGW;IACZ,QAAY,EAAE,IAAI,CAAC,OAAO,oBAAoB,EAAE,WAAW,CAAC,CAAC;CAC1D"}

package/src/proposals/transfer-proposal.js

@@ -0,0 +1,120 @@
+// @ts-check
+import { E } from '@endo/far';
+import { BridgeId as BRIDGE_ID, VTRANSFER_IBC_EVENT } from '@agoric/internal';
+
+/**
+ * @param {BootstrapPowers & {
+ *   consume: {
+ *     loadCriticalVat: VatLoader<any>;
+ *     bridgeManager: import('../types').BridgeManager;
+ *     vtransferBridgeManager: import('../types').ScopedBridgeManager<'vtransfer'>;
+ *   };
+ *   produce: {
+ *     transferMiddleware: Producer<any>;
+ *     transferVat: Producer<any>;
+ *     vtransferBridgeManager: Producer<any>;
+ *   };
+ * }} powers
+ * @param {object} options
+ * @param {{ transferRef: VatSourceRef }} options.options
+ *
+ * @typedef {{
+ *   transfer: ERef<import('../vat-transfer.js').TransferVat>;
+ * }} TransferVats
+ */
+export const setupTransferMiddleware = async (
+  {
+    consume: {
+      loadCriticalVat,
+      bridgeManager: bridgeManagerP,
+      vtransferBridgeManager: vtransferBridgeManagerP,
+    },
+    produce: {
+      transferMiddleware: produceTransferMiddleware,
+      transferVat: produceTransferVat,
+      vtransferBridgeManager: produceVtransferBridgeManager,
+    },
+  },
+  options,
+) => {
+  const bridgeManager = await bridgeManagerP;
+  if (!bridgeManager) {
+    console.error('No bridgeManager, skipping setupTransferMiddleware');
+    return;
+  }
+
+  const { transferRef } = options.options;
+  /** @type {TransferVats} */
+  const vats = {
+    transfer: E(loadCriticalVat)('transfer', transferRef),
+  };
+  // don't proceed if loadCriticalVat fails
+  await Promise.all(Object.values(vats));
+  produceTransferVat.reset();
+  produceTransferVat.resolve(vats.transfer);
+
+  // We'll be exporting a TransferMiddleware instance that implements a
+  // vtransfer app registry supporting active and passive "taps" while handling
+  // IBC transfer protocol conformance by configuring its backing
+  // BridgeTargetKit registry to wrap each app with an interceptor.
+  // But a bridge channel scoped to vtransfer might already exist, so we make or
+  // retrieve it as appropriate, then make its intercepting BridgeTargetKit,
+  // and then finally configure the TransferMiddleware with that kit's registry.
+  const { finisher, interceptorFactory, transferMiddleware } = await E(
+    vats.transfer,
+  ).makeTransferMiddlewareKit();
+  const vtransferID = BRIDGE_ID.VTRANSFER;
+  const provideBridgeTargetKit = bridge =>
+    E(vats.transfer).provideBridgeTargetKit(
+      bridge,
+      VTRANSFER_IBC_EVENT,
+      interceptorFactory,
+    );
+  /** @type {Awaited<ReturnType<typeof provideBridgeTargetKit>>} */
+  let bridgeTargetKit;
+  try {
+    const vtransferBridge = await E(bridgeManager).register(vtransferID);
+    produceVtransferBridgeManager.reset();
+    produceVtransferBridgeManager.resolve(vtransferBridge);
+    bridgeTargetKit = await provideBridgeTargetKit(vtransferBridge);
+    await E(finisher).useRegistry(bridgeTargetKit.targetRegistry);
+    await E(vtransferBridge).initHandler(bridgeTargetKit.bridgeHandler);
+    console.info('Successfully initHandler for', vtransferID);
+  } catch (e) {
+    console.error(
+      'Failed to initHandler',
+      vtransferID,
+      'reason:',
+      e,
+      'falling back to setHandler',
+    );
+    const vtransferBridge = await vtransferBridgeManagerP;
+    bridgeTargetKit = await provideBridgeTargetKit(vtransferBridge);
+    await E(finisher).useRegistry(bridgeTargetKit.targetRegistry);
+    await E(vtransferBridge).setHandler(bridgeTargetKit.bridgeHandler);
+    console.info('Successfully setHandler for', vtransferID);
+  }
+
+  produceTransferMiddleware.reset();
+  produceTransferMiddleware.resolve(transferMiddleware);
+};
+
+export const getManifestForTransfer = (_powers, { transferRef }) => ({
+  manifest: {
+    [setupTransferMiddleware.name]: {
+      consume: {
+        loadCriticalVat: true,
+        bridgeManager: 'bridge',
+        vtransferBridgeManager: 'transfer',
+      },
+      produce: {
+        transferMiddleware: 'transfer',
+        transferVat: 'transfer',
+        vtransferBridgeManager: 'transfer',
+      },
+    },
+  },
+  options: {
+    transferRef,
+  },
+});

package/src/proposals/vtransfer-echoer.d.ts

@@ -0,0 +1,24 @@
+export function echoVtransfer({ consume: { transferMiddleware } }: BootstrapPowers & {
+    consume: {
+        transferMiddleware: import("../transfer.js").TransferMiddleware;
+    };
+}, { options: { target } }: {
+    options: {
+        target: string;
+    };
+}): Promise<void>;
+export function getManifestForVtransferEchoer(_powers: any, { target }: {
+    target: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                transferMiddleware: string;
+            };
+        };
+    };
+    options: {
+        target: any;
+    };
+};
+//# sourceMappingURL=vtransfer-echoer.d.ts.map

package/src/proposals/vtransfer-echoer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vtransfer-echoer.d.ts","sourceRoot":"","sources":["vtransfer-echoer.js"],"names":[],"mappings":"AAaO,mEARI,eAAe,GAAG;IAC5B,OAAW,EAAE;QACb,kBAAwB,EAAE,OAAO,gBAAgB,EAAE,kBAAkB,CAAC;KACjE,CAAC;CACH;IAEmC,OAAO,EAAnC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE;kBAiB5B;AAEM;;;;;;;;;;;;;EAWL"}

package/src/proposals/vtransfer-echoer.js

@@ -0,0 +1,42 @@
+// @ts-check
+import { makeExo } from '@agoric/store';
+import { E } from '@endo/far';
+
+/**
+ * @param {BootstrapPowers & {
+ *   consume: {
+ *     transferMiddleware: import('../transfer.js').TransferMiddleware;
+ *   };
+ * }} powers
+ * @param {object} options
+ * @param {{ target: string }} options.options
+ */
+export const echoVtransfer = async (
+  { consume: { transferMiddleware } },
+  { options: { target } },
+) => {
+  console.warn(`=== vtransfer echoer targeting ${target}`);
+
+  // a tap that simply returns what it received
+  const tap = makeExo('echoer', undefined, {
+    // ack value must be stringlike
+    receiveUpcall: async param => JSON.stringify(param),
+  });
+
+  await E(transferMiddleware).registerActiveTap(target, tap);
+
+  console.warn('=== vtransfer echoer registered');
+};
+
+export const getManifestForVtransferEchoer = (_powers, { target }) => ({
+  manifest: {
+    [echoVtransfer.name]: {
+      consume: {
+        transferMiddleware: 'transferMiddleware',
+      },
+    },
+  },
+  options: {
+    target,
+  },
+});

package/src/transfer.d.ts

@@ -0,0 +1,124 @@
+export function prepareTransferTools(zone: import("@agoric/base-zone").Zone, vowTools: import("@agoric/vow").VowTools): {
+    makeTransferMiddlewareKit: () => import("@endo/exo").GuardedKit<{
+        finisher: {
+            /**
+             * @param {import('./bridge-target').TargetRegistry} registry
+             */
+            useRegistry(registry: import("./bridge-target").TargetRegistry): void;
+        };
+        interceptorFactory: {
+            wrapApp: (tap: globalThis.ERef<TargetApp>, targetHost: globalThis.ERef<TargetHost>, isActiveTap?: boolean | undefined) => import("@endo/exo").Guarded<{
+                receiveUpcall(obj: any): Promise<import("@agoric/vow").Vow<unknown> | undefined>;
+            }>;
+        };
+        transferMiddleware: {
+            /**
+             * Register a tap to intercept the vtransfer target account address
+             * messages, without granting that tap the ability to delay or interfere
+             * with the underlying IBC transfer protocol.
+             *
+             * @type {RegisterTap}
+             */
+            registerTap(target: string, tap: ERef<import("./bridge-target.js").TargetApp>): any;
+            /**
+             * Similar to `registerTap`, but allows the tap to inject async
+             * acknowledgements in the IBC transfer protocol.
+             *
+             * @type {RegisterTap}
+             */
+            registerActiveTap(target: string, tap: ERef<import("./bridge-target.js").TargetApp>): any;
+            /**
+             * Unregister the target.
+             *
+             * @param {string} target String identifying the bridge target to stop
+             *   tapping.
+             */
+            unregisterTap(target: string): Promise<void>;
+        };
+    }>;
+    makeBridgeTargetKit: (manager: import("./types.js").ScopedBridgeManager<import("@agoric/internal").BridgeIdValue>, inboundEventType: string, appTransformer?: import("./bridge-target.js").AppTransformer | undefined) => import("@endo/exo").GuardedKit<{
+        bridgeHandler: {
+            fromBridge(obj: any): Promise<any>;
+        };
+        targetHost: {
+            sendDowncall(obj: any): Promise<any>;
+        };
+        targetRegistry: {
+            register(target: string, app: TargetApp, args?: unknown[] | undefined): Promise<import("./bridge-target.js").TargetRegistration>;
+            reregister(target: string, app: TargetApp, args?: unknown[] | undefined): Promise<void>;
+            unregister(target: string): Promise<void>;
+        };
+    }>;
+};
+export type RegisterTap = (target: string, tap: ERef<import("./bridge-target.js").TargetApp>) => any;
+export type TransferMiddlewareKit = ReturnType<ReturnType<typeof prepareTransferMiddlewareKit>>;
+export type TransferMiddleware = TransferMiddlewareKit["transferMiddleware"];
+import type { TargetApp } from './bridge-target.js';
+import type { TargetHost } from './bridge-target.js';
+/**
+ * @callback RegisterTap
+ * @param {string} target String identifying the bridge target.
+ * @param {ERef<import('./bridge-target.js').TargetApp>} tap The "application
+ *   tap" to register for the target.
+ */
+/**
+ * A TransferMiddlewareKit has a `transferMiddleware` facet with methods for
+ * registering and unregistering active and passive "taps" in a BridgeTargetKit
+ * registry that must use the `interceptorFactory` facet as its appTransfomer to
+ * enforce IBC transfer protocol conformance. Before registering any taps, the
+ * backing BridgeTargetKit must be set with the `finisher` facet (i.e., the
+ * expected setup pattern is to pass in `interceptorFactory` as the
+ * appTransformer argument when making a BridgeTargetKit and then to invoke
+ * `finisher.useRegistry` with the `targetRegistry` of that BridgeTargetKit
+ * before making further use of the TransferMiddlewareKit or connecting the
+ * BridgeTargetKit to a bridge).
+ *
+ * @param {import('@agoric/base-zone').Zone} zone
+ * @param {ReturnType<typeof prepareTransferInterceptor>} makeTransferInterceptor
+ */
+declare function prepareTransferMiddlewareKit(zone: import("@agoric/base-zone").Zone, makeTransferInterceptor: ReturnType<typeof prepareTransferInterceptor>): () => import("@endo/exo").GuardedKit<{
+    finisher: {
+        /**
+         * @param {import('./bridge-target').TargetRegistry} registry
+         */
+        useRegistry(registry: import("./bridge-target").TargetRegistry): void;
+    };
+    interceptorFactory: {
+        wrapApp: (tap: globalThis.ERef<TargetApp>, targetHost: globalThis.ERef<TargetHost>, isActiveTap?: boolean | undefined) => import("@endo/exo").Guarded<{
+            receiveUpcall(obj: any): Promise<import("@agoric/vow").Vow<unknown> | undefined>;
+        }>;
+    };
+    transferMiddleware: {
+        /**
+         * Register a tap to intercept the vtransfer target account address
+         * messages, without granting that tap the ability to delay or interfere
+         * with the underlying IBC transfer protocol.
+         *
+         * @type {RegisterTap}
+         */
+        registerTap(target: string, tap: ERef<import("./bridge-target.js").TargetApp>): any;
+        /**
+         * Similar to `registerTap`, but allows the tap to inject async
+         * acknowledgements in the IBC transfer protocol.
+         *
+         * @type {RegisterTap}
+         */
+        registerActiveTap(target: string, tap: ERef<import("./bridge-target.js").TargetApp>): any;
+        /**
+         * Unregister the target.
+         *
+         * @param {string} target String identifying the bridge target to stop
+         *   tapping.
+         */
+        unregisterTap(target: string): Promise<void>;
+    };
+}>;
+/**
+ * @param {import('@agoric/base-zone').Zone} zone
+ * @param {import('@agoric/vow').VowTools} vowTools
+ */
+declare function prepareTransferInterceptor(zone: import("@agoric/base-zone").Zone, vowTools: import("@agoric/vow").VowTools): (tap: globalThis.ERef<TargetApp>, targetHost: globalThis.ERef<TargetHost>, isActiveTap?: boolean | undefined) => import("@endo/exo").Guarded<{
+    receiveUpcall(obj: any): Promise<import("@agoric/vow").Vow<unknown> | undefined>;
+}>;
+export {};
+//# sourceMappingURL=transfer.d.ts.map

package/src/transfer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer.d.ts","sourceRoot":"","sources":["transfer.js"],"names":[],"mappings":"AAiQO,2CAHI,OAAO,mBAAmB,EAAE,IAAI,YAChC,OAAO,aAAa,EAAE,QAAQ;;;YArDjC;;eAEG;kCADQ,OAAO,iBAAiB,EAAE,cAAc;;;;;;;;YAUnD;;;;;;eAMG;gCAnDA,MAAM,OACN,IAAI,CAAC,OAAO,oBAAoB,EAAE,SAAS,CAAC;YAwD/C;;;;;eAKG;sCA9DA,MAAM,OACN,IAAI,CAAC,OAAO,oBAAoB,EAAE,SAAS,CAAC;YAmE/C;;;;;eAKG;kCAFQ,MAAM;;;;;;;;;;;0CAvBqB,SAC7C;4CAwCyB,SAAS;;;;EAYlC;mCArGU,MAAM,OACN,IAAI,CAAC,OAAO,oBAAoB,EAAE,SAAS,CAAC;oCAiFzC,UAAU,CAAC,UAAU,CAAC,OAAO,4BAA4B,CAAC,CAAC;iCAC3D,qBAAqB,CAAC,oBAAoB,CAAC;+BA/OjB,oBAAoB;gCAApB,oBAAoB;AA0J5D;;;;;GAKG;AAEH;;;;;;;;;;;;;;GAcG;AACH,oDAHW,OAAO,mBAAmB,EAAE,IAAI,2BAChC,UAAU,CAAC,OAAO,0BAA0B,CAAC;;QAgBhD;;WAEG;8BADQ,OAAO,iBAAiB,EAAE,cAAc;;;;;;;;QAUnD;;;;;;WAMG;4BAnDA,MAAM,OACN,IAAI,CAAC,OAAO,oBAAoB,EAAE,SAAS,CAAC;QAwD/C;;;;;WAKG;kCA9DA,MAAM,OACN,IAAI,CAAC,OAAO,oBAAoB,EAAE,SAAS,CAAC;QAmE/C;;;;;WAKG;8BAFQ,MAAM;;GAUtB;AAlOH;;;GAGG;AACH,kDAHW,OAAO,mBAAmB,EAAE,IAAI,YAChC,OAAO,aAAa,EAAE,QAAQ;;GAuHxC"}