@agoric/fast-usdc 0.2.0-upgrade-19-dev-0754752.0 → 0.2.0-upgrade-18a-dev-4ee0508.0

package/src/exos/status-manager.js

@@ -53,12 +53,6 @@ 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`
@@ -75,15 +69,14 @@ export const prepareStatusManager = (
   txnsNode,
   {
     marshaller,
-    // eslint-disable-next-line no-unused-vars
-    log = makeTracer('StatusManager', true),
+    log = makeTracer('Advancer', true),
   } = /** @type {StatusManagerPowers} */ ({}),
 ) => {
   /**
    * Keyed by a tuple of the Noble Forwarding Account and amount.
    * @type {MapStore<PendingTxKey, PendingTx[]>}
    */
-  const pendingSettleTxs = zone.mapStore('PendingSettleTxs', {
+  const pendingTxs = zone.mapStore('PendingTxs', {
     keyShape: M.string(),
     valueShape: M.arrayOf(PendingTxShape),
   });
@@ -91,18 +84,13 @@ export const prepareStatusManager = (
   /**
    * Transactions seen *ever* by the contract.
    *
-   * 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>}
+   * 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>}
    */
-  const seenTxs = zone.mapStore('SeenTxs', {
+  const seenTxs = zone.setStore('SeenTxs', {
     keyShape: M.string(),
-    valueShape: M.nat(),
   });
 
   /**
@@ -165,10 +153,10 @@ export const prepareStatusManager = (
     if (seenTxs.has(txHash)) {
       throw makeError(`Transaction already seen: ${q(txHash)}`);
     }
-    seenTxs.init(txHash, evidence.blockTimestamp);
+    seenTxs.add(txHash);
 
     appendToStoredArray(
-      pendingSettleTxs,
+      pendingTxs,
       pendingTxKeyOf(evidence),
       harden({ ...evidence, status }),
     );
@@ -189,8 +177,8 @@ export const prepareStatusManager = (
    */
   function setPendingTxStatus({ nfa, amount }, status) {
     const key = makePendingTxKey(nfa, amount);
-    pendingSettleTxs.has(key) || Fail`no advancing tx with ${{ nfa, amount }}`;
-    const pending = pendingSettleTxs.get(key);
+    pendingTxs.has(key) || Fail`no advancing tx with ${{ nfa, amount }}`;
+    const pending = pendingTxs.get(key);
     const ix = pending.findIndex(tx => tx.status === PendingTxStatus.Advancing);
     ix >= 0 || Fail`no advancing tx with ${{ nfa, amount }}`;
     const [prefix, tx, suffix] = [
@@ -199,7 +187,7 @@ export const prepareStatusManager = (
       pending.slice(ix + 1),
     ];
     const txpost = { ...tx, status };
-    pendingSettleTxs.set(key, harden([...prefix, txpost, ...suffix]));
+    pendingTxs.set(key, harden([...prefix, txpost, ...suffix]));
     void publishTxnRecord(tx.txHash, harden({ status }));
   }
 
@@ -207,19 +195,24 @@ export const prepareStatusManager = (
     'Fast USDC Status Manager',
     M.interface('StatusManagerI', {
       // TODO: naming scheme for transition events
-      advance: M.call(CctpTxEvidenceShape).returns(),
+      advance: M.call(CctpTxEvidenceShape).returns(M.undefined()),
       advanceOutcome: M.call(M.string(), M.nat(), M.boolean()).returns(),
-      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(),
+      skipAdvance: M.call(CctpTxEvidenceShape, M.arrayOf(M.string())).returns(
+        M.undefined(),
+      ),
+      observe: M.call(CctpTxEvidenceShape).returns(M.undefined()),
       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(...Object.values(PendingTxStatus)),
+            status: M.or(
+              PendingTxStatus.Advanced,
+              PendingTxStatus.AdvanceSkipped,
+              PendingTxStatus.AdvanceFailed,
+              PendingTxStatus.Observed,
+            ),
           },
           M.undefined(),
         ),
@@ -227,7 +220,9 @@ export const prepareStatusManager = (
       disbursed: M.call(EvmHashShape, AmountKeywordRecordShape).returns(
         M.undefined(),
       ),
-      forwarded: M.call(EvmHashShape, M.boolean()).returns(),
+      forwarded: M.call(M.opt(EvmHashShape), M.string(), M.nat()).returns(
+        M.undefined(),
+      ),
       lookupPending: M.call(M.string(), M.bigint()).returns(
         M.arrayOf(PendingTxShape),
       ),
@@ -263,7 +258,7 @@ export const prepareStatusManager = (
       },
 
       /**
-       * Record result of an ADVANCING transaction
+       * Record result of ADVANCING
        *
        * @param {NobleAddress} nfa Noble Forwarding Account
        * @param {import('@agoric/ertp').NatValue} amount
@@ -277,43 +272,6 @@ 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
@@ -345,32 +303,34 @@ export const prepareStatusManager = (
       },
 
       /**
-       * 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.
+       * Remove and return an `ADVANCED` or `OBSERVED` tx waiting to be `SETTLED`.
        *
        * @param {NobleAddress} nfa
        * @param {bigint} amount
-       * @returns {Pick<PendingTx, 'status' | 'txHash'> | undefined} undefined if no pending
-       *   transactions exist for this address and amount combination.
+       * @returns {Pick<PendingTx, 'status' | 'txHash'> | undefined} undefined if nothing
+       *   with this address and amount has been marked pending.
        */
       dequeueStatus(nfa, amount) {
         const key = makePendingTxKey(nfa, amount);
-        if (!pendingSettleTxs.has(key)) return undefined;
-        const pending = pendingSettleTxs.get(key);
+        if (!pendingTxs.has(key)) return undefined;
+        const pending = pendingTxs.get(key);
 
-        if (pending.length === 0) {
-          return undefined;
-        }
-        // extract first item
-        const [{ status, txHash }, ...remaining] = pending;
+        const dequeueIdx = pending.findIndex(
+          x => x.status !== PendingTxStatus.Advancing,
+        );
+        if (dequeueIdx < 0) return undefined;
 
-        if (remaining.length) {
-          pendingSettleTxs.set(key, harden(remaining));
+        if (pending.length > 1) {
+          const pendingCopy = [...pending];
+          pendingCopy.splice(dequeueIdx, 1);
+          pendingTxs.set(key, harden(pendingCopy));
         } else {
-          pendingSettleTxs.delete(key);
+          pendingTxs.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 });
       },
 
@@ -388,18 +348,21 @@ export const prepareStatusManager = (
       },
 
       /**
-       * Mark a transaction as `FORWARDED` or `FORWARD_FAILED`
+       * Mark a transaction as `FORWARDED`
        *
-       * @param {EvmHash} txHash
-       * @param {boolean} success
+       * @param {EvmHash | undefined} txHash - undefined in case mint before observed
+       * @param {NobleAddress} nfa
+       * @param {bigint} amount
        */
-      forwarded(txHash, success) {
-        void publishTxnRecord(
-          txHash,
-          harden({
-            status: success ? TxStatus.Forwarded : TxStatus.ForwardFailed,
-          }),
-        );
+      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.`,
+          );
+        }
       },
 
       /**
@@ -413,13 +376,12 @@ export const prepareStatusManager = (
        */
       lookupPending(nfa, amount) {
         const key = makePendingTxKey(nfa, amount);
-        if (!pendingSettleTxs.has(key)) {
+        if (!pendingTxs.has(key)) {
           return harden([]);
         }
-        return pendingSettleTxs.get(key);
+        return pendingTxs.get(key);
       },
     },
