@agoric/fast-usdc 0.2.0-u18a.0 → 0.2.0-u19.1

package/src/exos/settler.js

@@ -8,20 +8,72 @@ import { M } from '@endo/patterns';
 import { decodeAddressHook } from '@agoric/cosmic-proto/address-hooks.js';
 import { PendingTxStatus } from '../constants.js';
 import { makeFeeTools } from '../utils/fees.js';
-import { EvmHashShape } from '../type-guards.js';
+import {
+  CctpTxEvidenceShape,
+  EvmHashShape,
+  makeNatAmountShape,
+} from '../type-guards.js';
 
 /**
  * @import {FungibleTokenPacketData} from '@agoric/cosmic-proto/ibc/applications/transfer/v2/packet.js';
+ * @import {Amount, Brand, NatValue, Payment} from '@agoric/ertp';
  * @import {Denom, OrchestrationAccount, ChainHub, ChainAddress} from '@agoric/orchestration';
  * @import {WithdrawToSeat} from '@agoric/orchestration/src/utils/zoe-tools'
- * @import {IBCChannelID, VTransferIBCEvent} from '@agoric/vats';
+ * @import {IBCChannelID, IBCPacket, VTransferIBCEvent} from '@agoric/vats';
  * @import {Zone} from '@agoric/zone';
  * @import {HostOf, HostInterface} from '@agoric/async-flow';
  * @import {TargetRegistration} from '@agoric/vats/src/bridge-target.js';
- * @import {NobleAddress, LiquidityPoolKit, FeeConfig, EvmHash, LogFn} from '../types.js';
+ * @import {NobleAddress, LiquidityPoolKit, FeeConfig, EvmHash, LogFn, CctpTxEvidence} from '../types.js';
  * @import {StatusManager} from './status-manager.js';
  */
 
