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

package/src/utils/config-marshal.js

@@ -0,0 +1,130 @@
+import { Fail } from '@endo/errors';
+import { makeMarshal } from '@endo/marshal';
+import { mustMatch } from '@endo/patterns';
+
+// TODO(#7309): move to make available beyond fast-usdc.
+
+/**
+ * @import {Marshal, CapData, Passable} from '@endo/marshal';
+ * @import { RemotableBrand } from '@endo/eventual-send';
+ * @import {TypedPattern} from '@agoric/internal'
+ */
+const { entries } = Object;
+
+/**
+ * To configure amounts such as terms or ratios,
+ * we need to refer to objects such as brands.
+ *
+ * If parties agree on names, any party that doesn't have
+ * an actual presence for an object can make one up:
+ *
+ * const remotes = { USDC: Far('USDC Brand') };
+ *
+ * and use it in local computation:
+ *
+ * const terms = { fee1: AmountMath.make(remotes.USDC, 1234n) }
+ *
+ * Then we can pass references across using marshal conventions, using
+ * the names as slots.
+ *
+ * @param {Record<string, Passable>} slotToVal a record that gives names to stand-ins for objects in another vat
+ * @returns {Marshal<string>}
+ */
+export const makeMarshalFromRecord = slotToVal => {
+  const convertSlotToVal = slot => {
+    slot in slotToVal || Fail`unknown slot ${slot}`;
+    return slotToVal[slot];
+  };
+  const valToSlot = new Map(entries(slotToVal).map(([k, v]) => [v, k]));
+  const convertValToSlot = v => {
+    valToSlot.has(v) || Fail`unknown value: ${v}`;
+    return valToSlot.get(v);
+  };
+  return makeMarshal(convertValToSlot, convertSlotToVal, {
+    serializeBodyFormat: 'smallcaps',
+  });
+};
+
+/**
+ * @typedef {`\$${number}${string}`} SmallCapsSlotRef
+ */
+
+/**
+ * @template T
+ * @typedef {{ [KeyType in keyof T]: T[KeyType] } & {}} Simplify flatten the
+ *   type output to improve type hints shown in editors
+ *   https://github.com/sindresorhus/type-fest/blob/main/source/simplify.d.ts
+ */
+
+/**
+ * @template T
+ * @template R
+ * @typedef {T extends R
+ *     ? SmallCapsSlotRef
+ *     : T extends {}
+ *       ? Simplify<SmallCapsStructureOf<T, R>>
+ *       : Awaited<T>} SmallCapsStructureOf
+ */
+
+/**
+ * The smallCaps body is a string, which simplifies some usage.
+ * But it's hard to read and write.
+ *
+ * The parsed structure makes a convenient notation for configuration etc.
+ *
+ * @template {Passable} [T=Passable]
+ * @template [R=RemotableBrand]
+ * @typedef {{
+ *   structure: SmallCapsStructureOf<T, R>;
+ *   slots: string[];
+ * }} LegibleCapData
+ */
+
+/**
+ * @template {Passable} [T=Passable]
+ * @template [R=RemotableBrand]
+ * @param {CapData<string>} capData
+ * @returns {LegibleCapData<T, R>}
+ */
+export const toLegible = ({ body, slots }) =>
+  harden({ structure: JSON.parse(body.replace(/^#/, '')), slots });
+
+/**
+ * @template {Passable} [T=Passable]
+ * @template [R=RemotableBrand]
+ * @param {LegibleCapData<T,R>} legible
+ * @returns {CapData<string>}
+ */
+export const fromLegible = ({ structure, slots }) =>
+  harden({ body: `#${JSON.stringify(structure)}`, slots });
+
+/**
+ * @template {Passable} [T=Passable]
+ * @template [R=RemotableBrand]
+ * @param {T} config
+ * @param {Record<string, Passable>} context
+ * @param {TypedPattern<T>} [shape]
+ * @returns {LegibleCapData<T,R>}
+ */
+export const toExternalConfig = (config, context, shape) => {
+  if (shape) {
+    mustMatch(config, shape);
+  }
+  return toLegible(makeMarshalFromRecord(context).toCapData(config));
+};
+
+/**
+ * @template {Passable} [T=Passable]
+ * @template [R=RemotableBrand]
+ * @param {LegibleCapData<T,R>} repr
+ * @param {Record<string, Passable>} context
+ * @param {TypedPattern<T>} [shape]
+ * @returns {T}
+ */
+export const fromExternalConfig = (repr, context, shape) => {
+  const config = makeMarshalFromRecord(context).fromCapData(fromLegible(repr));
+  if (shape) {
+    mustMatch(config, shape);
+  }
+  return config;
+};

package/src/utils/core-eval.js

@@ -0,0 +1,73 @@
+import { deeplyFulfilledObject, makeTracer, objectMap } from '@agoric/internal';
+import { Fail } from '@endo/errors';
+import { E } from '@endo/eventual-send';
+import { makeMarshal } from '@endo/marshal';
+
+const trace = makeTracer('FUCoreEval');
+
+/**
+ * @import {Brand, DepositFacet} from '@agoric/ertp';
+ * @import {FastUSDCKit} from '../start-fast-usdc.core.js'
+ * @import {FeedPolicy} from '../types.js'
+ */
+
+export const FEED_POLICY = 'feedPolicy';
+export const marshalData = makeMarshal(_val => Fail`data only`);
+
+/**
+ * @param {ERef<StorageNode>} node
+ * @param {FeedPolicy} policy
+ */
+export const publishFeedPolicy = async (node, policy) => {
+  const feedPolicy = E(node).makeChildNode(FEED_POLICY);
+  const value = marshalData.toCapData(policy);
+  await E(feedPolicy).setValue(JSON.stringify(value));
+};
+
+/**
+ * @param {object} powers
+ * @param {FastUSDCKit['creatorFacet']} powers.creatorFacet
+ * @param {BootstrapPowers['consume']['namesByAddress']} powers.namesByAddress
+ * @param {Record<string, string>} oracles
+ */
+export const inviteOracles = async (
+  { creatorFacet, namesByAddress },
+  oracles,
+) => {
+  const oracleDepositFacets = await deeplyFulfilledObject(
+    objectMap(
+      oracles,
+      /** @type {(address: string) => Promise<DepositFacet>} */
+      address => E(namesByAddress).lookup(address, 'depositFacet'),
+    ),
+  );
+  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);
+    }),
+  );
+};
+
+const BOARD_AUX = 'boardAux';
+/**
+ * @param {Brand} brand
+ * @param {Pick<BootstrapPowers['consume'], 'board' | 'chainStorage'>} powers
+ */
+export 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));
+};