-    { stateShape },
   );
 };
 harden(prepareStatusManager);

package/src/exos/transaction-feed.js

@@ -1,7 +1,7 @@
 import { makeTracer } from '@agoric/internal';
 import { prepareDurablePublishKit } from '@agoric/notifier';
 import { keyEQ, M } from '@endo/patterns';
-import { Fail, quote } from '@endo/errors';
+import { Fail } from '@endo/errors';
 import { CctpTxEvidenceShape, RiskAssessmentShape } from '../type-guards.js';
 import { defineInertInvitation } from '../utils/zoe.js';
 import { prepareOperatorKit } from './operator-kit.js';
@@ -15,10 +15,6 @@ import { prepareOperatorKit } from './operator-kit.js';
 
 const trace = makeTracer('TxFeed', true);
 
-/**
- * @typedef {Pick<OperatorKit, 'invitationMakers' | 'operator'>} OperatorOfferResult
- */
-
 /** Name in the invitation purse (keyed also by this contract instance) */
 export const INVITATION_MAKERS_DESC = 'oracle operator invitation';
 
@@ -31,10 +27,8 @@ const TransactionFeedKitI = harden({
     ).returns(),
   }),
   creator: M.interface('Transaction Feed Creator', {
-    initOperator: M.call(M.string()).returns({
-      invitationMakers: M.remotable(),
-      operator: M.remotable(),
-    }),
+    // TODO narrow the return shape to OperatorKit
+    initOperator: M.call(M.string()).returns(M.record()),
     makeOperatorInvitation: M.call(M.string()).returns(M.promise()),
     removeOperator: M.call(M.string()).returns(),
   }),
@@ -59,12 +53,6 @@ const allRisksIdentified = (riskStores, txHash) => {
   return [...setOfRisks.values()].sort();
 };
 