+/**
+ * @param {IBCPacket} data
+ * @param {string} remoteDenom
+ * @returns {{ nfa: NobleAddress, amount: bigint, EUD: string } | {error: object[]}}
+ */
+const decodeEventPacket = ({ data }, remoteDenom) => {
+  // NB: may not be a FungibleTokenPacketData or even JSON
+  /** @type {FungibleTokenPacketData} */
+  let tx;
+  try {
+    tx = JSON.parse(atob(data));
+  } catch (e) {
+    return { error: ['could not parse packet data', data] };
+  }
+
+  // given the sourceChannel check, we can be certain of this cast
+  const nfa = /** @type {NobleAddress} */ (tx.sender);
+
+  if (tx.denom !== remoteDenom) {
+    const { denom: actual } = tx;
+    return { error: ['unexpected denom', { actual, expected: remoteDenom }] };
+  }
+
+  let EUD;
+  try {
+    ({ EUD } = decodeAddressHook(tx.receiver).query);
+    if (!EUD) {
+      return { error: ['no EUD parameter', tx.receiver] };
+    }
+    if (typeof EUD !== 'string') {
+      return { error: ['EUD is not a string', EUD] };
+    }
+  } catch (e) {
+    return { error: ['no query params', tx.receiver] };
+  }
+
+  let amount;
+  try {
+    amount = BigInt(tx.amount);
+  } catch (e) {
+    return { error: ['invalid amount', tx.amount] };
+  }
+
+  return { nfa, amount, EUD };
+};
+harden(decodeEventPacket);
+
 /**
  * NOTE: not meant to be parsable.
  *
@@ -31,6 +83,25 @@ import { EvmHashShape } from '../type-guards.js';
 const makeMintedEarlyKey = (addr, amount) =>
   `pendingTx:${JSON.stringify([addr, String(amount)])}`;
 
+/** @param {Brand<'nat'>} USDC */
+export const makeAdvanceDetailsShape = USDC =>
+  harden({
+    destination: ChainAddressShape,
+    forwardingAddress: M.string(),
+    fullAmount: makeNatAmountShape(USDC),
+    txHash: EvmHashShape,
+  });
+
+export const stateShape = harden({
+  repayer: M.remotable('Repayer'),
+  settlementAccount: M.remotable('Account'),
+  registration: M.or(M.undefined(), M.remotable('Registration')),
+  sourceChannel: M.string(),
+  remoteDenom: M.string(),
+  mintedEarly: M.remotable('mintedEarly'),
+  intermediateRecipient: M.opt(ChainAddressShape),
+});
+
 /**
  * @param {Zone} zone
  * @param {object} caps
@@ -67,26 +138,23 @@ export const prepareSettler = (
       tap: M.interface('SettlerTapI', {
         receiveUpcall: M.call(M.record()).returns(M.promise()),
       }),
-      notify: M.interface('SettlerNotifyI', {
+      notifier: M.interface('SettlerNotifyI', {
         notifyAdvancingResult: M.call(
-          M.record(), // XXX fill in details TODO
+          makeAdvanceDetailsShape(USDC),
           M.boolean(),
         ).returns(),
+        checkMintedEarly: M.call(
+          CctpTxEvidenceShape,
+          ChainAddressShape,
+        ).returns(M.boolean()),
       }),
       self: M.interface('SettlerSelfI', {
-        disburse: M.call(EvmHashShape, M.string(), M.nat()).returns(
-          M.promise(),
-        ),
-        forward: M.call(
-          M.opt(EvmHashShape),
-          M.string(),
-          M.nat(),
-          M.string(),
-        ).returns(),
+        disburse: M.call(EvmHashShape, M.nat()).returns(M.promise()),
+        forward: M.call(EvmHashShape, M.nat(), M.string()).returns(),
       }),
       transferHandler: M.interface('SettlerTransferI', {
-        onFulfilled: M.call(M.any(), M.record()).returns(),
-        onRejected: M.call(M.any(), M.record()).returns(),
+        onFulfilled: M.call(M.undefined(), M.string()).returns(),
+        onRejected: M.call(M.error(), M.string()).returns(),
       }),
     },
     /**
@@ -137,61 +205,40 @@ export const prepareSettler = (
             return;
           }
 
-          // TODO: why is it safe to cast this without a runtime check?
-          const tx = /** @type {FungibleTokenPacketData} */ (
-            JSON.parse(atob(packet.data))
-          );
-
-          // given the sourceChannel check, we can be certain of this cast
-          const nfa = /** @type {NobleAddress} */ (tx.sender);
-
-          if (tx.denom !== remoteDenom) {
-            const { denom: actual } = tx;
-            log('unexpected denom', { actual, expected: remoteDenom });
-            return;
-          }
-
-          let EUD;
-          try {
-            ({ EUD } = decodeAddressHook(tx.receiver).query);
-            if (!EUD) {
-              log('no EUD parameter', tx.receiver);
-              return;
-            }
-            if (typeof EUD !== 'string') {
-              log('EUD is not a string', EUD);
-              return;
-            }
-          } catch (e) {
-            log('no query params', tx.receiver);
+          const decoded = decodeEventPacket(event.packet, remoteDenom);
+          if ('error' in decoded) {
+            log('invalid event packet', decoded.error);
             return;
           }
 
-          const amount = BigInt(tx.amount); // TODO: what if this throws?
-
+          const { nfa, amount, EUD } = decoded;
           const { self } = this.facets;
           const found = statusManager.dequeueStatus(nfa, amount);
           log('dequeued', found, 'for', nfa, amount);
           switch (found?.status) {
             case PendingTxStatus.Advanced:
-              return self.disburse(found.txHash, nfa, amount);
+              return self.disburse(found.txHash, amount);
 
             case PendingTxStatus.Advancing:
+              log('⚠️ tap: minted while advancing', nfa, amount);
               this.state.mintedEarly.add(makeMintedEarlyKey(nfa, amount));
               return;
 
             case PendingTxStatus.Observed:
             case PendingTxStatus.AdvanceSkipped:
             case PendingTxStatus.AdvanceFailed:
-              return self.forward(found.txHash, nfa, amount, EUD);
+              return self.forward(found.txHash, amount, EUD);
 
             case undefined:
             default:
-              log('⚠️ tap: no status for ', nfa, amount);
+              log('⚠️ tap: minted before observed', nfa, amount);
+              // XXX consider capturing in vstorage
+              // we would need a new key, as this does not have a txHash
+              this.state.mintedEarly.add(makeMintedEarlyKey(nfa, amount));
           }
         },
       },
