@agoric/vats 0.15.2-dev-19b9351.0 → 0.15.2-dev-4dd330d.0

package/src/localchain.js

@@ -9,18 +9,36 @@ import {
   PaymentShape,
 } from '@agoric/ertp';
 import { Shape as NetworkShape } from '@agoric/network';
+import { MsgSend } from '@agoric/cosmic-proto/cosmos/bank/v1beta1/tx.js';
+import { decodeAddressHook } from '@agoric/cosmic-proto/address-hooks.js';
 
 const { Vow$ } = NetworkShape;
 
 /**
+ * @import {MsgSendProtoMsg} from '@agoric/cosmic-proto/cosmos/bank/v1beta1/tx.js';
+ * @import {FungibleTokenPacketData} from '@agoric/cosmic-proto/ibc/applications/transfer/v2/packet.js';
+ * @import {Coin} from '@agoric/cosmic-proto/cosmos/base/v1beta1/coin.js';
  * @import {ERef, EReturn} from '@endo/far';
  * @import {Key, Pattern} from '@endo/patterns';
  * @import {TypedJson, ResponseTo, JsonSafe} from '@agoric/cosmic-proto';
  * @import {Amount, Brand, Payment} from '@agoric/ertp';
- * @import {PromiseVow, VowTools} from '@agoric/vow';
+ * @import {PromiseVow, Vow, VowTools} from '@agoric/vow';
  * @import {TargetApp, TargetRegistration} from './bridge-target.js';
  * @import {BankManager, Bank} from './vat-bank.js';
- * @import {ScopedBridgeManager} from './types.js';
+ * @import {IBCEvent, IBCPacket, ScopedBridgeManager} from './types.js';
+ */
+
+/**
+ * @typedef {SendInfo} NotifyInfo Extend this with any additional notification
+ *   types.
+ */
+
+/**
+ * @typedef {{
+ *   msgTypeUrl: MsgSendProtoMsg['typeUrl'];
+ *   coins: Coin[];
+ *   target: string;
+ * } & Omit<FungibleTokenPacketData, 'amount' | 'denom'>} SendInfo
  */
 
 /**
@@ -52,12 +70,18 @@ const { Vow$ } = NetworkShape;
  * }>}
  */
 
+/**
+ * @template {TypedJson[]} MT
+ * @typedef {{
+ *   [K in keyof MT]: JsonSafe<ResponseTo<MT[K]>>;
+ * }} ResponseToMany
+ */
+
 /**
  * @typedef {{
- *   system: ScopedBridgeManager<'vlocalchain'>;
  *   bank: Bank;
- *   transfer: import('./transfer.js').TransferMiddleware;
- * }} AccountPowers
+ *   lastSequence?: string;
+ * } & Pick<LocalChainPowers, 'system' | 'transfer'>} AccountPowers
  */
 
 /**
@@ -68,6 +92,18 @@ const { Vow$ } = NetworkShape;
  * }} LocalChainPowers
  */
 