-export const stateShape = {
-  operators: M.remotable(),
-  pending: M.remotable(),
-  risks: M.remotable(),
-};
-
 /**
  * @param {Zone} zone
  * @param {ZCF} zcf
@@ -104,14 +92,14 @@ export const prepareTransactionFeedKit = (zone, zcf) => {
          * CCTP transactions.
          *
          * @param {string} operatorId unique per contract instance
-         * @returns {Promise<Invitation<OperatorOfferResult>>}
+         * @returns {Promise<Invitation<OperatorKit>>}
          */
         makeOperatorInvitation(operatorId) {
           const { creator } = this.facets;
           trace('makeOperatorInvitation', operatorId);
 
           return zcf.makeInvitation(
-            /** @type {OfferHandler<OperatorOfferResult>} */
+            /** @type {OfferHandler<OperatorKit>} */
             seat => {
               seat.exit();
               return creator.initOperator(operatorId);
@@ -119,10 +107,7 @@ export const prepareTransactionFeedKit = (zone, zcf) => {
             INVITATION_MAKERS_DESC,
           );
         },
-        /**
-         * @param {string} operatorId
-         * @returns {OperatorOfferResult}
-         */
+        /** @param {string} operatorId */
         initOperator(operatorId) {
           const { operators, pending, risks } = this.state;
           trace('initOperator', operatorId);
@@ -138,16 +123,11 @@ export const prepareTransactionFeedKit = (zone, zcf) => {
           );
           risks.init(operatorId, zone.detached().mapStore('risk assessments'));
 
-          // Subset facets to all the off-chain operator needs
-          const { invitationMakers, operator } = operatorKit;
-          return {
-            invitationMakers,
-            operator,
-          };
+          return operatorKit;
         },
 
         /** @param {string} operatorId */
-        removeOperator(operatorId) {
+        async removeOperator(operatorId) {
           const { operators } = this.state;
           trace('removeOperator', operatorId);
           const operatorKit = operators.get(operatorId);
@@ -221,7 +201,7 @@ export const prepareTransactionFeedKit = (zone, zcf) => {
                   '!=',
                   next,
                 );
-                Fail`conflicting evidence for ${quote(txHash)}`;
+                Fail`conflicting evidence for ${txHash}`;
               }
             }
             lastEvidence = next;
@@ -251,7 +231,6 @@ export const prepareTransactionFeedKit = (zone, zcf) => {
         getEvidenceSubscriber: () => subscriber,
       },
     },
-    { stateShape },
   );
 };
 harden(prepareTransactionFeedKit);

package/src/fast-usdc-policy.core.js

@@ -3,10 +3,8 @@
 import { E } from '@endo/far';
 import { fromExternalConfig } from './utils/config-marshal.js';
 import { FeedPolicyShape } from './type-guards.js';
-import { publishFeedPolicy } from './utils/core-eval.js';
 
 /**
- * @import {Issuer} from '@agoric/ertp';
  * @import {Passable} from '@endo/pass-style'
  * @import {BootstrapManifest} from '@agoric/vats/src/core/lib-boot.js'
  * @import {LegibleCapData} from './utils/config-marshal.js'
@@ -14,6 +12,18 @@ import { publishFeedPolicy } from './utils/core-eval.js';
  */
 
 const contractName = 'fastUsdc';
+const FEED_POLICY = 'feedPolicy';
+
+/**
+ * XXX copied from fast-usdc.start.js
+ *
+ * @param {ERef<StorageNode>} node
+ * @param {FeedPolicy} policy
+ */
+const publishFeedPolicy = async (node, policy) => {
+  const feedPolicy = E(node).makeChildNode(FEED_POLICY);
+  await E(feedPolicy).setValue(JSON.stringify(policy));
+};
 
 /**
  * @param {BootstrapPowers &

package/src/fast-usdc.contract.js

@@ -22,6 +22,7 @@ import { prepareStatusManager } from './exos/status-manager.js';
 import { prepareTransactionFeedKit } from './exos/transaction-feed.js';
 import * as flows from './fast-usdc.flows.js';
 import { FastUSDCTermsShape, FeeConfigShape } from './type-guards.js';
+import { defineInertInvitation } from './utils/zoe.js';
 
 const trace = makeTracer('FastUsdc');
 
@@ -36,9 +37,8 @@ const ADDRESSES_BAGGAGE_KEY = 'addresses';
  * @import {Remote} from '@agoric/internal';
  * @import {Marshaller, StorageNode} from '@agoric/internal/src/lib-chainStorage.js'
  * @import {Zone} from '@agoric/zone';
- * @import {OperatorOfferResult} from './exos/transaction-feed.js';
  * @import {OperatorKit} from './exos/operator-kit.js';
- * @import {CctpTxEvidence, ContractRecord, FeeConfig} from './types.js';
+ * @import {CctpTxEvidence, FeeConfig, RiskAssessment} from './types.js';
  */
 
 /**
@@ -76,7 +76,10 @@ const publishFeeConfig = async (node, marshaller, feeConfig) => {
 
 /**
  * @param {Remote<StorageNode>} contractNode
- * @param {ContractRecord} addresses
+ * @param {{
+ *  poolAccount: ChainAddress['value'];
+ *  settlementAccount: ChainAddress['value'];
+ * }} addresses
  */
 const publishAddresses = (contractNode, addresses) => {
   return E(contractNode).setValue(JSON.stringify(addresses));
@@ -90,7 +93,6 @@ const publishAddresses = (contractNode, addresses) => {
  *   feeConfig: FeeConfig;
  *   marshaller: Marshaller;
  *   poolMetricsNode: Remote<StorageNode>;
- *   storageNode: Remote<StorageNode>;
  * }} privateArgs
  * @param {Zone} zone
  * @param {OrchestrationTools} tools
