@agoric/fast-usdc 0.2.0-upgrade-20-dev-ef71cfd.0 → 0.2.0-upgrade-19-devnet-dev-5428c4d.0

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

@@ -0,0 +1,65 @@
+/** @file core-eval to publish update to Fast USDC feedPolicy */
+
+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'
+ * @import {FeedPolicy} from './types.js'
+ */
+
+const contractName = 'fastUsdc';
+
+/**
+ * @param {BootstrapPowers &
+ *  { consume: { chainStorage: Promise<StorageNode> }}
+ * } powers
+ * @param {{ options: LegibleCapData<{feedPolicy: FeedPolicy & Passable}> }} config
+ */
+export const updateFastUsdcPolicy = async (
+  { consume: { agoricNames, chainStorage } },
+  config,
+) => {
+  /** @type {Issuer<'nat'>} */
+  const USDCissuer = await E(agoricNames).lookup('issuer', 'USDC');
+  const brands = harden({
+    USDC: await E(USDCissuer).getBrand(),
+  });
+  const { feedPolicy } = fromExternalConfig(
+    config.options,
+    brands,
+    harden({ feedPolicy: FeedPolicyShape }),
+  );
+
+  const storageNode = await E(chainStorage).makeChildNode(contractName);
+
+  await publishFeedPolicy(storageNode, feedPolicy);
+};
+
+/**
+ * @param {unknown} _utils
+ * @param {{
+ *   options: LegibleCapData<{feedPolicy: FeedPolicy & Passable}>;
+ * }} param1
+ */
+export const getManifestForUpdateFastUsdcPolicy = (_utils, { options }) => {
+  return {
+    /** @type {BootstrapManifest} */
+    manifest: {
+      [updateFastUsdcPolicy.name]: {
+        consume: {
+          chainStorage: true,
+
+          // widely shared: name services
+          agoricNames: true,
+        },
+      },
+    },
+    options,
+  };
+};

package/src/fast-usdc.contract.js

