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

package/src/fast-usdc.contract.js

@@ -1,235 +0,0 @@
-import { AssetKind } from '@agoric/ertp';
-import {
-  assertAllDefined,
-  deeplyFulfilledObject,
-  makeTracer,
-} from '@agoric/internal';
-import { observeIteration, subscribeEach } from '@agoric/notifier';
-import {
-  OrchestrationPowersShape,
-  withOrchestration,
-} from '@agoric/orchestration';
-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 { E } from '@endo/far';
-import { M, objectMap } 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';
-
-const trace = makeTracer('FastUsdc');
-
-/**
- * @import {Denom} from '@agoric/orchestration';
- * @import {HostInterface} from '@agoric/async-flow';
- * @import {OrchestrationAccount} from '@agoric/orchestration';
- * @import {OrchestrationPowers, OrchestrationTools} from '@agoric/orchestration/src/utils/start-helper.js';
- * @import {Vow} from '@agoric/vow';
- * @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';
- */
-
-/**
- * @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,
-    feeConfig: FeeConfigShape,
-    marshaller: M.remotable(),
-  },
-};
-harden(meta);
-
-/**
- * @param {ZCF<FastUsdcTerms>} zcf
- * @param {OrchestrationPowers & {
- *   marshaller: Marshaller;
- *   feeConfig: FeeConfig;
- * }} 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 } = privateArgs;
-  const { makeRecorderKit } = prepareRecorderKitMakers(
-    zone.mapStore('vstorage'),
-    marshaller,
-  );
-  const statusManager = prepareStatusManager(zone);
-  const makeSettler = prepareSettler(zone, { statusManager });
-  const { chainHub, orchestrateAll, vowTools } = tools;
-  const { localTransfer } = makeZoeTools(zcf, vowTools);
-  const makeAdvancer = prepareAdvancer(zone, {
-    chainHub,
-    feeConfig,
-    localTransfer,
-    usdc: harden({
-      brand: terms.brands.USDC,
-      denom: terms.usdcDenom,
-    }),
-    statusManager,
-    vowTools,
-    zcf,
-  });
-  const makeFeedKit = prepareTransactionFeedKit(zone, zcf);
-  assertAllDefined({ makeFeedKit, makeAdvancer, makeSettler, statusManager });
-  const makeLiquidityPoolKit = prepareLiquidityPoolKit(
-    zone,
-    zcf,
-    terms.brands.USDC,
-    { makeRecorderKit },
-  );
-
-  const makeTestInvitation = defineInertInvitation(
-    zcf,
-    'test of forcing evidence',
-  );
-
-  const { makeLocalAccount } = 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();
-    },
-    /**
-     *
-     * @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,
-      );
-      poolKit.repayer.repay(tmpAssetManagerSeat, amounts);
-      return tmpAssetManagerSeat.getCurrentAllocation();
-    },
-  });
-
-  const publicFacet = zone.exo('Fast USDC Public', undefined, {
-    // XXX to be removed before production
-    /**
-     * NB: Any caller with access to this invitation maker has the ability to
-     * force handling of evidence.
-     *
-     * Provide an API call in the form of an invitation maker, so that the
-     * capability is available in the smart-wallet bridge during UI testing.
-     *
-     * @param {CctpTxEvidence} evidence
-     */
-    makeTestPushInvitation(evidence) {
-      // eslint-disable-next-line no-use-before-define
-      void advancer.handleTransactionEvent(evidence);
-      return makeTestInvitation();
-    },
-    makeDepositInvitation() {
-      return poolKit.public.makeDepositInvitation();
-    },
-    makeWithdrawInvitation() {
-      return poolKit.public.makeWithdrawInvitation();
-    },
-    getPublicTopics() {
-      return poolKit.public.getPublicTopics();
-    },
-  });
-
-  // ^^^ 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.
-
-  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.storageNode),
-  );
-
-  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 advancer = zone.makeOnce('Advancer', () =>
-    makeAdvancer({
-      borrowerFacet: poolKit.borrower,
-      poolAccount,
-    }),
-  );
-  // Connect evidence stream to advancer
-  void observeIteration(subscribeEach(feedKit.public.getEvidenceSubscriber()), {
-    updateState(evidence) {
-      try {
-        void advancer.handleTransactionEvent(evidence);
-      } catch (err) {
-        trace('🚨 Error handling transaction event', err);
-      }
-    },
-  });
-
-  return harden({ creatorFacet, publicFacet });
-};
-harden(contract);
-
-export const start = withOrchestration(contract);
-harden(start);
-/** @typedef {typeof start} FastUsdcSF */