+/**
+ * @typedef {WeakMapStore<
+ *   LocalChainPowers['transfer'],
+ *   {
+ *     transferBridgeManager: Pick<
+ *       ScopedBridgeManager<'vtransfer'>,
+ *       'fromBridge'
+ *     >;
+ *   }
+ * >} AdditionalTransferPowers
+ */
+
 export const LocalChainAccountI = M.interface('LocalChainAccount', {
   getAddress: M.callWhen().returns(Vow$(M.string())),
   getBalance: M.callWhen(BrandShape).returns(Vow$(AmountShape)),
@@ -85,9 +121,14 @@ export const LocalChainAccountI = M.interface('LocalChainAccount', {
 
 /**
  * @param {import('@agoric/base-zone').Zone} zone
- * @param {VowTools} vowTools
+ * @param {VowTools & {
+ *   powersForTransfer: AdditionalTransferPowers;
+ * }} powers
  */
-export const prepareLocalChainAccountKit = (zone, { watch }) =>
+export const prepareLocalChainAccountKit = (
+  zone,
+  { watch, allSettled, powersForTransfer },
+) =>
   zone.exoClassKit(
     'LocalChainAccountKit',
     {
@@ -100,15 +141,23 @@ export const prepareLocalChainAccountKit = (zone, { watch }) =>
           })
           .returns(M.promise()),
       }),
+      notifyTransferVatWatcher: M.interface('NotifyTransferVatWatcher', {
+        onFulfilled: M.call(M.any(), M.record()).returns(M.any()),
+      }),
+      overrideWatcher: M.interface('OverrideWatcher', {
+        onFulfilled: M.call(M.any(), M.any()).returns(M.any()),
+      }),
     },
     /**
      * @param {import('@agoric/orchestration').Bech32Address} address
-     * @param {AccountPowers} powers
+     * @param {AccountPowers} accountPowers
      */
-    (address, powers) => ({
+    (address, { bank, system, transfer }) => ({
       address,
-      ...powers,
-      reserved: undefined,
+      bank,
+      system,
+      transfer,
+      lastSequence: 0n,
     }),
     {
       depositPaymentWatcher: {
@@ -124,6 +173,119 @@ export const prepareLocalChainAccountKit = (zone, { watch }) =>
           return E(purse).deposit(payment, optAmountShape);
         },
       },
+      notifyTransferVatWatcher: {
+        /**
+         * @template {TypedJson[]} MT
+         * @param {ResponseToMany<MT>} fulfilment
+         * @param {Record<number, NotifyInfo>} notifyInfos
+         */
+        onFulfilled(fulfilment, notifyInfos) {
+          if (Object.keys(notifyInfos).length === 0) {
+            // No need to notify the transfer bridge manager, so just return.
+            return fulfilment;
+          }
+
+          const { transfer } = this.state;
+          const transferPowers =
+            powersForTransfer.has(transfer) && powersForTransfer.get(transfer);
+          const { transferBridgeManager } = transferPowers || {};
+
+          if (!transferBridgeManager) {
+            // If there is no transfer bridge manager, then we can't notify it,
+            // so bail and just return the fulfilment.
+            return fulfilment;
+          }
+
+          // notify the transfer vat that assets have been sent.
+          const notifyV = allSettled(
+            Object.values(notifyInfos).flatMap(info => {
+              if (!info) {
+                // If there is no info, then this is not a tx message that needs
+                // notification.
+                return [];
+              }
+
+              // If the message is not a MsgSend, then we don't do anything.
+              if (info.msgTypeUrl !== MsgSend.typeUrl) {
+                return [];
+              }
+
+              const sendInfo = /** @type {SendInfo} */ (info);
+
+              const { coins, target, memo, sender, receiver } = sendInfo;
+              /** @type {Omit<FungibleTokenPacketData, 'amount' | 'denom'>} */
+              const sharedFtpData = {
+                sender,
+                receiver,
+                memo,
+              };
+              /** @type {Omit<IBCPacket, 'data' | 'sequence'>} */
+              const sharedPacket = {
+                source_port: 'localchain-msg',
+                source_channel: 'channel-0',
+                destination_port: 'localchain-msg',
+                destination_channel: 'channel-1',
+              };
+              return coins.map(({ denom, amount }) => {
+                // MsgSends are local to this chain, so ensure the transfer packet
+                // reflects that.
+                const transferDenom = `${sharedPacket.source_port}/${sharedPacket.source_channel}/${denom}`;
+
+                /** @type {FungibleTokenPacketData} */
+                const ftpData = {
+                  ...sharedFtpData,
+                  denom: transferDenom,
+                  amount,
+                };
+
+                /** @type {bigint} */
+                const lastSequence = BigInt(this.state.lastSequence ?? 0) + 1n;
+
+                const sequence = String(lastSequence);
+                this.state.lastSequence = lastSequence;
+
+                /** @type {IBCPacket} */
+                const packet = {
+                  ...sharedPacket,
+                  data: btoa(JSON.stringify(ftpData)),
+                  sequence,
+                };
+                /** @type {IBCEvent<'receivePacket', 'VTRANSFER_IBC_EVENT'>} */
+                const obj = {
+                  type: 'VTRANSFER_IBC_EVENT',
+                  event: 'receivePacket',
+                  packet,
+                  target: { onlyIfRegistered: target },
+                };
+                return E(transferBridgeManager).fromBridge(obj);
+              });
+            }),
+          );
+
+          const overrideV = watch(
+            notifyV,
+            this.facets.overrideWatcher,
+            fulfilment,
+          );
+
+          return /** @type {Vow<typeof fulfilment>} */ (
+            /** @type {unknown} */ (overrideV)
+          );
+        },
+      },
+      overrideWatcher: {
+        /**
+         * @template T
+         * @param {unknown} _awaited
+         * @param {T} override
+         * @returns {T}
+         */
+        onFulfilled(_awaited, override) {
+          // This watcher is used to wait for fulfilment, then override the
+          // return.
+          return override;
+        },
+      },
       account: {
         // Information that the account creator needs.
         getAddress() {
@@ -173,6 +335,7 @@ export const prepareLocalChainAccountKit = (zone, { watch }) =>
           const purse = E(bank).getPurse(amount.brand);
           return E(purse).withdraw(amount);
         },
+
         /**
          * Execute a batch of messages on the local chain. Note in particular,
          * that for IBC `MsgTransfer`, execution only queues a packet for the
@@ -186,10 +349,7 @@ export const prepareLocalChainAccountKit = (zone, { watch }) =>
          * @template {TypedJson[]} MT messages tuple (use const with multiple
          *   elements or it will be a mixed array)
          * @param {MT} messages
-         * @returns {PromiseVowOfTupleMappedToGenerics<{
-         *   [K in keyof MT]: JsonSafe<ResponseTo<MT[K]>>;
-         * }>}
-         *
+         * @returns {PromiseVowOfTupleMappedToGenerics<ResponseToMany<MT>>}
          * @see {typedJson} which can be used on arguments to get typed return
          * values.
          */
@@ -197,15 +357,82 @@ export const prepareLocalChainAccountKit = (zone, { watch }) =>
           const { address, system } = this.state;
           messages.length > 0 || Fail`need at least one message to execute`;
 
+          /** @type {Record<number, NotifyInfo>} */
+          const notifyInfos = {};
+
+          const rewrittenMsgs = messages.map((msg, i) => {
+            const { '@type': typeUrl, ...value } = msg;
+            if (typeUrl !== MsgSend.typeUrl) {
+              console.info(
+                `Skipping message ${i} of type ${typeUrl} as it is not a MsgSend`,
+              );
+              return msg;
+            }
+
+            const msgTypeUrl = /** @type {MsgSendProtoMsg['typeUrl']} */ (
+              MsgSend.typeUrl
+            );
+
+            // Since the message is a `MsgSend`, then we remap the receiver
+            // to its unhooked baseAddress.
+            const origSend = MsgSend.fromPartial(value);
+            const { baseAddress: target } = decodeAddressHook(
+              origSend.toAddress,
+            );
+            const newSend = MsgSend.fromPartial({
+              ...value,
+              toAddress: target,
+            });
+
+            const {
+              amount: coins,
+              fromAddress: sender,
+              // Propagate the original hooked address for the target
+              // distinguish.
+              toAddress: receiver,
+            } = origSend;
+
+            /** @type {NotifyInfo} */
+            const info = {
+              msgTypeUrl,
+              coins,
+              target,
+              sender,
+              receiver,
+              memo: JSON.stringify({
+                hookedTypeUrl: msgTypeUrl,
+              }),
+            };
+            notifyInfos[i] = info;
+            return harden({ '@type': msgTypeUrl, ...newSend });
+          });
+
           const obj = {
             type: 'VLOCALCHAIN_EXECUTE_TX',
             // This address is the only one that `VLOCALCHAIN_EXECUTE_TX` will
             // accept as a signer for the transaction.  If the messages have other
             // addresses in signer positions, the transaction will be aborted.
             address,
-            messages,
+            messages: rewrittenMsgs,
           };
-          return E(system).toBridge(obj);
+
+          const notifiedV =
+            /**
+             * @type {PromiseVowOfTupleMappedToGenerics<
+             *   ResponseToMany<MT>
+             * >}
+             */
+            (
+              /** @type {unknown} */ (
+                watch(
+                  E(system).toBridge(obj),
+                  this.facets.notifyTransferVatWatcher,
+                  notifyInfos,
+                )
+              )
+            );
+
+          return notifiedV;
         },
         /**
          * @param {TargetApp} tap
@@ -273,7 +500,7 @@ const prepareLocalChain = (zone, makeAccountKit, { watch }) => {
             type: 'VLOCALCHAIN_ALLOCATE_ADDRESS',
           });
           const bank = await E(bankManager).getBankForAddress(address);
-          return makeAccountKit(address, { system, bank, transfer }).account;
+          return makeAccountKit(address, { bank, system, transfer }).account;
         },
         /**
          * Make a single query to the local chain. Will reject with an error if
@@ -332,13 +559,18 @@ const prepareLocalChain = (zone, makeAccountKit, { watch }) => {
 
 /**
  * @param {import('@agoric/base-zone').Zone} zone
- * @param {VowTools} vowTools
+ * @param {VowTools & { powersForTransfer: AdditionalTransferPowers }} powers
  */
-export const prepareLocalChainTools = (zone, vowTools) => {
-  const makeAccountKit = prepareLocalChainAccountKit(zone, vowTools);
-  const makeLocalChain = prepareLocalChain(zone, makeAccountKit, vowTools);
+export const prepareLocalChainTools = (zone, powers) => {
+  const { powersForTransfer: _, ...localChainPowers } = powers;
+  const makeLocalChainAccountKit = prepareLocalChainAccountKit(zone, powers);
+  const makeLocalChain = prepareLocalChain(
+    zone,
+    makeLocalChainAccountKit,
+    localChainPowers,
+  );
 
-  return harden({ makeLocalChain });
+  return makeLocalChain;
 };
 harden(prepareLocalChainTools);
 /** @typedef {ReturnType<typeof prepareLocalChainTools>} LocalChainTools */

package/src/proposals/localchain-hook-msg-send.d.ts

@@ -0,0 +1,26 @@
+export function upgradeAndInterceptMsgSend(powers: BootstrapPowers & {
+    consume: {
+        vtransferBridgeManager: import("../types.js").ScopedBridgeManager<"vtransfer">;
+        transferMiddleware: import("../transfer.js").TransferMiddleware;
+        vatAdminSvc: VatAdminSvc;
+        vatStore: MapStore<string, import("@agoric/swingset-vat").CreateVatResults>;
+    };
+}, options: object): Promise<void>;
+export function getManifestForMsgSendToTransfer(powers: any, arg: any): {
+    options: {
+        bundleRefs: any;
+        vatOptions: any;
+    };
+    manifest: {
+        [upgradeAndInterceptMsgSend.name]: {
+            consume: {
+                vtransferBridgeManager: string;
+                transferMiddleware: string;
+                vatStore: string;
+                vatAdminSvc: string;
+            };
+            produce: {};
+        };
+    };
+};
+//# sourceMappingURL=localchain-hook-msg-send.d.ts.map

package/src/proposals/localchain-hook-msg-send.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localchain-hook-msg-send.d.ts","sourceRoot":"","sources":["localchain-hook-msg-send.js"],"names":[],"mappings":"AAqBO,mDAbI,eAAe,GAAG;IACxB,OAAO,EAAE;QACP,sBAAsB,EAAE,OAAO,aAAa,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;QAC/E,kBAAkB,EAAE,OAAO,gBAAgB,EAAE,kBAAkB,CAAC;QAChE,WAAW,EAAE,WAAW,CAAC;QACzB,QAAQ,EAAE,QAAQ,CACxB,MAAc,EACd,OAAe,sBAAsB,EAAE,gBAAgB,CAChD,CAAC;KACH,CAAC;CACH,WACO,MAAM,iBAuBhB;AAEM;;;;;;QAaD,CAAC,0BAA0B,CAAC,IAAI,CAAC;;;;;;;;UAQhC;;EAIN"}

package/src/proposals/localchain-hook-msg-send.js

@@ -0,0 +1,70 @@
+// @ts-check
+import { E } from '@endo/far';
+import {
+  getManifestForUpgradingVats,
+  upgradeVatsGeneric,
+} from './upgrade-vats-generic-proposal.js';
+
+/**
+ * @param {BootstrapPowers & {
+ *   consume: {
+ *     vtransferBridgeManager: import('../types.js').ScopedBridgeManager<'vtransfer'>;
+ *     transferMiddleware: import('../transfer.js').TransferMiddleware;
+ *     vatAdminSvc: VatAdminSvc;
+ *     vatStore: MapStore<
+ *       string,
+ *       import('@agoric/swingset-vat').CreateVatResults
+ *     >;
+ *   };
+ * }} powers
+ * @param {object} options
+ */
+export const upgradeAndInterceptMsgSend = async (powers, options) => {
+  const {
+    consume: {
+      vtransferBridgeManager: vtransferBridgeManagerP,
+      transferMiddleware: transferMiddlewareP,
+    },
+  } = powers;
+
+  // Go on to upgrade the vats and provide the transferBridgeManager.
+  const upgradeRoots = await upgradeVatsGeneric(powers, options);
+
+  const [transferMiddleware, transferBridgeManager] = await Promise.all([
+    transferMiddlewareP,
+    vtransferBridgeManagerP,
+  ]);
+
+  // Link the transferBridgeManager with the localchain vat.
+  await E(upgradeRoots.localchain).linkTransferMiddlewareToBridgeManager(
+    transferMiddleware,
+    transferBridgeManager,
+  );
+};
+
+export const getManifestForMsgSendToTransfer = (powers, arg) => {
+  const {
+    manifest: { [upgradeVatsGeneric.name]: upgradeVatsManifest, ...empty },
+    ...rest
+  } = getManifestForUpgradingVats(powers, arg);
+  assert.equal(
+    Object.keys(empty).length,
+    0,
+    'expected empty remaining manifest',
+  );
+
+  return {
+    manifest: {
+      [upgradeAndInterceptMsgSend.name]: {
+        ...upgradeVatsManifest,
+        consume: {
+          ...upgradeVatsManifest.consume,
+          vtransferBridgeManager: 'hookedMsgSend',
+          transferMiddleware: 'hookedMsgSend',
+          vatStore: 'hookedMsgSend',
+        },
+      },
+    },
+    ...rest,
+  };
+};

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

@@ -1,9 +1,10 @@
-export function setupLocalChainVat({ consume: { loadCriticalVat, bridgeManager: bridgeManagerP, localchainBridgeManager: localchainBridgeManagerP, bankManager, transferMiddleware, }, produce: { localchainVat, localchain, localchainBridgeManager }, }: BootstrapPowers & {
+export function setupLocalChainVat({ consume: { loadCriticalVat, bridgeManager: bridgeManagerP, localchainBridgeManager: localchainBridgeManagerP, bankManager: bankManagerP, transferMiddleware: transferMiddlewareP, vtransferBridgeManager: vtransferBridgeManagerP, }, produce: { localchainVat, localchain, localchainBridgeManager }, }: BootstrapPowers & {
     consume: {
         bridgeManager: import("../types").BridgeManager;
         localchainBridgeManager: import("../types").ScopedBridgeManager<"vlocalchain">;
         bankManager: Promise<import("../vat-bank.js").BankManager>;
         transferMiddleware: Promise<import("../transfer.js").TransferMiddleware>;
+        vtransferBridgeManager: Promise<import("../types").ScopedBridgeManager<"vtransfer">>;
     };
     produce: {
         localchain: Producer<any>;
@@ -31,6 +32,7 @@ export function getManifestForLocalChain(_powers: any, { localchainRef }: {
                 localchainBridgeManager: string;
                 bankManager: string;
                 transferMiddleware: string;
+                vtransferBridgeManager: string;
             };
             produce: {
                 localchain: string;

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

@@ -1 +1 @@
-{"version":3,"file":"localchain-proposal.d.ts","sourceRoot":"","sources":["localchain-proposal.js"],"names":[],"mappings":"AA0BO,2PApBI,eAAe,GAAG;IACxB,OAAO,EAAE;QACP,aAAa,EAAE,OAAO,UAAU,EAAE,aAAa,CAAC;QAChD,uBAAuB,EAAE,OAAO,UAAU,EAAE,mBAAmB,CAAC,aAAa,CAAC,CAAC;QAC/E,WAAW,EAAE,OAAO,CAAC,OAAO,gBAAgB,EAAE,WAAW,CAAC,CAAC;QAC3D,kBAAkB,EAAE,OAAO,CAAC,OAAO,gBAAgB,EAAE,kBAAkB,CAAC,CAAC;KAC1E,CAAC;IACF,OAAO,EAAE;QACP,UAAU,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QAC1B,aAAa,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QAC7B,uBAAuB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;KACxC,CAAC;CACH,WAED;IAAiD,OAAO,EAAhD;QAAE,aAAa,EAAE,YAAY,CAAA;KAAE;CAEvC,iBA6DF;AAUM,2EAPI,eAAe,GAAG;IACxB,OAAO,EAAE;QACP,UAAU,EAAE,OAAO,kBAAkB,EAAE,UAAU,CAAC;KACnD,CAAC;CACH,YACO,MAAM,iBAOhB;AAEM;;;;QAEH,CAAC,kBAAkB,CAAC,IAAI,CAAC;;;;;;;;;;;;;UAaxB;QAED,CAAC,qBAAqB,CAAC,IAAI,CAAC;;;;;UAK3B;;;;;EAKH;6BAzGW;IACR,UAAU,EAAE,IAAI,CAAC,OAAO,sBAAsB,EAAE,aAAa,CAAC,CAAC;CAChE"}
+{"version":3,"file":"localchain-proposal.d.ts","sourceRoot":"","sources":["localchain-proposal.js"],"names":[],"mappings":"AA6BO,+UAvBI,eAAe,GAAG;IACxB,OAAO,EAAE;QACP,aAAa,EAAE,OAAO,UAAU,EAAE,aAAa,CAAC;QAChD,uBAAuB,EAAE,OAAO,UAAU,EAAE,mBAAmB,CAAC,aAAa,CAAC,CAAC;QAC/E,WAAW,EAAE,OAAO,CAAC,OAAO,gBAAgB,EAAE,WAAW,CAAC,CAAC;QAC3D,kBAAkB,EAAE,OAAO,CAAC,OAAO,gBAAgB,EAAE,kBAAkB,CAAC,CAAC;QACzE,sBAAsB,EAAE,OAAO,CACrC,OAAe,UAAU,EAAE,mBAAmB,CAAC,WAAW,CAAC,CACpD,CAAC;KACH,CAAC;IACF,OAAO,EAAE;QACP,UAAU,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QAC1B,aAAa,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;QAC7B,uBAAuB,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;KACxC,CAAC;CACH,WAED;IAAiD,OAAO,EAAhD;QAAE,aAAa,EAAE,YAAY,CAAA;KAAE;CAEvC,iBA0EF;AAUM,2EAPI,eAAe,GAAG;IACxB,OAAO,EAAE;QACP,UAAU,EAAE,OAAO,kBAAkB,EAAE,UAAU,CAAC;KACnD,CAAC;CACH,YACO,MAAM,iBAOhB;AAEM;;;;QAEH,CAAC,kBAAkB,CAAC,IAAI,CAAC;;;;;;;;;;;;;;UAcxB;QAED,CAAC,qBAAqB,CAAC,IAAI,CAAC;;;;;UAK3B;;;;;EAKH;6BAvHW;IACR,UAAU,EAAE,IAAI,CAAC,OAAO,sBAAsB,EAAE,aAAa,CAAC,CAAC;CAChE"}

package/src/proposals/localchain-proposal.js

@@ -10,6 +10,9 @@ import { makeScopedBridge } from '../bridge.js';
  *     localchainBridgeManager: import('../types').ScopedBridgeManager<'vlocalchain'>;
  *     bankManager: Promise<import('../vat-bank.js').BankManager>;
  *     transferMiddleware: Promise<import('../transfer.js').TransferMiddleware>;
+ *     vtransferBridgeManager: Promise<
+ *       import('../types').ScopedBridgeManager<'vtransfer'>
+ *     >;
  *   };
  *   produce: {
  *     localchain: Producer<any>;
@@ -30,8 +33,9 @@ export const setupLocalChainVat = async (
       loadCriticalVat,
       bridgeManager: bridgeManagerP,
       localchainBridgeManager: localchainBridgeManagerP,
-      bankManager,
-      transferMiddleware,
+      bankManager: bankManagerP,
+      transferMiddleware: transferMiddlewareP,
+      vtransferBridgeManager: vtransferBridgeManagerP,
     },
     produce: { localchainVat, localchain, localchainBridgeManager },
   },
@@ -73,12 +77,24 @@ export const setupLocalChainVat = async (
     );
   }
 
+  const [transferBridgeManager, transfer, bankManager] = await Promise.all([
+    vtransferBridgeManagerP,
+    transferMiddlewareP,
+    bankManagerP,
+  ]);
+
   const newLocalChain = await E(vats.localchain).makeLocalChain({
     system: scopedManager,
-    bankManager: await bankManager,
-    transfer: await transferMiddleware,
+    bankManager,
+    transfer,
   });
 
+  // Allow the localchain to obtain the bridge manager via the middleware.
+  await E(vats.localchain).linkTransferMiddlewareToBridgeManager(
+    transfer,
+    transferBridgeManager,
+  );
+
   localchain.reset();
   localchain.resolve(newLocalChain);
 };
@@ -107,6 +123,7 @@ export const getManifestForLocalChain = (_powers, { localchainRef }) => ({
         localchainBridgeManager: 'localchain',
         bankManager: 'bank',
         transferMiddleware: 'transfer',
+        vtransferBridgeManager: 'vtransfer',
       },
       produce: {
         localchain: 'localchain',

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

@@ -1,4 +1,4 @@
-export function testLocalChain({ consume: { chainStorage, localchain } }: BootstrapPowers & {
+export function testLocalChain({ consume: { board, chainStorage, localchain } }: BootstrapPowers & {
     consume: {
         localchain: import("../localchain.js").LocalChain;
     };
@@ -13,9 +13,13 @@ export function getManifestForLocalChainTest(_powers: any, { testResultPath }: {
     manifest: {
         [testLocalChain.name]: {
             consume: {
+                board: string;
                 chainStorage: string;
                 localchain: string;
             };
+            produce: {
+                testLocalChain: string;
+            };
         };
     };
     options: {

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;IACxB,OAAO,EAAE;QACP,UAAU,EAAE,OAAO,kBAAkB,EAAE,UAAU,CAAC;KACnD,CAAC;CACH,mCAED;IAA4C,OAAO,EAA3C;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE;CACpC,iBA8DA;AAEM;;;;QAEH,CAAC,cAAc,CAAC,IAAI,CAAC;;;;;UAKpB;;;;;EAKH"}
+{"version":3,"file":"localchain-test.d.ts","sourceRoot":"","sources":["localchain-test.js"],"names":[],"mappings":"AAcO,iFARI,eAAe,GAAG;IACxB,OAAO,EAAE;QACP,UAAU,EAAE,OAAO,kBAAkB,EAAE,UAAU,CAAC;KACnD,CAAC;CACH,mCAED;IAA4C,OAAO,EAA3C;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE;CACpC,iBAmHA;AAEM;;;;QAEH,CAAC,cAAc,CAAC,IAAI,CAAC;;;;;;;;;UASpB;;;;;EAKH"}