package/src/utils/deploy-config.js

@@ -0,0 +1,127 @@
+import { denomHash, withChainCapabilities } from '@agoric/orchestration';
+import fetchedChainInfo from '@agoric/orchestration/src/fetched-chain-info.js';
+import { ChainPolicies } from './chain-policies.js';
+
+/**
+ * @import {FastUSDCConfig} from '@agoric/fast-usdc';
+ * @import {Passable} from '@endo/marshal';
+ * @import {CosmosChainInfo, Denom, DenomDetail} from '@agoric/orchestration';
+ */
+
+/** @type {[Denom, DenomDetail & { brandKey?: string}]} */
+const usdcOnAgoric = [
+  `ibc/${denomHash({ denom: 'uusdc', channelId: fetchedChainInfo.agoric.connections['noble-1'].transferChannel.channelId })}`,
+  {
+    baseName: 'noble',
+    chainName: 'agoric',
+    baseDenom: 'uusdc',
+    brandKey: 'USDC',
+  },
+];
+
+/** @type {[Denom, DenomDetail & { brandKey?: string}][]} */
+export const transferAssetInfo = [
+  ['uusdc', { baseName: 'noble', chainName: 'noble', baseDenom: 'uusdc' }],
+  usdcOnAgoric,
+];
+harden(transferAssetInfo);
+
+/** ABI for DepositForBurn event in TokenMessenger contract */
+const DepositForBurnEvent =
+  'DepositForBurn(uint64,address,uint256,address,bytes32,uint32,bytes32,bytes32)';
+
+/**
+ * @type {Record<string, Pick<FastUSDCConfig, 'oracles' | 'feedPolicy' | 'chainInfo' | 'assetInfo' >>}
+ *
+ * meanwhile, use price oracle addresses (from updatePriceFeeds.js).
+ */
+export const configurations = {
+  /**
+   * NOTE: The a3p-integration runtime does _not_ include
+   * a noble chain; this limits functionality to advancing
+   * to the Agoric chain.
+   */
+  A3P_INTEGRATION: {
+    oracles: {
+      gov1: 'agoric1ee9hr0jyrxhy999y755mp862ljgycmwyp4pl7q',
+      gov2: 'agoric1wrfh296eu2z34p6pah7q04jjuyj3mxu9v98277',
+      gov3: 'agoric1ydzxwh6f893jvpaslmaz6l8j2ulup9a7x8qvvq',
+    },
+    feedPolicy: {
+      nobleAgoricChannelId: 'channel-does-not-exist',
+      nobleDomainId: 4,
+      chainPolicies: ChainPolicies.TESTNET,
+      eventFilter: DepositForBurnEvent,
+    },
+    chainInfo: /** @type {Record<string, CosmosChainInfo & Passable>} */ (
+      withChainCapabilities({
+        agoric: fetchedChainInfo.agoric,
+        // registering USDC-on-agoric requires registering the noble chain
+        noble: fetchedChainInfo.noble,
+      })
+    ),
+    assetInfo: [usdcOnAgoric],
+  },
+  MAINNET: {
+    // per JVC 12 Feb 2025
+    oracles: {
+      '01node': 'agoric1ym488t6j24x3ys3va3452ftx44lhs64rz8pu7h',
+      SimplyStaking: 'agoric1s5yawjgj6xcw4ea5r2x4cjrnkprmd0fcun2tyk',
+      DSRV: 'agoric17crpkfxarq658e9ddru2petrfr0fhjzvjfccq9',
+    },
+    feedPolicy: {
+      nobleAgoricChannelId: 'channel-21',
+      nobleDomainId: 4,
+      chainPolicies: ChainPolicies.MAINNET,
+      eventFilter: DepositForBurnEvent,
+    },
+    chainInfo: /** @type {Record<string, CosmosChainInfo & Passable>} */ (
+      withChainCapabilities(fetchedChainInfo)
+    ),
+    assetInfo: transferAssetInfo,
+  },
+  DEVNET: {
+    oracles: {
+      DSRV: 'agoric1lw4e4aas9q84tq0q92j85rwjjjapf8dmnllnft',
+      Stakin: 'agoric1zj6vrrrjq4gsyr9lw7dplv4vyejg3p8j2urm82',
+      '01node': 'agoric1ra0g6crtsy6r3qnpu7ruvm7qd4wjnznyzg5nu4',
+      'Simply Staking': 'agoric1qj07c7vfk3knqdral0sej7fa6eavkdn8vd8etf',
+      P2P: 'agoric10vjkvkmpp9e356xeh6qqlhrny2htyzp8hf88fk',
+    },
+    feedPolicy: {
+      nobleAgoricChannelId: 'TODO',
+      nobleDomainId: 4,
+      chainPolicies: ChainPolicies.TESTNET,
+      eventFilter: DepositForBurnEvent,
+    },
+    chainInfo: /** @type {Record<string, CosmosChainInfo & Passable>} */ (
+      withChainCapabilities(fetchedChainInfo) // TODO: use devnet values
+    ),
+    assetInfo: transferAssetInfo,
+  },
+  EMERYNET: {
+    oracles: {
+      gov1: 'agoric1ldmtatp24qlllgxmrsjzcpe20fvlkp448zcuce',
+      gov2: 'agoric140dmkrz2e42ergjj7gyvejhzmjzurvqeq82ang',
+    },
+    feedPolicy: {
+      nobleAgoricChannelId: 'TODO',
+      nobleDomainId: 4,
+      chainPolicies: ChainPolicies.TESTNET,
+      eventFilter: DepositForBurnEvent,
+    },
+    chainInfo: /** @type {Record<string, CosmosChainInfo & Passable>} */ (
+      withChainCapabilities(fetchedChainInfo) // TODO: use emerynet values
+    ),
+    assetInfo: transferAssetInfo,
+  },
+};
+harden(configurations);
+
+// Constraints on the configurations
+const MAINNET_EXPECTED_ORACLES = 3;
+assert(
+  new Set(Object.values(configurations.MAINNET.oracles)).size ===
+    MAINNET_EXPECTED_ORACLES,
+  `Mainnet must have exactly ${MAINNET_EXPECTED_ORACLES} oracles`,
+);

