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

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

@@ -0,0 +1,75 @@
+/** @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 {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';
+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 &
+ *  { 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

@@ -1,41 +1,44 @@
 import { AssetKind } from '@agoric/ertp';
-import {
-  assertAllDefined,
-  deeplyFulfilledObject,
-  makeTracer,
-} from '@agoric/internal';
+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 { makeZoeTools } from '@agoric/orchestration/src/utils/zoe-tools.js';
-import { depositToSeat } from '@agoric/zoe/src/contractSupport/zoeHelpers.js';
+import { Fail } from '@endo/errors';
 import { E } from '@endo/far';
-import { M, objectMap } from '@endo/patterns';
+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 { defineInertInvitation } from './utils/zoe.js';
-import { FastUSDCTermsShape, FeeConfigShape } from './type-guards.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');
 
+const TXNS_NODE = 'txns';
+const FEE_NODE = 'feeConfig';
+const ADDRESSES_BAGGAGE_KEY = 'addresses';
+
 /**
- * @import {Denom} from '@agoric/orchestration';
  * @import {HostInterface} from '@agoric/async-flow';
- * @import {OrchestrationAccount} from '@agoric/orchestration';
+ * @import {ChainAddress, CosmosChainInfo, Denom, DenomDetail, OrchestrationAccount} from '@agoric/orchestration';
  * @import {OrchestrationPowers, OrchestrationTools} from '@agoric/orchestration/src/utils/start-helper.js';
- * @import {Vow} from '@agoric/vow';
+ * @import {Remote} from '@agoric/internal';
+ * @import {Marshaller, StorageNode} from '@agoric/internal/src/lib-chainStorage.js'
  * @import {Zone} from '@agoric/zone';
  * @import {OperatorKit} from './exos/operator-kit.js';
- * @import {CctpTxEvidence, FeeConfig} from './types.js';
- * @import {RepayAmountKWR, RepayPaymentKWR} from './exos/liquidity-pool.js';
+ * @import {CctpTxEvidence, FeeConfig, RiskAssessment} from './types.js';
  */
 
 /**
@@ -51,17 +54,45 @@ export const meta = {
   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 {{
+ *  poolAccount: ChainAddress['value'];
+ *  settlementAccount: ChainAddress['value'];
+ * }} addresses
+ */
+const publishAddresses = (contractNode, addresses) => {
+  return E(contractNode).setValue(JSON.stringify(addresses));
+};
+
 /**
  * @param {ZCF<FastUsdcTerms>} zcf
  * @param {OrchestrationPowers & {
- *   marshaller: Marshaller;
+ *   assetInfo: [Denom, DenomDetail & { brandKey?: string}][];
+ *   chainInfo: Record<string, CosmosChainInfo>;
  *   feeConfig: FeeConfig;
+ *   marshaller: Marshaller;
+ *   poolMetricsNode: Remote<StorageNode>;
  * }} privateArgs
  * @param {Zone} zone
  * @param {OrchestrationTools} tools
@@ -71,14 +102,32 @@ export const contract = async (zcf, privateArgs, zone, tools) => {
   const terms = zcf.getTerms();
   assert('USDC' in terms.brands, 'no USDC brand');
   assert('usdcDenom' in terms, 'no usdcDenom');
-  const { feeConfig, marshaller } = privateArgs;
+
+  const { feeConfig, marshaller, storageNode } = privateArgs;
   const { makeRecorderKit } = prepareRecorderKitMakers(
     zone.mapStore('vstorage'),
     marshaller,
   );
-  const statusManager = prepareStatusManager(zone);
-  const makeSettler = prepareSettler(zone, { statusManager });
-  const { chainHub, orchestrateAll, vowTools } = tools;
+
+  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 { localTransfer } = makeZoeTools(zcf, vowTools);
   const makeAdvancer = prepareAdvancer(zone, {
     chainHub,
@@ -92,8 +141,9 @@ export const contract = async (zcf, privateArgs, zone, tools) => {
     vowTools,
     zcf,
   });
+
   const makeFeedKit = prepareTransactionFeedKit(zone, zcf);
-  assertAllDefined({ makeFeedKit, makeAdvancer, makeSettler, statusManager });
+
   const makeLiquidityPoolKit = prepareLiquidityPoolKit(
     zone,
     zcf,
@@ -106,42 +156,39 @@ export const contract = async (zcf, privateArgs, zone, tools) => {
     'test of forcing evidence',
   );
 
-  const { makeLocalAccount } = orchestrateAll(flows, {});
+  const { makeLocalAccount, makeNobleAccount } = orchestrateAll(flows, {});
 
   const creatorFacet = zone.exo('Fast USDC Creator', undefined, {
     /** @type {(operatorId: string) => Promise<Invitation<OperatorKit>>} */
     async makeOperatorInvitation(operatorId) {
-      // eslint-disable-next-line no-use-before-define
       return feedKit.creator.makeOperatorInvitation(operatorId);
     },
