@agoric/fast-usdc 0.2.0-u19.1 → 0.2.0-u20.0

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

@@ -1,65 +0,0 @@
-/** @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

@@ -1,316 +0,0 @@
-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

@@ -1,23 +0,0 @@
-/**
- * @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/start-fast-usdc.core.js

@@ -1,246 +0,0 @@
-import { deeplyFulfilledObject, makeTracer } from '@agoric/internal';
-import { E } from '@endo/far';
-import { FastUSDCConfigShape } from './type-guards.js';
-import { fromExternalConfig } from './utils/config-marshal.js';
-import {
-  inviteOracles,
-  publishDisplayInfo,
-  publishFeedPolicy,
-} from './utils/core-eval.js';
-
-/**
- * @import {Brand, Issuer} from '@agoric/ertp';
- * @import {Instance, StartParams} from '@agoric/zoe/src/zoeService/utils'
- * @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 {LegibleCapData} from './utils/config-marshal.js'
- * @import {FastUsdcSF} from './fast-usdc.contract.js'
- * @import {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';
-
-/**
- * XXX Shouldn't the bridge or board vat handle this?
- *
- * @param {string} path
- * @param {{
- *   chainStorage: ERef<StorageNode>;
- *   board: ERef<Board>;
- * }} io
- */
-const makePublishingStorageKit = async (path, { chainStorage, board }) => {
-  const storageNode = await E(chainStorage).makeChildNode(path);
-
-  const marshaller = await E(board).getPublishingMarshaller();
-  return { storageNode, marshaller };
-};
-
-const POOL_METRICS = 'poolMetrics';
-
-/**
- * @typedef { PromiseSpaceOf<{
- *   fastUsdcKit: FastUSDCKit
- *  }> & {
- *   installation: PromiseSpaceOf<{ fastUsdc: Installation<FastUsdcSF> }>;
- *   instance: PromiseSpaceOf<{ fastUsdc: Instance<FastUsdcSF> }>;
- *   issuer: PromiseSpaceOf<{ FastLP: Issuer }>;
- *   brand: PromiseSpaceOf<{ FastLP: Brand }>;
- * }} FastUSDCCorePowers
- *
- * @typedef {StartedInstanceKitWithLabel & {
- *   creatorFacet: StartedInstanceKit<FastUsdcSF>['creatorFacet'];
- *   privateArgs: StartParams<FastUsdcSF>['privateArgs'];
- * }} FastUSDCKit
- */
-
-/**
- * @throws if oracle smart wallets are not yet provisioned
- *
- * @param {BootstrapPowers & FastUSDCCorePowers } powers
- * @param {{ options: LegibleCapData<FastUSDCConfig> }} config
- */
-export const startFastUSDC = async (
-  {
-    produce: { fastUsdcKit },
-    consume: {
-      agoricNames,
-      namesByAddress,
-      bankManager,
-      board,
-      chainStorage,
-      chainTimerService: timerService,
-      localchain,
-      cosmosInterchainService,
-      startUpgradable,
-      zoe,
-    },
-    issuer: {
-      produce: { FastLP: produceShareIssuer },
-    },
-    brand: {
-      produce: { FastLP: produceShareBrand },
-    },
-    installation: {
-      consume: { fastUsdc },
-    },
-    instance: {
-      produce: { fastUsdc: produceInstance },
-    },
-  },
-  config,
-) => {
-  trace('startFastUSDC');
-
-  await null;
-  /** @type {Issuer<'nat'>} */
-  const USDCissuer = await E(agoricNames).lookup('issuer', 'USDC');
-  const brands = harden({
-    USDC: await E(USDCissuer).getBrand(),
-  });
-
-  const { terms, oracles, feeConfig, feedPolicy, ...net } = fromExternalConfig(
-    config.options,
-    brands,
-    FastUSDCConfigShape,
-  );
-  trace('using terms', terms);
-  trace('using fee config', feeConfig);
-
-  const { storageNode, marshaller } = await makePublishingStorageKit(
-    contractName,
-    {
-      board,
-      // @ts-expect-error Promise<null> case is vestigial
-      chainStorage,
-    },
-  );
-  const poolMetricsNode = await E(storageNode).makeChildNode(POOL_METRICS);
-
-  const privateArgs = await deeplyFulfilledObject(
-    harden({
-      agoricNames,
-      feeConfig,
-      localchain,
-      orchestrationService: cosmosInterchainService,
-      poolMetricsNode,
-      storageNode,
-      timerService,
-      marshaller,
-      chainInfo: net.chainInfo,
-      assetInfo: net.assetInfo,
-    }),
-  );
-
-  const kit = await E(startUpgradable)({
-    label: contractName,
-    installation: fastUsdc,
-    issuerKeywordRecord: harden({ USDC: USDCissuer }),
-    terms,
-    privateArgs,
-  });
-  fastUsdcKit.resolve(harden({ ...kit, privateArgs }));
-  const { instance, creatorFacet } = kit;
-
-  await publishFeedPolicy(storageNode, feedPolicy);
-
-  const {
-    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 inviteOracles({ creatorFacet, namesByAddress }, oracles);
-
-  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);
-
-/**
- * @param {{
- *   restoreRef: (b: ERef<ManifestBundleRef>) => Promise<Installation>;
- * }} utils
- * @param {{
- *   installKeys: { fastUsdc: ERef<ManifestBundleRef> };
- *   options: LegibleCapData<FastUSDCConfig>;
- * }} param1
- */
-export const getManifestForFastUSDC = (
-  { restoreRef },
-  { installKeys, options },
-) => {
-  return {
-    /** @type {BootstrapManifest} */
-    manifest: {
-      [startFastUSDC.name]: {
-        produce: {
-          fastUsdcKit: true,
-        },
-        consume: {
-          bankManager: true, // to add FastLP as vbank asset
-
-          chainStorage: true,
-          chainTimerService: true,
-          localchain: true,
-          cosmosInterchainService: true,
-
-          // limited distribution durin MN2: contract installation
-          startUpgradable: true,
-          zoe: true, // only getTerms() is needed. XXX should be split?
-
-          // widely shared: name services
-          agoricNames: true,
-          namesByAddress: true,
-          board: true,
-        },
-        issuer: {
-          produce: { FastLP: true },
-        },
-        brand: {
-          produce: { FastLP: true },
-        },
-        instance: {
-          produce: { fastUsdc: true },
-        },
-        installation: {
-          consume: { fastUsdc: true },
-        },
-      },
-    },
-    installations: {
-      fastUsdc: restoreRef(installKeys.fastUsdc),
-    },
-    options,
-  };
-};