@@ -0,0 +1,316 @@
+import { AssetKind } from '@agoric/ertp';
+import { makeTracer } from '@agoric/internal';
+import { observeIteration, subscribeEach } from '@agoric/notifier';
+import {
+  CosmosChainInfoShape,
+  DenomDetailShape,
+  DenomShape,
+  OrchestrationPowersShape,
+  registerChainsAndAssets,
+  withOrchestration,
+} from '@agoric/orchestration';
+import { makeZoeTools } from '@agoric/orchestration/src/utils/zoe-tools.js';
+import { provideSingleton } from '@agoric/zoe/src/contractSupport/durability.js';
+import { prepareRecorderKitMakers } from '@agoric/zoe/src/contractSupport/recorder.js';
+import { Fail } from '@endo/errors';
+import { E } from '@endo/far';
+import { M } from '@endo/patterns';
+import { prepareAdvancer } from './exos/advancer.js';
+import { prepareLiquidityPoolKit } from './exos/liquidity-pool.js';
+import { prepareSettler } from './exos/settler.js';
+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';
+
+const trace = makeTracer('FastUsdc');
+
+const TXNS_NODE = 'txns';
+const FEE_NODE = 'feeConfig';
+const ADDRESSES_BAGGAGE_KEY = 'addresses';
+
+/**
+ * @import {HostInterface} from '@agoric/async-flow';
+ * @import {ChainAddress, CosmosChainInfo, Denom, DenomDetail, OrchestrationAccount} from '@agoric/orchestration';
+ * @import {OrchestrationPowers, OrchestrationTools} from '@agoric/orchestration/src/utils/start-helper.js';
+ * @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';
+ */
+
+/**
+ * @typedef {{
+ *   usdcDenom: Denom;
+ * }} FastUsdcTerms
+ */
+
+/** @type {ContractMeta<typeof start>} */
+export const meta = {
+  // @ts-expect-error TypedPattern not recognized as record
+  customTermsShape: FastUSDCTermsShape,
+  privateArgsShape: {
+    // @ts-expect-error TypedPattern not recognized as record
+    ...OrchestrationPowersShape,
+    assetInfo: M.arrayOf([DenomShape, DenomDetailShape]),
+    chainInfo: M.recordOf(M.string(), CosmosChainInfoShape),
+    feeConfig: FeeConfigShape,
+    marshaller: M.remotable(),
+    poolMetricsNode: M.remotable(),
+  },
+};
+harden(meta);
+
+/**
+ * @param {Remote<StorageNode>} node
+ * @param {ERef<Marshaller>} marshaller
+ * @param {FeeConfig} feeConfig
+ */
+const publishFeeConfig = async (node, marshaller, feeConfig) => {
+  const feeNode = E(node).makeChildNode(FEE_NODE);
+  const value = await E(marshaller).toCapData(feeConfig);
+  return E(feeNode).setValue(JSON.stringify(value));
+};
+
+/**
+ * @param {Remote<StorageNode>} contractNode
+ * @param {ContractRecord} addresses
+ */
+const publishAddresses = (contractNode, addresses) => {
+  return E(contractNode).setValue(JSON.stringify(addresses));
+};
+
+/**
+ * @param {ZCF<FastUsdcTerms>} zcf
+ * @param {OrchestrationPowers & {
+ *   assetInfo: [Denom, DenomDetail & { brandKey?: string}][];
+ *   chainInfo: Record<string, CosmosChainInfo>;
+ *   feeConfig: FeeConfig;
+ *   marshaller: Marshaller;
+ *   poolMetricsNode: Remote<StorageNode>;
+ *   storageNode: Remote<StorageNode>;
+ * }} privateArgs
+ * @param {Zone} zone
+ * @param {OrchestrationTools} tools
+ */
+export const contract = async (zcf, privateArgs, zone, tools) => {
+  assert(tools, 'no tools');
+  const terms = zcf.getTerms();
+  assert('USDC' in terms.brands, 'no USDC brand');
+  assert('usdcDenom' in terms, 'no usdcDenom');
+
+  const { feeConfig, marshaller, storageNode } = privateArgs;
+  const { makeRecorderKit } = prepareRecorderKitMakers(
+    zone.mapStore('vstorage'),
+    marshaller,
+  );
+
+  const statusManager = prepareStatusManager(
+    zone,
+    E(storageNode).makeChildNode(TXNS_NODE),
+    { marshaller },
+  );
+
+  const { USDC } = terms.brands;
+  const { withdrawToSeat } = tools.zoeTools;
+  const { baggage, chainHub, orchestrateAll, vowTools } = tools;
+  const makeSettler = prepareSettler(zone, {
+    statusManager,
+    USDC,
+    withdrawToSeat,
+    feeConfig,
+    vowTools: tools.vowTools,
+    zcf,
+    chainHub,
+  });
+
+  const zoeTools = makeZoeTools(zcf, vowTools);
+  const makeAdvancer = prepareAdvancer(zone, {
+    chainHub,
+    feeConfig,
+    usdc: harden({
+      brand: terms.brands.USDC,
+      denom: terms.usdcDenom,
+    }),
+    statusManager,
+    vowTools,
+    zcf,
+    zoeTools,
+  });
+
+  const makeFeedKit = prepareTransactionFeedKit(zone, zcf);
+
+  const makeLiquidityPoolKit = prepareLiquidityPoolKit(
+    zone,
+    zcf,
+    terms.brands.USDC,
+    { makeRecorderKit },
+  );
+
+  const { makeLocalAccount, makeNobleAccount } = orchestrateAll(flows, {});
+
+  const creatorFacet = zone.exo('Fast USDC Creator', undefined, {
+    /** @type {(operatorId: string) => Promise<Invitation<OperatorOfferResult>>} */
+    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);
+        return vowTools.when(
+          E(nobleAccount).getAddress(),
+          intermediateRecipient => {
+            trace('intermediateRecipient', intermediateRecipient);
+            advancer.setIntermediateRecipient(intermediateRecipient);
+            settlerKit.creator.setIntermediateRecipient(intermediateRecipient);
+            return intermediateRecipient;
+          },
+        );
+      });
+    },
+    async publishAddresses() {
+      !baggage.has(ADDRESSES_BAGGAGE_KEY) || Fail`Addresses already published`;
+      const [poolAccountAddress] = await vowTools.when(
+        vowTools.all([E(poolAccount).getAddress()]),
+      );
+      const addresses = harden({
+        poolAccount: poolAccountAddress.value,
+        settlementAccount: settlementAddress.value,
+      });
+      baggage.init(ADDRESSES_BAGGAGE_KEY, addresses);
+      await publishAddresses(storageNode, addresses);
+      return addresses;
+    },
+    deleteCompletedTxs() {
+      return statusManager.deleteCompletedTxs();
+    },
+  });
+
+  const publicFacet = zone.exo('Fast USDC Public', undefined, {
+    makeDepositInvitation() {
+      return poolKit.public.makeDepositInvitation();
+    },
+    makeWithdrawInvitation() {
+      return poolKit.public.makeWithdrawInvitation();
+    },
+    getPublicTopics() {
+      return poolKit.public.getPublicTopics();
+    },
+    getStaticInfo() {
+      baggage.has(ADDRESSES_BAGGAGE_KEY) ||
+        Fail`no addresses. creator must 'publishAddresses' first`;
+      return harden({
+        [ADDRESSES_BAGGAGE_KEY]: baggage.get(ADDRESSES_BAGGAGE_KEY),
+      });
+    },
+  });
+
+  // ^^^ Define all kinds above this line. Keep remote calls below. vvv
+
+  // NOTE: Using a ZCFMint is helpful for the usual reasons (
+  // synchronous mint/burn, keeping assets out of contract vats, ...).
+  // And there's just one pool, which suggests building it with zone.exo().
+  //
+  // But zone.exo() defines a kind and
+  // all kinds have to be defined before any remote calls,
+  // such as the one to the zoe vat as part of making a ZCFMint.
+  //
+  // So we use zone.exoClassKit above to define the liquidity pool kind
+  // and pass the shareMint into the maker / init function.
+
+  void publishFeeConfig(storageNode, marshaller, feeConfig);
+
+  const shareMint = await provideSingleton(
+    zone.mapStore('mint'),
+    'PoolShare',
+    () =>
+      zcf.makeZCFMint('PoolShares', AssetKind.NAT, {
+        decimalPlaces: 6,
+      }),
+  );
+
+  const poolKit = zone.makeOnce('Liquidity Pool kit', () =>
+    makeLiquidityPoolKit(shareMint, privateArgs.poolMetricsNode),
+  );
+
+  /** Chain, connection, and asset info can only be registered once */
+  const firstIncarnationKey = 'firstIncarnationKey';
+  if (!baggage.has(firstIncarnationKey)) {
+    baggage.init(firstIncarnationKey, true);
+    registerChainsAndAssets(
+      chainHub,
+      terms.brands,
+      privateArgs.chainInfo,
+      privateArgs.assetInfo,
+    );
+  }
+
+  const nobleAccountV = zone.makeOnce('NobleAccount', () => makeNobleAccount());
+
+  const feedKit = zone.makeOnce('Feed Kit', () => makeFeedKit());
+
+  const poolAccountV = zone.makeOnce('PoolAccount', () => makeLocalAccount());
+  const settleAccountV = zone.makeOnce('SettleAccount', () =>
+    makeLocalAccount(),
+  );
+  // when() is OK here since this clearly resolves promptly.
+  /** @type {[HostInterface<OrchestrationAccount<{chainId: 'agoric-3';}>>, HostInterface<OrchestrationAccount<{chainId: 'agoric-3';}>>]} */
+  const [poolAccount, settlementAccount] = await vowTools.when(
+    vowTools.all([poolAccountV, settleAccountV]),
+  );
+  trace('settlementAccount', settlementAccount);
+  trace('poolAccount', poolAccount);
+  const settlementAddress = await E(settlementAccount).getAddress();
+  trace('settlementAddress', settlementAddress);
+
+  const [_agoric, _noble, agToNoble] = await vowTools.when(
+    chainHub.getChainsAndConnection('agoric', 'noble'),
+  );
+  const settlerKit = makeSettler({
+    repayer: poolKit.repayer,
+    sourceChannel: agToNoble.transferChannel.counterPartyChannelId,
+    remoteDenom: 'uusdc',
+    settlementAccount,
+  });
+
+  const advancer = zone.makeOnce('Advancer', () =>
+    makeAdvancer({
+      borrower: poolKit.borrower,
+      notifier: settlerKit.notifier,
+      poolAccount,
+      settlementAddress,
+    }),
+  );
+  // Connect evidence stream to advancer
+  void observeIteration(subscribeEach(feedKit.public.getEvidenceSubscriber()), {
+    updateState(evidenceWithRisk) {
+      try {
+        void advancer.handleTransactionEvent(evidenceWithRisk);
+      } catch (err) {
+        trace('🚨 Error handling transaction event', err);
+      }
+    },
+  });
+
+  await settlerKit.creator.monitorMintingDeposits();
+
+  return harden({ creatorFacet, publicFacet });
+};
+harden(contract);
+
+export const start = withOrchestration(contract);
+harden(start);
+/** @typedef {typeof start} FastUsdcSF */

