@agoric/fast-usdc 0.1.1-other-dev-3eb1a1d.0 → 0.1.1-other-dev-d15096d.0.d15096d

package/src/exos/advancer.js

@@ -1,255 +0,0 @@
-import { AmountMath, AmountShape } from '@agoric/ertp';
-import { assertAllDefined, makeTracer } from '@agoric/internal';
-import { ChainAddressShape } from '@agoric/orchestration';
-import { pickFacet } from '@agoric/vat-data';
-import { VowShape } from '@agoric/vow';
-import { q } from '@endo/errors';
-import { E } from '@endo/far';
-import { M } from '@endo/patterns';
-import { CctpTxEvidenceShape, EudParamShape } from '../type-guards.js';
-import { addressTools } from '../utils/address.js';
-import { makeFeeTools } from '../utils/fees.js';
-
-const { isGTE } = AmountMath;
-
-/**
- * @import {HostInterface} from '@agoric/async-flow';
- * @import {NatAmount} from '@agoric/ertp';
- * @import {ChainAddress, ChainHub, Denom, OrchestrationAccount} from '@agoric/orchestration';
- * @import {ZoeTools} from '@agoric/orchestration/src/utils/zoe-tools.js';
- * @import {VowTools} from '@agoric/vow';
- * @import {Zone} from '@agoric/zone';
- * @import {CctpTxEvidence, FeeConfig, LogFn} from '../types.js';
- * @import {StatusManager} from './status-manager.js';
- * @import {LiquidityPoolKit} from './liquidity-pool.js';
- */
-
-/**
- * @typedef {{
- *  chainHub: ChainHub;
- *  feeConfig: FeeConfig;
- *  localTransfer: ZoeTools['localTransfer'];
- *  log?: LogFn;
- *  statusManager: StatusManager;
- *  usdc: { brand: Brand<'nat'>; denom: Denom; };
- *  vowTools: VowTools;
- *  zcf: ZCF;
- * }} AdvancerKitPowers
- */
-
-/** type guards internal to the AdvancerKit */
-const AdvancerKitI = harden({
-  advancer: M.interface('AdvancerI', {
-    handleTransactionEvent: M.callWhen(CctpTxEvidenceShape).returns(),
-  }),
-  depositHandler: M.interface('DepositHandlerI', {
-    onFulfilled: M.call(M.undefined(), {
-      amount: AmountShape,
-      destination: ChainAddressShape,
-      tmpSeat: M.remotable(),
-    }).returns(VowShape),
-    onRejected: M.call(M.error(), {
-      amount: AmountShape,
-      destination: ChainAddressShape,
-      tmpSeat: M.remotable(),
-    }).returns(),
-  }),
-  transferHandler: M.interface('TransferHandlerI', {
-    // TODO confirm undefined, and not bigint (sequence)
-    onFulfilled: M.call(M.undefined(), {
-      amount: AmountShape,
-      destination: ChainAddressShape,
-    }).returns(M.undefined()),
-    onRejected: M.call(M.error(), {
-      amount: AmountShape,
-      destination: ChainAddressShape,
-    }).returns(M.undefined()),
-  }),
-});
-
-/**
- * @param {Zone} zone
- * @param {AdvancerKitPowers} caps
- */
-export const prepareAdvancerKit = (
-  zone,
-  {
-    chainHub,
-    feeConfig,
-    localTransfer,
-    log = makeTracer('Advancer', true),
-    statusManager,
-    usdc,
-    vowTools: { watch, when },
-    zcf,
-  } = /** @type {AdvancerKitPowers} */ ({}),
-) => {
-  assertAllDefined({
-    chainHub,
-    feeConfig,
-    statusManager,
-    watch,
-    when,
-  });
-  const feeTools = makeFeeTools(feeConfig);
-  /** @param {bigint} value */
-  const toAmount = value => AmountMath.make(usdc.brand, value);
-
-  return zone.exoClassKit(
-    'Fast USDC Advancer',
-    AdvancerKitI,
-    /**
-     * @param {{
-     *   borrowerFacet: LiquidityPoolKit['borrower'];
-     *   poolAccount: HostInterface<OrchestrationAccount<{chainId: 'agoric'}>>;
-     * }} config
-     */
-    config => harden(config),
-    {
-      advancer: {
-        /**
-         * Must perform a status update for every observed transaction.
-         *
-         * We do not expect any callers to depend on the settlement of
-         * `handleTransactionEvent` - errors caught are communicated to the
-         * `StatusManager` - so we don't need to concern ourselves with
-         * preserving the vow chain for callers.
-         *
-         * @param {CctpTxEvidence} evidence
-         */
-        async handleTransactionEvent(evidence) {
-          await null;
-          try {
-            const { borrowerFacet, poolAccount } = this.state;
-            const { recipientAddress } = evidence.aux;
-            const { EUD } = addressTools.getQueryParams(
-              recipientAddress,
-              EudParamShape,
-            );
-
-            // this will throw if the bech32 prefix is not found, but is handled by the catch
-            const destination = chainHub.makeChainAddress(EUD);
-            const requestedAmount = toAmount(evidence.tx.amount);
-            const advanceAmount = feeTools.calculateAdvance(requestedAmount);
-
-            // TODO: consider skipping and using `borrow()`s internal balance check
-            const poolBalance = borrowerFacet.getBalance();
-            if (!isGTE(poolBalance, requestedAmount)) {
-              log(
-                `Insufficient pool funds`,
-                `Requested ${q(advanceAmount)} but only have ${q(poolBalance)}`,
-              );
-              statusManager.observe(evidence);
-              return;
-            }
-
-            try {
-              // Mark as Advanced since `transferV` initiates the advance.
-              // Will throw if we've already .skipped or .advanced this evidence.
-              statusManager.advance(evidence);
-            } catch (e) {
-              // Only anticipated error is `assertNotSeen`, so intercept the
-              // catch so we don't call .skip which also performs this check
-              log('Advancer error:', q(e).toString());
-              return;
-            }
-
-            const { zcfSeat: tmpSeat } = zcf.makeEmptySeatKit();
-            const amountKWR = harden({ USDC: advanceAmount });
-            try {
-              borrowerFacet.borrow(tmpSeat, amountKWR);
-            } catch (e) {
-              // We do not expect this to fail since there are no turn boundaries
-              // between .getBalance() and .borrow().
-              // We catch to report outside of the normal error flow since this is
-              // not expected.
-              log('🚨 advance borrow failed', q(e).toString());
-            }
-
-            const depositV = localTransfer(
-              tmpSeat,
-              // @ts-expect-error LocalAccountMethods vs OrchestrationAccount
-              poolAccount,
-              amountKWR,
-            );
-            void watch(depositV, this.facets.depositHandler, {
-              amount: advanceAmount,
-              destination,
-              tmpSeat,
-            });
-          } catch (e) {
-            log('Advancer error:', q(e).toString());
-            statusManager.observe(evidence);
-          }
-        },
-      },
-      depositHandler: {
-        /**
-         * @param {undefined} result
-         * @param {{ amount: Amount<'nat'>; destination: ChainAddress; tmpSeat: ZCFSeat }} ctx
-         */
-        onFulfilled(result, { amount, destination }) {
-          const { poolAccount } = this.state;
-          const transferV = E(poolAccount).transfer(destination, {
-            denom: usdc.denom,
-            value: amount.value,
-          });
-          return watch(transferV, this.facets.transferHandler, {
-            destination,
-            amount,
-          });
-        },
-        /**
-         * @param {Error} error
-         * @param {{ amount: Amount<'nat'>; destination: ChainAddress; tmpSeat: ZCFSeat }} ctx
-         */
-        onRejected(error, { tmpSeat }) {
-          // TODO return seat allocation from ctx to LP?
-          log('🚨 advance deposit failed', q(error).toString());
-          // TODO #10510 (comprehensive error testing) determine
-          // course of action here
-          log(
-            'TODO live payment on seat to return to LP',
-            q(tmpSeat).toString(),
-          );
-        },
-      },
-      transferHandler: {
-        /**
-         * @param {undefined} result TODO confirm this is not a bigint (sequence)
-         * @param {{ destination: ChainAddress; amount: NatAmount; }} ctx
-         */
-        onFulfilled(result, { destination, amount }) {
-          // TODO vstorage update? We don't currently have a status for
-          // Advanced + transferV settled
-          log(
-            'Advance transfer fulfilled',
-            q({ amount, destination, result }).toString(),
-          );
-        },
-        onRejected(error) {
-          // TODO #10510 (comprehensive error testing) determine
-          // course of action here. This might fail due to timeout.
-          log('Advance transfer rejected', q(error).toString());
-        },
-      },
-    },
-    {
-      stateShape: harden({
-        borrowerFacet: M.remotable(),
-        poolAccount: M.remotable(),
-      }),
-    },
-  );
-};
-harden(prepareAdvancerKit);
-
-/**
- * @param {Zone} zone
- * @param {AdvancerKitPowers} caps
- */
-export const prepareAdvancer = (zone, caps) => {
-  const makeAdvancerKit = prepareAdvancerKit(zone, caps);
-  return pickFacet(makeAdvancerKit, 'advancer');
-};
-harden(prepareAdvancer);