package/src/utils/fees.js

@@ -1,142 +1,56 @@
 import { AmountMath } from '@agoric/ertp';
-import { multiplyBy } from '@agoric/ertp/src/ratio.js';
+import { multiplyBy } from '@agoric/zoe/src/contractSupport/ratio.js';
 import { Fail } from '@endo/errors';
 import { mustMatch } from '@endo/patterns';
-import { chainOfAccount } from '@agoric/orchestration/src/utils/address.js';
 import { FeeConfigShape } from '../type-guards.js';
 
-const { add, isGTE, subtract, makeEmpty } = AmountMath;
+const { add, isGTE, subtract } = AmountMath;
 
 /**
  * @import {Amount} from '@agoric/ertp';
- * @import {AccountId} from '@agoric/orchestration';
  * @import {FeeConfig} from '../types.js';
+ * @import {RepayAmountKWR} from '../exos/liquidity-pool.js';
  */
 
-/**
- * @typedef {{
- *  Principal: Amount<'nat'>;
- *  PoolFee: Amount<'nat'>;
- *  ContractFee: Amount<'nat'>;
- *  RelayFee: Amount<'nat'>;
- * }} RepayAmountKWR
- */
-
-/**
- * @typedef {{
- *  Principal: Payment<'nat'>;
- *  PoolFee: Payment<'nat'>;
- *  ContractFee: Payment<'nat'>;
- *  RelayFee: Payment<'nat'>;
- * }} RepayPaymentKWR
- */
-
-/**
- * @template {keyof Omit<FeeConfig, 'destinationOverrides'>} K
- * @param {FeeConfig} feeConfig
- * @param {K} key
- * @param {AccountId} destination
- * @returns {FeeConfig[K]}
- */
-const getConfigValue = (feeConfig, key, destination) => {
-  const chainId = chainOfAccount(destination);
-  if (
-    feeConfig.destinationOverrides?.[chainId] &&
-    feeConfig.destinationOverrides[chainId][key] !== undefined
-  ) {
-    return feeConfig.destinationOverrides[chainId][key];
-  }
-  return feeConfig[key];
-};
-
-/**
- * @param {FeeConfig} feeConfig
- */
+/** @param {FeeConfig} feeConfig */
 export const makeFeeTools = feeConfig => {
   mustMatch(feeConfig, FeeConfigShape, 'Must provide feeConfig');
-  const emptyAmount = makeEmpty(feeConfig.flat.brand);
-
+  const { flat, variableRate } = feeConfig;
   const feeTools = harden({
     /**
-     * Calculate the base fee to charge for the advance (variable + flat).
-     * Will be shared between the pool and the contract based on
-     * {@link FeeConfig.contractRate}.
+     * Calculate the net amount to advance after withholding fees.
      *
      * @param {Amount<'nat'>} requested
-     * @param {AccountId} destination
-     * @returns {Amount<'nat'>}
-     */
-    calculateBaseFee(requested, destination) {
-      const flat = getConfigValue(feeConfig, 'flat', destination);
-      const variableRate = getConfigValue(
-        feeConfig,
-        'variableRate',
-        destination,
-      );
-      return add(multiplyBy(requested, variableRate), flat);
-    },
-    /**
-     * Calculate the optional relay fee charged for certain destinations.
-     * Only disbursed to contract seat.
-     *
-     * @param {AccountId} destination
-     * @returns {Amount<'nat'>}
+     * @throws {Error} if requested does not exceed fees
      */
-    calculateRelayFee(destination) {
-      const relay = getConfigValue(feeConfig, 'relay', destination);
-      return relay || emptyAmount;
+    calculateAdvance(requested) {
+      const fee = feeTools.calculateAdvanceFee(requested);
+      return subtract(requested, fee);
     },
     /**
      * Calculate the total fee to charge for the advance.
      *
      * @param {Amount<'nat'>} requested
-     * @param {AccountId} destination
      * @throws {Error} if requested does not exceed fees
      */
-    calculateAdvanceFee(requested, destination) {
-      const baseFee = feeTools.calculateBaseFee(requested, destination);
-      const relayFee = feeTools.calculateRelayFee(destination);
-      const fee = add(baseFee, relayFee);
+    calculateAdvanceFee(requested) {
+      const fee = add(multiplyBy(requested, variableRate), flat);
       !isGTE(fee, requested) || Fail`Request must exceed fees.`;
       return fee;
     },
-    /**
-     * Calculate the net amount to advance after withholding fees.
-     *
-     * @param {Amount<'nat'>} requested
-     * @param {AccountId} destination
-     * @throws {Error} if requested does not exceed fees
-     */
-    calculateAdvance(requested, destination) {
-      const fee = feeTools.calculateAdvanceFee(requested, destination);
-      return subtract(requested, fee);
-    },
     /**
      * Calculate the split of fees between pool and contract.
      *
-     * The `ContractFee` includes base fees plus the relay fee.
-     *
      * @param {Amount<'nat'>} requested
-     * @param {AccountId} destination
      * @returns {RepayAmountKWR} an {@link AmountKeywordRecord}
      * @throws {Error} if requested does not exceed fees
      */
-    calculateSplit(requested, destination) {
-      const baseFee = feeTools.calculateBaseFee(requested, destination);
-      const relayFee = feeTools.calculateRelayFee(destination);
-      const totalFee = add(baseFee, relayFee);
-      !isGTE(totalFee, requested) || Fail`Request must exceed fees.`;
-
-      const contractRate = getConfigValue(
-        feeConfig,
-        'contractRate',
-        destination,
-      );
-      const Principal = subtract(requested, totalFee);
-      const ContractFee = multiplyBy(baseFee, contractRate);
-      const PoolFee = subtract(baseFee, ContractFee);
-
-      return harden({ Principal, PoolFee, ContractFee, RelayFee: relayFee });
+    calculateSplit(requested) {
+      const fee = feeTools.calculateAdvanceFee(requested);
+      const Principal = subtract(requested, fee);
+      const ContractFee = multiplyBy(fee, feeConfig.contractRate);
+      const PoolFee = subtract(fee, ContractFee);
+      return harden({ Principal, PoolFee, ContractFee });
     },
   });
   return feeTools;

package/src/utils/zoe.js

@@ -0,0 +1,28 @@
+import { makeTracer } from '@agoric/internal';
+
+const trace = makeTracer('ZoeUtils');
+
+/**
+ * Used for "continuing offer" invitations in which the caller does not need
+ * anything in return. In those cases there is no Zoe offer safety and the
+ * invitation making function can perform the request itself.
+ *
+ * But smart-wallet expects an invitation maker to make an invitation, so this
+ * function abstracts making such an inert invitation and logs consistently when
+ * it is used.
+ *
+ * When this is used by an invitation maker that performs the operation, receiving
+ * one of these invitations is evidence that the operation took place.
+ *
+ * @param {ZCF} zcf
+ * @param {string} description @see {@link ZCF.makeInvitation}
+ * @returns {() => Promise<Invitation>} an arg-less invitation maker
+ */
+export const defineInertInvitation = (zcf, description) => {
+  return () =>
+    zcf.makeInvitation(seat => {
+      trace(`ℹ️ An offer was made on an inert invitation for ${description}`);
+      seat.exit();
+      return 'inert; nothing should be expected from this offer';
+    }, description);
+};

package/src/operator-kit-interface.js

@@ -1,29 +0,0 @@
-import { M } from '@endo/patterns';
-import { CctpTxEvidenceShape, RiskAssessmentShape } from './type-guards.js';
-
-/**
- * @import {Zone} from '@agoric/zone';
- * @import {CctpTxEvidence, RiskAssessment} from '@agoric/fast-usdc/src/types.js';
- */
-
-/** Name in the invitation purse (keyed also by this contract instance) */
-export const INVITATION_MAKERS_DESC = 'oracle operator invitation';
-
-export const OperatorKitI = {
-  admin: M.interface('Admin', {
-    disable: M.call().returns(),
-  }),
-
-  invitationMakers: M.interface('InvitationMakers', {
-    SubmitEvidence: M.call(CctpTxEvidenceShape)
-      .optional(RiskAssessmentShape)
-      .returns(M.promise()),
-  }),
-
-  operator: M.interface('Operator', {
-    submitEvidence: M.call(CctpTxEvidenceShape)
-      .optional(RiskAssessmentShape)
-      .returns(),
-    getStatus: M.call().returns(M.record()),
-  }),
-};