-      notify: {
+      notifier: {
         /**
          * @param {object} ctx
          * @param {EvmHash} ctx.txHash
@@ -210,16 +257,12 @@ export const prepareSettler = (
           const key = makeMintedEarlyKey(forwardingAddress, fullValue);
           if (mintedEarly.has(key)) {
             mintedEarly.delete(key);
+            statusManager.advanceOutcomeForMintedEarly(txHash, success);
             if (success) {
-              void this.facets.self.disburse(
-                txHash,
-                forwardingAddress,
-                fullValue,
-              );
+              void this.facets.self.disburse(txHash, fullValue);
             } else {
               void this.facets.self.forward(
                 txHash,
-                forwardingAddress,
                 fullValue,
                 destination.value,
               );
@@ -228,14 +271,39 @@ export const prepareSettler = (
             statusManager.advanceOutcome(forwardingAddress, fullValue, success);
           }
         },
+        /**
+         * @param {CctpTxEvidence} evidence
+         * @param {ChainAddress} destination
+         * @returns {boolean}
+         * @throws {Error} if minted early, so advancer doesn't advance
+         */
+        checkMintedEarly(evidence, destination) {
+          const {
+            tx: { forwardingAddress, amount },
+            txHash,
+          } = evidence;
+          const key = makeMintedEarlyKey(forwardingAddress, amount);
+          const { mintedEarly } = this.state;
+          if (mintedEarly.has(key)) {
+            log(
+              'matched minted early key, initiating forward',
+              forwardingAddress,
+              amount,
+            );
+            mintedEarly.delete(key);
+            statusManager.advanceOutcomeForUnknownMint(evidence);
+            void this.facets.self.forward(txHash, amount, destination.value);
+            return true;
+          }
+          return false;
+        },
       },
       self: {
         /**
          * @param {EvmHash} txHash
-         * @param {NobleAddress} nfa
          * @param {NatValue} fullValue
          */
-        async disburse(txHash, nfa, fullValue) {
+        async disburse(txHash, fullValue) {
           const { repayer, settlementAccount } = this.state;
           const received = AmountMath.make(USDC, fullValue);
           const { zcfSeat: settlingSeat } = zcf.makeEmptySeatKit();
@@ -259,76 +327,67 @@ export const prepareSettler = (
             harden([[settlingSeat, settlingSeat, { In: received }, split]]),
           );
           repayer.repay(settlingSeat, split);
+          settlingSeat.exit();
 
-          // update status manager, marking tx `SETTLED`
+          // update status manager, marking tx `DISBURSED`
           statusManager.disbursed(txHash, split);
         },
         /**
          * @param {EvmHash} txHash
-         * @param {NobleAddress} nfa
          * @param {NatValue} fullValue
          * @param {string} EUD
          */
-        forward(txHash, nfa, fullValue, EUD) {
+        forward(txHash, fullValue, EUD) {
           const { settlementAccount, intermediateRecipient } = this.state;
 
-          const dest = chainHub.makeChainAddress(EUD);
+          const dest = (() => {
+            try {
+              return chainHub.makeChainAddress(EUD);
+            } catch (e) {
+              log('⚠️ forward transfer failed!', e, txHash);
+              statusManager.forwarded(txHash, false);
+              return null;
+            }
+          })();
+          if (!dest) return;
 
-          // TODO? statusManager.forwarding(txHash, sender, amount);
           const txfrV = E(settlementAccount).transfer(
             dest,
             AmountMath.make(USDC, fullValue),
             { forwardOpts: { intermediateRecipient } },
           );
-          void vowTools.watch(txfrV, this.facets.transferHandler, {
-            txHash,
-            nfa,
-            fullValue,
-          });
+          void vowTools.watch(txfrV, this.facets.transferHandler, txHash);
         },
       },
       transferHandler: {
         /**
          * @param {unknown} _result
-         * @param {SettlerTransferCtx} ctx
-         *
-         * @typedef {{
-         *   txHash: EvmHash;
-         *   nfa: NobleAddress;
-         *   fullValue: NatValue;
-         * }} SettlerTransferCtx
+         * @param {EvmHash} txHash
          */
-        onFulfilled(_result, ctx) {
-          const { txHash, nfa, fullValue } = ctx;
-          statusManager.forwarded(txHash, nfa, fullValue);
+        onFulfilled(_result, txHash) {
+          // update status manager, marking tx `FORWARDED` without fee split
+          statusManager.forwarded(txHash, true);
         },
         /**
          * @param {unknown} reason
-         * @param {SettlerTransferCtx} ctx
+         * @param {EvmHash} txHash
          */
-        onRejected(reason, ctx) {
-          log('⚠️ transfer rejected!', reason, ctx);
-          // const { txHash, nfa, amount } = ctx;
-          // TODO(#10510): statusManager.forwardFailed(txHash, nfa, amount);
+        onRejected(reason, txHash) {
+          // funds remain in `settlementAccount` and must be recovered via a
+          // contract upgrade
+          log('🚨 forward transfer rejected!', reason, txHash);
+          // update status manager, flagging a terminal state that needs to be
+          // manual intervention or a code update to remediate
+          statusManager.forwarded(txHash, false);
         },
       },
     },
     {
-      stateShape: harden({
-        repayer: M.remotable('Repayer'),
-        settlementAccount: M.remotable('Account'),
-        registration: M.or(M.undefined(), M.remotable('Registration')),
-        sourceChannel: M.string(),
-        remoteDenom: M.string(),
-        mintedEarly: M.remotable('mintedEarly'),
-        intermediateRecipient: M.opt(ChainAddressShape),
-      }),
+      stateShape,
     },
   );
 };
 harden(prepareSettler);
 
-/**
- * XXX consider using pickFacet (do we have pickFacets?)
- * @typedef {ReturnType<ReturnType<typeof prepareSettler>>} SettlerKit
- */
+// Expose the whole kit because the contract needs `creatorFacet` and the Advancer needs `notifier`
+/** @typedef {ReturnType<ReturnType<typeof prepareSettler>>} SettlerKit */

package/src/exos/status-manager.js

@@ -53,6 +53,12 @@ const pendingTxKeyOf = evidence => {
  * }} StatusManagerPowers
  */
 
+export const stateShape = harden({
+  pendingSettleTxs: M.remotable(),
+  seenTxs: M.remotable(),
+  storedCompletedTxs: M.remotable(),
+});
+
 /**
  * The `StatusManager` keeps track of Pending and Seen Transactions
  * via {@link PendingTxStatus} states, aiding in coordination between the `Advancer`
@@ -69,14 +75,15 @@ export const prepareStatusManager = (
   txnsNode,
   {
     marshaller,
-    log = makeTracer('Advancer', true),
+    // eslint-disable-next-line no-unused-vars
+    log = makeTracer('StatusManager', true),
   } = /** @type {StatusManagerPowers} */ ({}),
 ) => {
   /**
    * Keyed by a tuple of the Noble Forwarding Account and amount.
    * @type {MapStore<PendingTxKey, PendingTx[]>}
    */
-  const pendingTxs = zone.mapStore('PendingTxs', {
+  const pendingSettleTxs = zone.mapStore('PendingSettleTxs', {
     keyShape: M.string(),
     valueShape: M.arrayOf(PendingTxShape),
   });
@@ -84,13 +91,18 @@ export const prepareStatusManager = (
   /**
    * Transactions seen *ever* by the contract.
    *
-   * Note that like all durable stores, this SetStore is stored in IAVL. It
-   * grows without bound (though the amount of growth per incoming message to
-   * the contract is bounded). At some point in the future we may want to prune.
-   * @type {SetStore<EvmHash>}
+   * Note that like all durable stores, this MapStore is kept in IAVL. It stores
+   * the `blockTimestamp` so that later we can prune old transactions.
+   *
+   * Note that `blockTimestamp` can drift between chains. Fortunately all CCTP
+   * chains use the same Unix epoch and won't drift more than minutes apart,
+   * which is more than enough precision for pruning old transaction.
+   *
+   * @type {MapStore<EvmHash, NatValue>}
    */
-  const seenTxs = zone.setStore('SeenTxs', {
+  const seenTxs = zone.mapStore('SeenTxs', {
     keyShape: M.string(),
+    valueShape: M.nat(),
   });
 
   /**
@@ -153,10 +165,10 @@ export const prepareStatusManager = (
     if (seenTxs.has(txHash)) {
       throw makeError(`Transaction already seen: ${q(txHash)}`);
     }
-    seenTxs.add(txHash);
+    seenTxs.init(txHash, evidence.blockTimestamp);
 
     appendToStoredArray(
-      pendingTxs,
+      pendingSettleTxs,
       pendingTxKeyOf(evidence),
       harden({ ...evidence, status }),
     );
@@ -177,8 +189,8 @@ export const prepareStatusManager = (
    */
   function setPendingTxStatus({ nfa, amount }, status) {
     const key = makePendingTxKey(nfa, amount);
-    pendingTxs.has(key) || Fail`no advancing tx with ${{ nfa, amount }}`;
-    const pending = pendingTxs.get(key);
+    pendingSettleTxs.has(key) || Fail`no advancing tx with ${{ nfa, amount }}`;
+    const pending = pendingSettleTxs.get(key);
     const ix = pending.findIndex(tx => tx.status === PendingTxStatus.Advancing);
     ix >= 0 || Fail`no advancing tx with ${{ nfa, amount }}`;
     const [prefix, tx, suffix] = [
@@ -187,7 +199,7 @@ export const prepareStatusManager = (
       pending.slice(ix + 1),
     ];
     const txpost = { ...tx, status };
-    pendingTxs.set(key, harden([...prefix, txpost, ...suffix]));
+    pendingSettleTxs.set(key, harden([...prefix, txpost, ...suffix]));
     void publishTxnRecord(tx.txHash, harden({ status }));
   }
 
@@ -195,24 +207,19 @@ export const prepareStatusManager = (
     'Fast USDC Status Manager',
     M.interface('StatusManagerI', {
       // TODO: naming scheme for transition events
-      advance: M.call(CctpTxEvidenceShape).returns(M.undefined()),
+      advance: M.call(CctpTxEvidenceShape).returns(),
       advanceOutcome: M.call(M.string(), M.nat(), M.boolean()).returns(),
-      skipAdvance: M.call(CctpTxEvidenceShape, M.arrayOf(M.string())).returns(
-        M.undefined(),
-      ),
-      observe: M.call(CctpTxEvidenceShape).returns(M.undefined()),
+      skipAdvance: M.call(CctpTxEvidenceShape, M.arrayOf(M.string())).returns(),
+      advanceOutcomeForMintedEarly: M.call(EvmHashShape, M.boolean()).returns(),
+      advanceOutcomeForUnknownMint: M.call(CctpTxEvidenceShape).returns(),
+      observe: M.call(CctpTxEvidenceShape).returns(),
       hasBeenObserved: M.call(CctpTxEvidenceShape).returns(M.boolean()),
       deleteCompletedTxs: M.call().returns(M.undefined()),
       dequeueStatus: M.call(M.string(), M.bigint()).returns(
         M.or(
           {
             txHash: EvmHashShape,
-            status: M.or(
-              PendingTxStatus.Advanced,
-              PendingTxStatus.AdvanceSkipped,
-              PendingTxStatus.AdvanceFailed,
-              PendingTxStatus.Observed,
-            ),
+            status: M.or(...Object.values(PendingTxStatus)),
           },
           M.undefined(),
         ),
@@ -220,9 +227,7 @@ export const prepareStatusManager = (
       disbursed: M.call(EvmHashShape, AmountKeywordRecordShape).returns(
         M.undefined(),
       ),
-      forwarded: M.call(M.opt(EvmHashShape), M.string(), M.nat()).returns(
-        M.undefined(),
-      ),
+      forwarded: M.call(EvmHashShape, M.boolean()).returns(),
       lookupPending: M.call(M.string(), M.bigint()).returns(
         M.arrayOf(PendingTxShape),
       ),
@@ -258,7 +263,7 @@ export const prepareStatusManager = (
       },
 
       /**
-       * Record result of ADVANCING
+       * Record result of an ADVANCING transaction
        *
        * @param {NobleAddress} nfa Noble Forwarding Account
        * @param {import('@agoric/ertp').NatValue} amount
@@ -272,6 +277,43 @@ export const prepareStatusManager = (
         );
       },
 
+      /**
+       * If minted while advancing, publish a status update for the advance
+       * to vstorage.
+       *
+       * Does not add or amend `pendingSettleTxs` as this has
+       * already settled.
+       *
+       * @param {EvmHash} txHash
+       * @param {boolean} success whether the Transfer succeeded
+       */
+      advanceOutcomeForMintedEarly(txHash, success) {
+        void publishTxnRecord(
+          txHash,
+          harden({
+            status: success
+              ? PendingTxStatus.Advanced
+              : PendingTxStatus.AdvanceFailed,
+          }),
+        );
+      },
+
+      /**
+       * If minted before observed and the evidence is eventually
+       * reported, publish the evidence without adding to `pendingSettleTxs`
+       *
+       * @param {CctpTxEvidence} evidence
+       */
+      advanceOutcomeForUnknownMint(evidence) {
+        const { txHash } = evidence;
+        // unexpected path, since `hasBeenObserved` will be called before this
+        if (seenTxs.has(txHash)) {
+          throw makeError(`Transaction already seen: ${q(txHash)}`);
+        }
+        seenTxs.init(txHash, evidence.blockTimestamp);
+        publishEvidence(txHash, evidence);
+      },
+
       /**
        * Add a new transaction with OBSERVED status
        * @param {CctpTxEvidence} evidence
@@ -303,34 +345,32 @@ export const prepareStatusManager = (
       },
 
       /**
-       * Remove and return an `ADVANCED` or `OBSERVED` tx waiting to be `SETTLED`.
+       * Remove and return the oldest pending settlement transaction that matches the given
+       * forwarding account and amount. Since multiple pending transactions may exist with
+       * identical (account, amount) pairs, we process them in FIFO order.
        *
        * @param {NobleAddress} nfa
        * @param {bigint} amount
-       * @returns {Pick<PendingTx, 'status' | 'txHash'> | undefined} undefined if nothing
-       *   with this address and amount has been marked pending.
+       * @returns {Pick<PendingTx, 'status' | 'txHash'> | undefined} undefined if no pending
+       *   transactions exist for this address and amount combination.
        */
       dequeueStatus(nfa, amount) {
         const key = makePendingTxKey(nfa, amount);
-        if (!pendingTxs.has(key)) return undefined;
-        const pending = pendingTxs.get(key);
+        if (!pendingSettleTxs.has(key)) return undefined;
+        const pending = pendingSettleTxs.get(key);
 
-        const dequeueIdx = pending.findIndex(
-          x => x.status !== PendingTxStatus.Advancing,
-        );
-        if (dequeueIdx < 0) return undefined;
+        if (pending.length === 0) {
+          return undefined;
+        }
+        // extract first item
+        const [{ status, txHash }, ...remaining] = pending;
 
-        if (pending.length > 1) {
-          const pendingCopy = [...pending];
-          pendingCopy.splice(dequeueIdx, 1);
-          pendingTxs.set(key, harden(pendingCopy));
+        if (remaining.length) {
+          pendingSettleTxs.set(key, harden(remaining));
         } else {
-          pendingTxs.delete(key);
+          pendingSettleTxs.delete(key);
         }
 
-        const { status, txHash } = pending[dequeueIdx];
-        // TODO: store txHash -> evidence for txs pending settlement?
-        // If necessary for vstorage writes in `forwarded` and `settled`
         return harden({ status, txHash });
       },
 
@@ -348,21 +388,18 @@ export const prepareStatusManager = (
       },
 
       /**
-       * Mark a transaction as `FORWARDED`
+       * Mark a transaction as `FORWARDED` or `FORWARD_FAILED`
        *
-       * @param {EvmHash | undefined} txHash - undefined in case mint before observed
-       * @param {NobleAddress} nfa
-       * @param {bigint} amount
+       * @param {EvmHash} txHash
+       * @param {boolean} success
        */
-      forwarded(txHash, nfa, amount) {
-        if (txHash) {
-          void publishTxnRecord(txHash, harden({ status: TxStatus.Forwarded }));
-        } else {
-          // TODO store (early) `Minted` transactions to check against incoming evidence
-          log(
-            `⚠️ Forwarded minted amount ${amount} from account ${nfa} before it was observed.`,
-          );
-        }
+      forwarded(txHash, success) {
+        void publishTxnRecord(
+          txHash,
+          harden({
+            status: success ? TxStatus.Forwarded : TxStatus.ForwardFailed,
+          }),
+        );
       },
 
       /**
@@ -376,12 +413,13 @@ export const prepareStatusManager = (
        */
       lookupPending(nfa, amount) {
         const key = makePendingTxKey(nfa, amount);
-        if (!pendingTxs.has(key)) {
+        if (!pendingSettleTxs.has(key)) {
           return harden([]);
         }
-        return pendingTxs.get(key);
+        return pendingSettleTxs.get(key);
       },
     },
+    { stateShape },
   );
 };
 harden(prepareStatusManager);