package/src/exos/liquidity-pool.js

@@ -1,365 +0,0 @@
-import { AmountMath, AmountShape } from '@agoric/ertp';
-import {
-  makeRecorderTopic,
-  TopicsRecordShape,
-} 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,
-  depositCalc,
-  makeParity,
-  repayCalc,
-  withdrawCalc,
-} from '../pool-share-math.js';
-import {
-  makeNatAmountShape,
-  makeProposalShapes,
-  PoolMetricsShape,
-} from '../type-guards.js';
-
-/**
- * @import {Zone} from '@agoric/zone';
- * @import {Remote} from '@agoric/internal'
- * @import {StorageNode} from '@agoric/internal/src/lib-chainStorage.js'
- * @import {MakeRecorderKit} from '@agoric/zoe/src/contractSupport/recorder.js'
- * @import {USDCProposalShapes, ShareWorth} from '../pool-share-math.js'
- * @import {PoolStats} from '../types.js';
- */
-
-const { add, isEqual, 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 {{
- *  Principal: Amount<'nat'>;
- *  PoolFee: Amount<'nat'>;
- *  ContractFee: Amount<'nat'>;
- * }} RepayAmountKWR
- */
-
-/**
- * @typedef {{
- *  Principal: Payment<'nat'>;
- *  PoolFee: Payment<'nat'>;
- *  ContractFee: Payment<'nat'>;
- * }} RepayPaymentKWR
- */
-
-/**
- * @param {Zone} zone
- * @param {ZCF} zcf
- * @param {Brand<'nat'>} USDC
- * @param {{
- *   makeRecorderKit: MakeRecorderKit;
- * }} tools
- */
-export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
-  return zone.exoClassKit(
-    'Liquidity Pool',
-    {
-      borrower: M.interface('borrower', {
-        getBalance: M.call().returns(AmountShape),
-        borrow: M.call(
-          SeatShape,
-          harden({ USDC: makeNatAmountShape(USDC, 1n) }),
-        ).returns(),
-      }),
-      repayer: M.interface('repayer', {
-        repay: M.call(
-          SeatShape,
-          harden({
-            Principal: makeNatAmountShape(USDC, 1n),
-            PoolFee: makeNatAmountShape(USDC, 0n),
-            ContractFee: makeNatAmountShape(USDC, 0n),
-          }),
-        ).returns(),
-      }),
-      external: M.interface('external', {
-        publishPoolMetrics: M.call().returns(),
-      }),
-      depositHandler: M.interface('depositHandler', {
-        handle: M.call(SeatShape, M.any()).returns(M.promise()),
-      }),
-      withdrawHandler: M.interface('withdrawHandler', {
-        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),
-      }),
-    },
-    /**
-     * @param {ZCFMint<'nat'>} shareMint
-     * @param {Remote<StorageNode>} node
-     */
-    (shareMint, node) => {
-      const { brand: PoolShares } = shareMint.getIssuerRecord();
-      const proposalShapes = makeProposalShapes({ USDC, PoolShares });
-      const shareWorth = makeParity(makeDust(USDC), PoolShares);
-      const { zcfSeat: poolSeat } = zcf.makeEmptySeatKit();
-      const { zcfSeat: feeSeat } = zcf.makeEmptySeatKit();
-      const poolMetricsRecorderKit = tools.makeRecorderKit(
-        node,
-        PoolMetricsShape,
-      );
-      const encumberedBalance = makeEmpty(USDC);
-      /** @type {PoolStats} */
-      const poolStats = harden({
-        totalBorrows: makeEmpty(USDC),
-        totalContractFees: makeEmpty(USDC),
-        totalPoolFees: makeEmpty(USDC),
-        totalRepays: makeEmpty(USDC),
-      });
-      return {
-        /** used for `checkPoolBalance` invariant. aka 'outstanding borrows' */
-        encumberedBalance,
-        feeSeat,
-        poolStats,
-        poolMetricsRecorderKit,
-        poolSeat,
-        PoolShares,
-        proposalShapes,
-        shareMint,
-        shareWorth,
-      };
-    },
-    {
-      borrower: {
-        getBalance() {
-          const { poolSeat } = this.state;
-          return poolSeat.getAmountAllocated('USDC', USDC);
-        },
-        /**
-         * @param {ZCFSeat} toSeat
-         * @param {{ USDC: Amount<'nat'>}} amountKWR
-         */
-        borrow(toSeat, amountKWR) {
-          const { encumberedBalance, poolSeat, poolStats } = this.state;
-
-          // Validate amount is available in pool
-          const post = borrowCalc(
-            amountKWR.USDC,
-            poolSeat.getAmountAllocated('USDC', USDC),
-            encumberedBalance,
-            poolStats,
-          );
-
-          // COMMIT POINT
-          try {
-            zcf.atomicRearrange(harden([[poolSeat, toSeat, amountKWR]]));
-          } catch (cause) {
-            const reason = Error('🚨 cannot commit borrow', { cause });
-            console.error(reason.message, cause);
-            zcf.shutdownWithFailure(reason);
-          }
-
-          Object.assign(this.state, post);
-          this.facets.external.publishPoolMetrics();
-        },
-        // TODO method to repay failed `LOA.deposit()`
-      },
-      repayer: {
-        /**
-         * @param {ZCFSeat} fromSeat
-         * @param {RepayAmountKWR} amounts
-         */
-        repay(fromSeat, amounts) {
-          const {
-            encumberedBalance,
-            feeSeat,
-            poolSeat,
-            poolStats,
-            shareWorth,
-          } = this.state;
-          checkPoolBalance(poolSeat, shareWorth, USDC, encumberedBalance);
-
-          const fromSeatAllocation = fromSeat.getCurrentAllocation();
-          // Validate allocation equals amounts and Principal <= encumberedBalance
-          const post = repayCalc(
-            shareWorth,
-            fromSeatAllocation,
-            amounts,
-            encumberedBalance,
-            poolStats,
-          );
-
-          const { ContractFee, ...rest } = amounts;
-
-          // COMMIT POINT
-          try {
-            zcf.atomicRearrange(
-              harden([
-                [
-                  fromSeat,
-                  poolSeat,
-                  rest,
-                  { USDC: add(amounts.PoolFee, amounts.Principal) },
-                ],
-                [fromSeat, feeSeat, { ContractFee }, { USDC: ContractFee }],
-              ]),
-            );
-          } catch (cause) {
-            const reason = Error('🚨 cannot commit repay', { cause });
-            console.error(reason.message, cause);
-            zcf.shutdownWithFailure(reason);
-          }
-
-          Object.assign(this.state, post);
-          this.facets.external.publishPoolMetrics();
-        },
-      },
-      external: {
-        publishPoolMetrics() {
-          const { poolStats, shareWorth, encumberedBalance } = this.state;
-          const { recorder } = this.state.poolMetricsRecorderKit;
-          // Consumers of this .write() are off-chain / outside the VM.
-          // And there's no way to recover from a failed write.
-          // So don't await.
-          void recorder.write({
-            encumberedBalance,
-            shareWorth,
-            ...poolStats,
-          });
-        },
-      },
-
-      depositHandler: {
-        /** @param {ZCFSeat} lp */
-        async handle(lp) {
-          const { shareWorth, shareMint, poolSeat, encumberedBalance } =
-            this.state;
-          const { external } = this.facets;
-
-          /** @type {USDCProposalShapes['deposit']} */
-          // @ts-expect-error ensured by proposalShape
-          const proposal = lp.getProposal();
-          checkPoolBalance(poolSeat, shareWorth, USDC, encumberedBalance);
-          const post = depositCalc(shareWorth, proposal);
-
-          // COMMIT POINT
-
-          try {
-            const mint = shareMint.mintGains(post.payouts);
-            this.state.shareWorth = post.shareWorth;
-            zcf.atomicRearrange(
-              harden([
-                // zoe guarantees lp has proposal.give allocated
-                [lp, poolSeat, proposal.give],
-                // mintGains() above establishes that mint has post.payouts
-                [mint, lp, post.payouts],
-              ]),
-            );
-            lp.exit();
-            mint.exit();
-          } catch (cause) {
-            const reason = Error('🚨 cannot commit deposit', { cause });
-            console.error(reason.message, cause);
-            zcf.shutdownWithFailure(reason);
-          }
-          external.publishPoolMetrics();
-        },
-      },
-      withdrawHandler: {
-        /** @param {ZCFSeat} lp */
-        async handle(lp) {
-          const { shareWorth, shareMint, poolSeat, encumberedBalance } =
-            this.state;
-          const { external } = this.facets;
-
-          /** @type {USDCProposalShapes['withdraw']} */
-          // @ts-expect-error ensured by proposalShape
-          const proposal = lp.getProposal();
-          const { zcfSeat: burn } = zcf.makeEmptySeatKit();
-          checkPoolBalance(poolSeat, shareWorth, USDC, encumberedBalance);
-          const post = withdrawCalc(shareWorth, proposal);
-
-          // COMMIT POINT
-
-          try {
-            this.state.shareWorth = post.shareWorth;
-            zcf.atomicRearrange(
-              harden([
-                // zoe guarantees lp has proposal.give allocated
-                [lp, burn, proposal.give],
-                // checkPoolBalance() + withdrawCalc() guarantee poolSeat has enough
-                [poolSeat, lp, post.payouts],
-              ]),
-            );
-            shareMint.burnLosses(proposal.give, burn);
-            lp.exit();
-            burn.exit();
-          } catch (cause) {
-            const reason = Error('🚨 cannot commit withdraw', { cause });
-            console.error(reason.message, cause);
-            zcf.shutdownWithFailure(reason);
-          }
-          external.publishPoolMetrics();
-        },
-      },
-      public: {
-        makeDepositInvitation() {
-          return zcf.makeInvitation(
-            this.facets.depositHandler,
-            'Deposit',
-            undefined,
-            this.state.proposalShapes.deposit,
-          );
-        },
-        makeWithdrawInvitation() {
-          return zcf.makeInvitation(
-            this.facets.withdrawHandler,
-            'Withdraw',
-            undefined,
-            this.state.proposalShapes.withdraw,
-          );
-        },
-        getPublicTopics() {
-          const { poolMetricsRecorderKit } = this.state;
-          return {
-            poolMetrics: makeRecorderTopic(
-              'poolMetrics',
-              poolMetricsRecorderKit,
-            ),
-          };
-        },
-      },
-    },
-    {
-      finish: ({ facets: { external } }) => {
-        void external.publishPoolMetrics();
-      },
-    },
-  );
-};
-harden(prepareLiquidityPoolKit);
-
-/**
- * @typedef {ReturnType<ReturnType<typeof prepareLiquidityPoolKit>>} LiquidityPoolKit
- */