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

package/src/exos/liquidity-pool.js

@@ -1,15 +1,13 @@
-import { AmountMath, AmountShape, RatioShape } from '@agoric/ertp';
+import { AmountMath } from '@agoric/ertp';
 import {
   makeRecorderTopic,
-  RecorderKitShape,
   TopicsRecordShape,
-} from '@agoric/zoe/src/contractSupport/index.js';
+} from '@agoric/zoe/src/contractSupport/topics.js';
 import { SeatShape } from '@agoric/zoe/src/typeGuards.js';
 import { M } from '@endo/patterns';
 import { Fail, q } from '@endo/errors';
 import {
   borrowCalc,
-  checkPoolBalance,
   depositCalc,
   makeParity,
   repayCalc,
@@ -22,7 +20,6 @@ import {
 } from '../type-guards.js';
 
 /**
- * @import {Amount, Brand, Payment} from '@agoric/ertp';
  * @import {Zone} from '@agoric/zone';
  * @import {Remote} from '@agoric/internal'
  * @import {StorageNode} from '@agoric/internal/src/lib-chainStorage.js'
@@ -31,7 +28,32 @@ import {
  * @import {PoolStats} from '../types.js';
  */
 
-const { add, isGTE, makeEmpty } = AmountMath;
+const { add, isEqual, isGTE, makeEmpty } = AmountMath;
+
+/** @param {Brand} brand */
+const makeDust = brand => AmountMath.make(brand, 1n);
+
+/**
+ * Verifies that the total pool balance (unencumbered + encumbered) matches the
+ * shareWorth numerator. The total pool balance consists of:
+ * 1. unencumbered balance - USDC available in the pool for borrowing
+ * 2. encumbered balance - USDC currently lent out
+ *
+ * A negligible `dust` amount is used to initialize shareWorth with a non-zero
+ * denominator. It must remain in the pool at all times.
+ *
+ * @param {ZCFSeat} poolSeat
+ * @param {ShareWorth} shareWorth
+ * @param {Brand} USDC
+ * @param {Amount<'nat'>} encumberedBalance
+ */
+const checkPoolBalance = (poolSeat, shareWorth, USDC, encumberedBalance) => {
+  const unencumberedBalance = poolSeat.getAmountAllocated('USDC', USDC);
+  const dust = makeDust(USDC);
+  const grossBalance = add(add(unencumberedBalance, dust), encumberedBalance);
+  isEqual(grossBalance, shareWorth.numerator) ||
+    Fail`🚨 pool balance ${q(unencumberedBalance)} and encumbered balance ${q(encumberedBalance)} inconsistent with shareWorth ${q(shareWorth)}`;
+};
 
 /**
  * @typedef {{
@@ -49,22 +71,6 @@ const { add, isGTE, makeEmpty } = AmountMath;
  * }} RepayPaymentKWR
  */
 
-export const stateShape = harden({
-  encumberedBalance: AmountShape,
-  feeSeat: M.remotable(),
-  poolStats: M.record(),
-  poolMetricsRecorderKit: RecorderKitShape,
-  poolSeat: M.remotable(),
-  PoolShares: M.remotable(),
-  proposalShapes: {
-    deposit: M.pattern(),
-    withdraw: M.pattern(),
-    withdrawFees: M.pattern(),
-  },
-  shareMint: M.remotable(),
-  shareWorth: RatioShape,
-});
-
 /**
  * @param {Zone} zone
  * @param {ZCF} zcf
@@ -100,18 +106,11 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
       withdrawHandler: M.interface('withdrawHandler', {
         handle: M.call(SeatShape, M.any()).returns(M.promise()),
       }),
-      withdrawFeesHandler: M.interface('withdrawFeesHandler', {
-        handle: M.call(SeatShape, M.any()).returns(M.promise()),
-      }),
       public: M.interface('public', {
         makeDepositInvitation: M.call().returns(M.promise()),
         makeWithdrawInvitation: M.call().returns(M.promise()),
         getPublicTopics: M.call().returns(TopicsRecordShape),
       }),
-      feeRecipient: M.interface('feeRecipient', {
-        getContractFeeBalance: M.call().returns(AmountShape),
-        makeWithdrawFeesInvitation: M.call().returns(M.promise()),
-      }),
     },
     /**
      * @param {ZCFMint<'nat'>} shareMint
@@ -120,7 +119,7 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
     (shareMint, node) => {
       const { brand: PoolShares } = shareMint.getIssuerRecord();
       const proposalShapes = makeProposalShapes({ USDC, PoolShares });
-      const shareWorth = makeParity(USDC, PoolShares);
+      const shareWorth = makeParity(makeDust(USDC), PoolShares);
       const { zcfSeat: poolSeat } = zcf.makeEmptySeatKit();
       const { zcfSeat: feeSeat } = zcf.makeEmptySeatKit();
       const poolMetricsRecorderKit = tools.makeRecorderKit(
@@ -192,9 +191,7 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
           zcf.atomicRearrange(
             harden([[borrowSeat, repaySeat, { USDC: amount }, returnAmounts]]),
           );
-          this.facets.repayer.repay(repaySeat, returnAmounts);
-          borrowSeat.exit();
-          repaySeat.exit();
+          return this.facets.repayer.repay(repaySeat, returnAmounts);
         },
       },
       repayer: {
@@ -210,11 +207,7 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
             poolStats,
             shareWorth,
           } = this.state;
-          checkPoolBalance(
-            poolSeat.getCurrentAllocation(),
-            shareWorth,
-            encumberedBalance,
-          );
+          checkPoolBalance(poolSeat, shareWorth, USDC, encumberedBalance);
 
           const fromSeatAllocation = fromSeat.getCurrentAllocation();
           // Validate allocation equals amounts and Principal <= encumberedBalance
@@ -271,11 +264,7 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
           /** @type {USDCProposalShapes['deposit']} */
           // @ts-expect-error ensured by proposalShape
           const proposal = lp.getProposal();
-          checkPoolBalance(
-            poolSeat.getCurrentAllocation(),
-            shareWorth,
-            encumberedBalance,
-          );
+          checkPoolBalance(poolSeat, shareWorth, USDC, encumberedBalance);
           const post = depositCalc(shareWorth, proposal);
 
           // COMMIT POINT
@@ -311,12 +300,8 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
           // @ts-expect-error ensured by proposalShape
           const proposal = lp.getProposal();
           const { zcfSeat: burn } = zcf.makeEmptySeatKit();
-          const post = withdrawCalc(
-            shareWorth,
-            proposal,
-            poolSeat.getCurrentAllocation(),
-            encumberedBalance,
-          );
+          checkPoolBalance(poolSeat, shareWorth, USDC, encumberedBalance);
+          const post = withdrawCalc(shareWorth, proposal);
 
           // COMMIT POINT
           try {
@@ -340,21 +325,6 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
           external.publishPoolMetrics();
         },
       },