package/src/fast-usdc.flows.js

@@ -0,0 +1,23 @@
+/**
+ * @import {Orchestrator, OrchestrationFlow} from '@agoric/orchestration';
+ */
+
+/**
+ * @satisfies {OrchestrationFlow}
+ * @param {Orchestrator} orch
+ */
+export const makeLocalAccount = async orch => {
+  const agoricChain = await orch.getChain('agoric');
+  return agoricChain.makeAccount();
+};
+harden(makeLocalAccount);
+
+/**
+ * @satisfies {OrchestrationFlow}
+ * @param {Orchestrator} orch
+ */
+export const makeNobleAccount = async orch => {
+  const nobleChain = await orch.getChain('noble');
+  return nobleChain.makeAccount();
+};
+harden(makeNobleAccount);

package/src/pool-share-math.js

@@ -4,17 +4,16 @@ import {
   makeRatio,
   makeRatioFromAmounts,
   multiplyBy,
-} from '@agoric/ertp/src/ratio.js';
+} from '@agoric/zoe/src/contractSupport/ratio.js';
 import { Fail, q } from '@endo/errors';
 
 const { keys } = Object;
 const { add, isEmpty, isEqual, isGTE, make, makeEmpty, subtract } = AmountMath;
 
 /**
- * @import {Amount, Brand, DepositFacet, NatValue, Payment, Ratio} from '@agoric/ertp';
- * @import {Allocation} from '@agoric/zoe';
- * @import {PoolStats} from './types.js';
- * @import {RepayAmountKWR} from './utils/fees.js';
+ * @import {Amount, Brand, DepositFacet, NatValue, Payment} from '@agoric/ertp';
+ * @import {PoolStats} from './types';
+ * @import {RepayAmountKWR} from './exos/liquidity-pool';
  */
 
 /**
@@ -202,26 +201,35 @@ export const borrowCalc = (
 
 /**
  * @param {ShareWorth} shareWorth
- * @param {RepayAmountKWR} split
+ * @param {Allocation} fromSeatAllocation
+ * @param {RepayAmountKWR} amounts
  * @param {Amount<'nat'>} encumberedBalance aka 'outstanding borrows'
  * @param {PoolStats} poolStats
- * @throws {Error} if Principal exceeds encumberedBalance
+ * @throws {Error} if allocations do not match amounts or Principal exceeds encumberedBalance
  */