-    /**
-     * @param {{ USDC: Amount<'nat'>}} amounts
-     */
-    testBorrow(amounts) {
-      console.log('🚧🚧 UNTIL: borrow is integrated (#10388) 🚧🚧', amounts);
-      const { zcfSeat: tmpAssetManagerSeat } = zcf.makeEmptySeatKit();
-      poolKit.borrower.borrow(tmpAssetManagerSeat, amounts);
-      return tmpAssetManagerSeat.getCurrentAllocation();
+    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;
+          },
+        );
+      });
     },
-    /**
-     *
-     * @param {RepayAmountKWR} amounts
-     * @param {RepayPaymentKWR} payments
-     * @returns {Promise<AmountKeywordRecord>}
-     */
-    async testRepay(amounts, payments) {
-      console.log('🚧🚧 UNTIL: repay is integrated (#10388) 🚧🚧', amounts);
-      const { zcfSeat: tmpAssetManagerSeat } = zcf.makeEmptySeatKit();
-      await depositToSeat(
-        zcf,
-        tmpAssetManagerSeat,
-        await deeplyFulfilledObject(
-          objectMap(payments, pmt => E(terms.issuers.USDC).getAmountOf(pmt)),
-        ),
-        payments,
+    async publishAddresses() {
+      !baggage.has(ADDRESSES_BAGGAGE_KEY) || Fail`Addresses already published`;
+      const [poolAccountAddress] = await vowTools.when(
+        vowTools.all([E(poolAccount).getAddress()]),
       );
-      poolKit.repayer.repay(tmpAssetManagerSeat, amounts);
-      return tmpAssetManagerSeat.getCurrentAllocation();
+      const addresses = harden({
+        poolAccount: poolAccountAddress.value,
+        settlementAccount: settlementAddress.value,
+      });
+      baggage.init(ADDRESSES_BAGGAGE_KEY, addresses);
+      await publishAddresses(storageNode, addresses);
+      return addresses;
     },
   });
 