@@ -126,10 +128,11 @@ export const contract = async (zcf, privateArgs, zone, tools) => {
     chainHub,
   });
 
-  const zoeTools = makeZoeTools(zcf, vowTools);
+  const { localTransfer } = makeZoeTools(zcf, vowTools);
   const makeAdvancer = prepareAdvancer(zone, {
     chainHub,
     feeConfig,
+    localTransfer,
     usdc: harden({
       brand: terms.brands.USDC,
       denom: terms.usdcDenom,
@@ -137,7 +140,6 @@ export const contract = async (zcf, privateArgs, zone, tools) => {
     statusManager,
     vowTools,
     zcf,
-    zoeTools,
   });
 
   const makeFeedKit = prepareTransactionFeedKit(zone, zcf);
@@ -149,24 +151,18 @@ export const contract = async (zcf, privateArgs, zone, tools) => {
     { makeRecorderKit },
   );
 
+  const makeTestInvitation = defineInertInvitation(
+    zcf,
+    'test of forcing evidence',
+  );
+
   const { makeLocalAccount, makeNobleAccount } = orchestrateAll(flows, {});
 
   const creatorFacet = zone.exo('Fast USDC Creator', undefined, {
-    /** @type {(operatorId: string) => Promise<Invitation<OperatorOfferResult>>} */
+    /** @type {(operatorId: string) => Promise<Invitation<OperatorKit>>} */
     async makeOperatorInvitation(operatorId) {
       return feedKit.creator.makeOperatorInvitation(operatorId);
     },
-    /** @type {(operatorId: string) => void} */
-    removeOperator(operatorId) {
-      return feedKit.creator.removeOperator(operatorId);
-    },
-    async getContractFeeBalance() {
-      return poolKit.feeRecipient.getContractFeeBalance();
-    },
-    /** @type {() => Promise<Invitation<unknown>>} */
-    async makeWithdrawFeesInvitation() {
-      return poolKit.feeRecipient.makeWithdrawFeesInvitation();
-    },
     async connectToNoble() {
       return vowTools.when(nobleAccountV, nobleAccount => {
         trace('nobleAccount', nobleAccount);
@@ -194,12 +190,24 @@ export const contract = async (zcf, privateArgs, zone, tools) => {
       await publishAddresses(storageNode, addresses);
       return addresses;
     },
-    deleteCompletedTxs() {
-      return statusManager.deleteCompletedTxs();
-    },
   });
 
   const publicFacet = zone.exo('Fast USDC Public', undefined, {
+    // XXX to be removed before production
+    /**
+     * NB: Any caller with access to this invitation maker has the ability to
+     * force handling of evidence.
+     *
+     * Provide an API call in the form of an invitation maker, so that the
+     * capability is available in the smart-wallet bridge during UI testing.
+     *
+     * @param {CctpTxEvidence} evidence
+     * @param {RiskAssessment} [risk]
+     */
+    makeTestPushInvitation(evidence, risk = {}) {
+      void advancer.handleTransactionEvent({ evidence, risk });
+      return makeTestInvitation();
+    },
     makeDepositInvitation() {
       return poolKit.public.makeDepositInvitation();
     },
@@ -288,8 +296,8 @@ export const contract = async (zcf, privateArgs, zone, tools) => {
 
   const advancer = zone.makeOnce('Advancer', () =>
     makeAdvancer({
-      borrower: poolKit.borrower,
-      notifier: settlerKit.notifier,
+      borrowerFacet: poolKit.borrower,
+      notifyFacet: settlerKit.notify,
       poolAccount,
       settlementAddress,
     }),