-export const repayCalc = (shareWorth, split, encumberedBalance, poolStats) => {
-  isGTE(encumberedBalance, split.Principal) ||
-    Fail`Cannot repay. Principal ${q(split.Principal)} exceeds encumberedBalance ${q(encumberedBalance)}.`;
+export const repayCalc = (
+  shareWorth,
+  fromSeatAllocation,
+  amounts,
+  encumberedBalance,
+  poolStats,
+) => {
+  (isEqual(fromSeatAllocation.Principal, amounts.Principal) &&
+    isEqual(fromSeatAllocation.PoolFee, amounts.PoolFee) &&
+    isEqual(fromSeatAllocation.ContractFee, amounts.ContractFee)) ||
+    Fail`Cannot repay. From seat allocation ${q(fromSeatAllocation)} does not equal amounts ${q(amounts)}.`;
+
+  isGTE(encumberedBalance, amounts.Principal) ||
+    Fail`Cannot repay. Principal ${q(amounts.Principal)} exceeds encumberedBalance ${q(encumberedBalance)}.`;
 
   return harden({
-    shareWorth: withFees(shareWorth, split.PoolFee),
-    encumberedBalance: subtract(encumberedBalance, split.Principal),
+    shareWorth: withFees(shareWorth, amounts.PoolFee),
+    encumberedBalance: subtract(encumberedBalance, amounts.Principal),
     poolStats: {
       ...poolStats,
-      totalRepays: add(poolStats.totalRepays, split.Principal),
-      totalPoolFees: add(poolStats.totalPoolFees, split.PoolFee),
-      totalContractFees: add(
-        add(poolStats.totalContractFees, split.ContractFee),
-        split.RelayFee,
-      ),
+      totalRepays: add(poolStats.totalRepays, amounts.Principal),
+      totalPoolFees: add(poolStats.totalPoolFees, amounts.PoolFee),
+      totalContractFees: add(poolStats.totalContractFees, amounts.ContractFee),
     },
   });
 };