package/src/fast-usdc.flows.js

@@ -1,13 +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);

package/src/fast-usdc.start.js

@@ -1,284 +0,0 @@
-import { deeplyFulfilledObject, makeTracer, objectMap } from '@agoric/internal';
-import { Fail } from '@endo/errors';
-import { E } from '@endo/far';
-import { makeMarshal } from '@endo/marshal';
-import { M } from '@endo/patterns';
-import {
-  FastUSDCTermsShape,
-  FeeConfigShape,
-  FeedPolicyShape,
-} from './type-guards.js';
-import { fromExternalConfig } from './utils/config-marshal.js';
-
-/**
- * @import {DepositFacet} from '@agoric/ertp/src/types.js'
- * @import {TypedPattern} from '@agoric/internal'
- * @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 {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'
- */
-
-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,
-});
-
-/**
- * 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 BOARD_AUX = 'boardAux';
-const marshalData = makeMarshal(_val => Fail`data only`);
-/**
- * @param {Brand} brand
- * @param {Pick<BootstrapPowers['consume'], 'board' | 'chainStorage'>} powers
- */
-const publishDisplayInfo = async (brand, { board, chainStorage }) => {
-  // chainStorage type includes undefined, which doesn't apply here.
-  // @ts-expect-error UNTIL https://github.com/Agoric/agoric-sdk/issues/8247
-  const boardAux = E(chainStorage).makeChildNode(BOARD_AUX);
-  const [id, displayInfo, allegedName] = await Promise.all([
-    E(board).getId(brand),
-    E(brand).getDisplayInfo(),
-    E(brand).getAllegedName(),
-  ]);
-  const node = E(boardAux).makeChildNode(id);
-  const aux = marshalData.toCapData(harden({ allegedName, displayInfo }));
-  await E(node).setValue(JSON.stringify(aux));
-};
-
-const FEED_POLICY = 'feedPolicy';
-
-/**
- * @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));
-};
-
-/**
- * @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 & {
- *   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,
-      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 } = fromExternalConfig(
-    config?.options, // just in case config is missing somehow
-    brands,
-    FastUSDCConfigShape,
-  );
-  trace('using terms', terms);
-  trace('using fee config', feeConfig);
-
-  trace('look up oracle deposit facets');
-  const oracleDepositFacets = await deeplyFulfilledObject(
-    objectMap(oracles, async address => {
-      /** @type {DepositFacet} */
-      const depositFacet = await E(namesByAddress).lookup(
-        address,
-        'depositFacet',
-      );
-      return depositFacet;
-    }),
-  );
-
-  const { storageNode, marshaller } = await makePublishingStorageKit(
-    contractName,
-    {
-      board,
-      // @ts-expect-error Promise<null> case is vestigial
-      chainStorage,
-    },
-  );
-
-  const privateArgs = await deeplyFulfilledObject(
-    harden({
-      agoricNames,
-      feeConfig,
-      localchain,
-      orchestrationService: cosmosInterchainService,
-      storageNode,
-      timerService,
-      marshaller,
-    }),
-  );
-
-  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: { PoolShares: shareIssuer },
-    brands: { PoolShares: shareBrand },
-  } = await E(zoe).getTerms(instance);
-  produceShareIssuer.resolve(shareIssuer);
-  produceShareBrand.resolve(shareBrand);
-  await publishDisplayInfo(shareBrand, { board, chainStorage });
-
-  await Promise.all(
-    Object.entries(oracleDepositFacets).map(async ([name, depositFacet]) => {
-      const address = oracles[name];
-      trace('making invitation for', name, address);
-      const toWatch = await E(creatorFacet).makeOperatorInvitation(address);
-
-      const amt = await E(depositFacet).receive(toWatch);
-      trace('sent', amt, 'to', name);
-    }),
-  );
-
-  produceInstance.reset();
-  produceInstance.resolve(instance);
-  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: {
-          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 }, // UNTIL #10432
-        },
-        brand: {
-          produce: { FastLP: true }, // UNTIL #10432
-        },
-        instance: {
-          produce: { fastUsdc: true },
-        },
-        installation: {
-          consume: { fastUsdc: true },
-        },
-      },
-    },
-    installations: {
-      fastUsdc: restoreRef(installKeys.fastUsdc),
-    },
-    options,
-  };
-};