@@ -155,10 +202,10 @@ export const contract = async (zcf, privateArgs, zone, tools) => {
      * capability is available in the smart-wallet bridge during UI testing.
      *
      * @param {CctpTxEvidence} evidence
+     * @param {RiskAssessment} [risk]
      */
-    makeTestPushInvitation(evidence) {
-      // eslint-disable-next-line no-use-before-define
-      void advancer.handleTransactionEvent(evidence);
+    makeTestPushInvitation(evidence, risk = {}) {
+      void advancer.handleTransactionEvent({ evidence, risk });
       return makeTestInvitation();
     },
     makeDepositInvitation() {
@@ -170,6 +217,13 @@ export const contract = async (zcf, privateArgs, zone, tools) => {
     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
@@ -185,6 +239,8 @@ export const contract = async (zcf, privateArgs, zone, tools) => {
   // 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',
@@ -195,37 +251,70 @@ export const contract = async (zcf, privateArgs, zone, tools) => {
   );
 
   const poolKit = zone.makeOnce('Liquidity Pool kit', () =>
-    makeLiquidityPoolKit(shareMint, privateArgs.storageNode),
+    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 =
-    // cast to HostInterface
-    /** @type { Vow<HostInterface<OrchestrationAccount<{chainId: 'agoric';}>>>} */ (
-      /** @type {unknown}*/ (
-        zone.makeOnce('Pool Local Orch Account', () => makeLocalAccount())
-      )
-    );
-  const poolAccount = await vowTools.when(poolAccountV);
+  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({
       borrowerFacet: poolKit.borrower,
+      notifyFacet: settlerKit.notify,
       poolAccount,
+      settlementAddress,
     }),
   );
   // Connect evidence stream to advancer
   void observeIteration(subscribeEach(feedKit.public.getEvidenceSubscriber()), {
-    updateState(evidence) {
+    updateState(evidenceWithRisk) {
       try {
-        void advancer.handleTransactionEvent(evidence);
+        void advancer.handleTransactionEvent(evidenceWithRisk);
       } catch (err) {
         trace('🚨 Error handling transaction event', err);
       }
     },
   });
 
+  await settlerKit.creator.monitorMintingDeposits();
+
   return harden({ creatorFacet, publicFacet });
 };
 harden(contract);

package/src/fast-usdc.flows.js

@@ -11,3 +11,13 @@ export const makeLocalAccount = async orch => {
   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/fast-usdc.start.js

@@ -1,4 +1,9 @@
 import { deeplyFulfilledObject, makeTracer, objectMap } from '@agoric/internal';
+import {
+  CosmosChainInfoShape,
+  DenomDetailShape,
+  DenomShape,
+} from '@agoric/orchestration';
 import { Fail } from '@endo/errors';
 import { E } from '@endo/far';
 import { makeMarshal } from '@endo/marshal';
@@ -17,30 +22,30 @@ import { fromExternalConfig } from './utils/config-marshal.js';
  * @import {Board} from '@agoric/vats'
  * @import {ManifestBundleRef} from '@agoric/deploy-script-support/src/externalTypes.js'
  * @import {BootstrapManifest} from '@agoric/vats/src/core/lib-boot.js'
- * @import {Passable} from '@endo/marshal';
  * @import {LegibleCapData} from './utils/config-marshal.js'
- * @import {FastUsdcSF, FastUsdcTerms} from './fast-usdc.contract.js'
- * @import {FeeConfig, FeedPolicy} from './types.js'
+ * @import {FastUsdcSF} from './fast-usdc.contract.js'
+ * @import {FeedPolicy, FastUSDCConfig} from './types.js'
  */
 
+const ShareAssetInfo = /** @type {const} */ harden({
+  issuerName: 'FastLP',
+  denom: 'ufastlp',
+  assetKind: 'nat',
+  decimalPlaces: 6,
+});
+
 const trace = makeTracer('FUSD-Start', true);
 
 const contractName = 'fastUsdc';
 
-/**
- * @typedef {{
- *   terms: FastUsdcTerms;
- *   oracles: Record<string, string>;
- *   feeConfig: FeeConfig;
- *   feedPolicy: FeedPolicy & Passable;
- * }} FastUSDCConfig
- */
 /** @type {TypedPattern<FastUSDCConfig>} */
 export const FastUSDCConfigShape = M.splitRecord({
   terms: FastUSDCTermsShape,
   oracles: M.recordOf(M.string(), M.string()),
   feeConfig: FeeConfigShape,
   feedPolicy: FeedPolicyShape,
+  chainInfo: M.recordOf(M.string(), CosmosChainInfoShape),
+  assetInfo: M.arrayOf([DenomShape, DenomDetailShape]),
 });
 
 /**
@@ -80,6 +85,7 @@ const publishDisplayInfo = async (brand, { board, chainStorage }) => {
 };
 
 const FEED_POLICY = 'feedPolicy';
+const POOL_METRICS = 'poolMetrics';
 
 /**
  * @param {ERef<StorageNode>} node
@@ -117,6 +123,7 @@ export const startFastUSDC = async (
     consume: {
       agoricNames,
       namesByAddress,
+      bankManager,
       board,
       chainStorage,
       chainTimerService: timerService,
@@ -149,8 +156,8 @@ export const startFastUSDC = async (
     USDC: await E(USDCissuer).getBrand(),
   });
 
-  const { terms, oracles, feeConfig, feedPolicy } = fromExternalConfig(
-    config?.options, // just in case config is missing somehow
+  const { terms, oracles, feeConfig, feedPolicy, ...net } = fromExternalConfig(
+    config.options,
     brands,
     FastUSDCConfigShape,
   );
@@ -177,6 +184,7 @@ export const startFastUSDC = async (
       chainStorage,
     },
   );
+  const poolMetricsNode = await E(storageNode).makeChildNode(POOL_METRICS);
 
   const privateArgs = await deeplyFulfilledObject(
     harden({
@@ -184,9 +192,12 @@ export const startFastUSDC = async (
       feeConfig,
       localchain,
       orchestrationService: cosmosInterchainService,
+      poolMetricsNode,
       storageNode,
       timerService,
       marshaller,
+      chainInfo: net.chainInfo,
+      assetInfo: net.assetInfo,
     }),
   );
 
@@ -203,13 +214,23 @@ export const startFastUSDC = async (
   await publishFeedPolicy(storageNode, feedPolicy);
 
   const {
-    issuers: { PoolShares: shareIssuer },
+    issuers: fastUsdcIssuers,
     brands: { PoolShares: shareBrand },
   } = await E(zoe).getTerms(instance);
+  /** @type {{ PoolShares: Issuer<'nat'> }} */
+  // @ts-expect-error see zcf.makeZCFMint(...) in fast-usdc.contract.js
+  const { PoolShares: shareIssuer } = fastUsdcIssuers;
   produceShareIssuer.resolve(shareIssuer);
   produceShareBrand.resolve(shareBrand);
   await publishDisplayInfo(shareBrand, { board, chainStorage });
 
+  const { denom, issuerName } = ShareAssetInfo;
+  trace('addAsset', denom, shareBrand);
+  await E(bankManager).addAsset(denom, issuerName, issuerName, {
+    issuer: shareIssuer,
+    brand: shareBrand,
+  });
+
   await Promise.all(
     Object.entries(oracleDepositFacets).map(async ([name, depositFacet]) => {
       const address = oracles[name];
@@ -223,6 +244,13 @@ export const startFastUSDC = async (
 
   produceInstance.reset();
   produceInstance.resolve(instance);
+
+  const addresses = await E(kit.creatorFacet).publishAddresses();
+  trace('contract orch account addresses', addresses);
+  if (!net.noNoble) {
+    const addr = await E(kit.creatorFacet).connectToNoble();
+    trace('noble intermediate recipient', addr);
+  }
   trace('startFastUSDC done', instance);
 };
 harden(startFastUSDC);
@@ -248,6 +276,8 @@ export const getManifestForFastUSDC = (
           fastUsdcKit: true,
         },
         consume: {
+          bankManager: true, // to add FastLP as vbank asset
+
           chainStorage: true,
           chainTimerService: true,
           localchain: true,