-      withdrawFeesHandler: {
-        /** @param {ZCFSeat} seat */
-        async handle(seat) {
-          const { feeSeat } = this.state;
-
-          const { want } = seat.getProposal();
-          const available = feeSeat.getAmountAllocated('USDC', want.USDC.brand);
-          isGTE(available, want.USDC) ||
-            Fail`cannot withdraw ${want.USDC}; only ${available} available`;
-
-          // COMMIT POINT
-          zcf.atomicRearrange(harden([[feeSeat, seat, want]]));
-          seat.exit();
-        },
-      },
       public: {
         makeDepositInvitation() {
           return zcf.makeInvitation(
@@ -382,28 +352,11 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
           };
         },
       },
-      feeRecipient: {
-        getContractFeeBalance() {
-          const { feeSeat } = this.state;
-          /** @type {Amount<'nat'>} */
-          const balance = feeSeat.getCurrentAllocation().USDC;
-          return balance;
-        },
-        makeWithdrawFeesInvitation() {
-          return zcf.makeInvitation(
-            this.facets.withdrawFeesHandler,
-            'Withdraw Fees',
-            undefined,
-            this.state.proposalShapes.withdrawFees,
-          );
-        },
-      },
     },
     {
       finish: ({ facets: { external } }) => {
         void external.publishPoolMetrics();
       },
-      stateShape,
     },
   );
 };

package/src/exos/operator-kit.js