package/src/util/agoric.js

@@ -1,12 +0,0 @@
-/** @import { VStorage } from '@agoric/client-utils' */
-
-export const queryFastUSDCLocalChainAccount = async (
-  /** @type {VStorage} */ vstorage,
-  out = console,
-) => {
-  const agoricAddr = await vstorage.readLatest(
-    'published.fastUSDC.settlementAccount',
-  );
-  out.log(`Got Fast USDC Local Chain Account ${agoricAddr}`);
-  return agoricAddr;
-};

package/src/utils/address.js

@@ -1,71 +0,0 @@
-import { makeError, q } from '@endo/errors';
-import { M, mustMatch } from '@endo/patterns';
-
-/**
- * @import {Pattern} from '@endo/patterns';
- */
-
-/**
- * Default pattern matcher for `getQueryParams`.
- * Does not assert keys exist, but ensures existing keys are strings.
- */
-const QueryParamsShape = M.splitRecord(
-  {},
-  {},
-  M.recordOf(M.string(), M.string()),
-);
-
-/**
- * Very minimal 'URL query string'-like parser that handles:
- *  - Query string delimiter (?)
- *  - Key-value separator (=)
- *  - Query parameter separator (&)
- *
- * Does not handle:
- * - Subpaths (`agoric1bech32addr/opt/account?k=v`)
- * - URI encoding/decoding (`%20` -> ` `)
- *    - note: `decodeURIComponent` seems to be available in XS
- * - Multiple question marks (foo?bar=1?baz=2)
- * - Empty parameters (foo=)
- * - Array parameters (`foo?k=v1&k=v2` -> k: [v1, v2])
- * - Parameters without values (foo&bar=2)
- */
-export const addressTools = {
-  /**
-   * @param {string} address
-   * @returns {boolean}
-   */
-  hasQueryParams: address => {
-    try {
-      const params = addressTools.getQueryParams(address);
-      return Object.keys(params).length > 0;
-    } catch {
-      return false;
-    }
-  },
-  /**
-   * @param {string} address
-   * @param {Pattern} [shape]
-   * @returns {Record<string, string>}
-   * @throws {Error} if the address cannot be parsed or params do not match `shape`
-   */
-  getQueryParams: (address, shape = QueryParamsShape) => {
-    const parts = address.split('?');
-    if (parts.length !== 2) {
-      throw makeError(`Unable to parse query params: ${q(address)}`);
-    }
-    /** @type {Record<string, string>} */
-    const result = {};
-    const paramPairs = parts[1].split('&');
-    for (const pair of paramPairs) {
-      const [key, value] = pair.split('=');
-      if (!key || !value) {
-        throw makeError(`Invalid parameter format in pair: ${q(pair)}`);
-      }
-      result[key] = value;
-    }
-    harden(result);
-    mustMatch(result, shape);
-    return result;
-  },
-};