@@ -90,6 +90,8 @@ export const prepareOperatorKit = (zone, staticPowers) =>
          */
         async SubmitEvidence(evidence, riskAssessment) {
           const { operator } = this.facets;
+          // TODO(bootstrap integration): cause this call to throw and confirm that it
+          // shows up in the the smart-wallet UpdateRecord `error` property
           operator.submitEvidence(evidence, riskAssessment);
           return staticPowers.makeInertInvitation(
             'evidence was pushed in the invitation maker call',

package/src/exos/settler.js

@@ -8,72 +8,20 @@ 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 {
-  CctpTxEvidenceShape,
-  EvmHashShape,
-  makeNatAmountShape,
-} from '../type-guards.js';
+import { EvmHashShape } 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, IBCPacket, VTransferIBCEvent} from '@agoric/vats';
+ * @import {IBCChannelID, 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, CctpTxEvidence} from '../types.js';
+ * @import {NobleAddress, LiquidityPoolKit, FeeConfig, EvmHash, LogFn} 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.
  *
@@ -83,25 +31,6 @@ harden(decodeEventPacket);
 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
@@ -138,23 +67,26 @@ export const prepareSettler = (
       tap: M.interface('SettlerTapI', {
         receiveUpcall: M.call(M.record()).returns(M.promise()),
       }),
-      notifier: M.interface('SettlerNotifyI', {
+      notify: M.interface('SettlerNotifyI', {
         notifyAdvancingResult: M.call(
-          makeAdvanceDetailsShape(USDC),
+          M.record(), // XXX fill in details TODO
           M.boolean(),
         ).returns(),
-        checkMintedEarly: M.call(
-          CctpTxEvidenceShape,
-          ChainAddressShape,
-        ).returns(M.boolean()),
       }),
       self: M.interface('SettlerSelfI', {
-        disburse: M.call(EvmHashShape, M.nat()).returns(M.promise()),
-        forward: M.call(EvmHashShape, M.nat(), M.string()).returns(),
+        disburse: M.call(EvmHashShape, M.string(), M.nat()).returns(
+          M.promise(),
+        ),
+        forward: M.call(
+          M.opt(EvmHashShape),
+          M.string(),
+          M.nat(),
+          M.string(),
+        ).returns(),
       }),
       transferHandler: M.interface('SettlerTransferI', {
-        onFulfilled: M.call(M.undefined(), M.string()).returns(),
-        onRejected: M.call(M.error(), M.string()).returns(),
+        onFulfilled: M.call(M.any(), M.record()).returns(),
+        onRejected: M.call(M.any(), M.record()).returns(),
       }),
     },
     /**
@@ -205,40 +137,61 @@ export const prepareSettler = (
             return;
           }
 
-          const decoded = decodeEventPacket(event.packet, remoteDenom);
-          if ('error' in decoded) {
-            log('invalid event packet', decoded.error);
+          // 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);
             return;
           }
 
-          const { nfa, amount, EUD } = decoded;
+          const amount = BigInt(tx.amount); // TODO: what if this throws?
+
           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, amount);
+              return self.disburse(found.txHash, nfa, 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, amount, EUD);
+              return self.forward(found.txHash, nfa, amount, EUD);
 
             case undefined:
             default:
-              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));
+              log('⚠️ tap: no status for ', nfa, amount);
           }
         },
       },
-      notifier: {
+      notify: {
         /**
          * @param {object} ctx
          * @param {EvmHash} ctx.txHash
@@ -257,12 +210,16 @@ 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, fullValue);
+              void this.facets.self.disburse(
+                txHash,
+                forwardingAddress,
+                fullValue,
+              );
             } else {
               void this.facets.self.forward(
                 txHash,
+                forwardingAddress,
                 fullValue,
                 destination.value,
               );
@@ -271,39 +228,14 @@ 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, fullValue) {
+        async disburse(txHash, nfa, fullValue) {
           const { repayer, settlementAccount } = this.state;
           const received = AmountMath.make(USDC, fullValue);
           const { zcfSeat: settlingSeat } = zcf.makeEmptySeatKit();
@@ -327,67 +259,76 @@ export const prepareSettler = (
             harden([[settlingSeat, settlingSeat, { In: received }, split]]),
           );
           repayer.repay(settlingSeat, split);
-          settlingSeat.exit();
 
-          // update status manager, marking tx `DISBURSED`
+          // update status manager, marking tx `SETTLED`
           statusManager.disbursed(txHash, split);
         },
         /**
          * @param {EvmHash} txHash
+         * @param {NobleAddress} nfa
          * @param {NatValue} fullValue
          * @param {string} EUD
          */
-        forward(txHash, fullValue, EUD) {
+        forward(txHash, nfa, fullValue, EUD) {
           const { settlementAccount, intermediateRecipient } = this.state;
 
-          const dest = (() => {
-            try {
-              return chainHub.makeChainAddress(EUD);
-            } catch (e) {
-              log('⚠️ forward transfer failed!', e, txHash);
-              statusManager.forwarded(txHash, false);
-              return null;
-            }
-          })();
-          if (!dest) return;
+          const dest = chainHub.makeChainAddress(EUD);
 
+          // 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);
+          void vowTools.watch(txfrV, this.facets.transferHandler, {
+            txHash,
+            nfa,
+            fullValue,
+          });
         },
       },
       transferHandler: {
         /**
          * @param {unknown} _result
-         * @param {EvmHash} txHash
+         * @param {SettlerTransferCtx} ctx
+         *
+         * @typedef {{
+         *   txHash: EvmHash;
+         *   nfa: NobleAddress;
+         *   fullValue: NatValue;
+         * }} SettlerTransferCtx
          */
-        onFulfilled(_result, txHash) {
-          // update status manager, marking tx `FORWARDED` without fee split
-          statusManager.forwarded(txHash, true);
+        onFulfilled(_result, ctx) {
+          const { txHash, nfa, fullValue } = ctx;
+          statusManager.forwarded(txHash, nfa, fullValue);
         },
         /**
          * @param {unknown} reason
-         * @param {EvmHash} txHash
+         * @param {SettlerTransferCtx} ctx
          */
-        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);
+        onRejected(reason, ctx) {
+          log('⚠️ transfer rejected!', reason, ctx);
+          // const { txHash, nfa, amount } = ctx;
+          // TODO(#10510): statusManager.forwardFailed(txHash, nfa, amount);
         },
       },
     },
     {
-      stateShape,
+      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),
+      }),
     },
   );
 };
 harden(prepareSettler);
 
-// Expose the whole kit because the contract needs `creatorFacet` and the Advancer needs `notifier`
-/** @typedef {ReturnType<ReturnType<typeof prepareSettler>>} SettlerKit */
+/**
+ * XXX consider using pickFacet (do we have pickFacets?)
+ * @typedef {ReturnType<ReturnType<typeof prepareSettler>>} SettlerKit
+ */