@agoric/fast-usdc 0.1.1-other-dev-3eb1a1d.0 → 0.1.1-upgrade-19-dev-c605745.0

package/src/utils/chain-policies.js

@@ -0,0 +1,140 @@
+/** @import {ChainPolicy} from '../types.js'; */
+
+/** @satisfies {Record<'MAINNET'| 'TESTNET', Record<string, ChainPolicy>>} */
+export const ChainPolicies = /** @type {const} */ ({
+  MAINNET: {
+    Arbitrum: {
+      attenuatedCttpBridgeAddresses: [
+        '0xe298b93ffB5eA1FB628e0C0D55A43aeaC268e347',
+      ],
+      cctpTokenMessengerAddress: '0x19330d10D9Cc8751218eaf51E8885D058642E08A',
+      chainId: 42161,
+      // TODO confirm confirmations and rateLimits
+      confirmations: 2,
+      rateLimits: {
+        blockWindow: 20_000_000_000n,
+        blockWindowSize: 10,
+        tx: 10_000_000_000n,
+      },
+    },
+    Base: {
+      attenuatedCttpBridgeAddresses: [
+        '0xB6615B2662b35fc3533F8479002e62D0523341De',
+      ],
+      cctpTokenMessengerAddress: '0x1682Ae6375C4E4A97e4B583BC394c861A46D8962',
+      chainId: 8453,
+      // TODO confirm confirmations and rateLimits
+      confirmations: 2,
+      rateLimits: {
+        blockWindow: 20_000_000_000n,
+        blockWindowSize: 10,
+        tx: 10_000_000_000n,
+      },
+    },
+    Ethereum: {
+      attenuatedCttpBridgeAddresses: [
+        '0xBC8552339dA68EB65C8b88B414B5854E0E366cFc',
+      ],
+      cctpTokenMessengerAddress: '0xBd3fa81B58Ba92a82136038B25aDec7066af3155',
+      chainId: 1,
+      // TODO confirm confirmations and rateLimits
+      confirmations: 2,
+      rateLimits: {
+        blockWindow: 20_000_000_000n,
+        blockWindowSize: 10,
+        tx: 10_000_000_000n,
+      },
+    },
+    Optimism: {
+      attenuatedCttpBridgeAddresses: [
+        '0x48C5417ED570928eC85D5e3AD4e7E0EeD7dB1E2A',
+      ],
+      cctpTokenMessengerAddress: '0x2B4069517957735bE00ceE0fadAE88a26365528f',
+      chainId: 10,
+      // TODO confirm confirmations and rateLimits
+      confirmations: 2,
+      rateLimits: {
+        blockWindow: 20_000_000_000n,
+        blockWindowSize: 10,
+        tx: 10_000_000_000n,
+      },
+    },
+    Polygon: {
+      attenuatedCttpBridgeAddresses: [
+        '0x32cb9574650AFF312c80edc4B4343Ff5500767cA',
+      ],
+      cctpTokenMessengerAddress: '0x9daF8c91AEFAE50b9c0E69629D3F6Ca40cA3B3FE',
+      chainId: 137,
+      // TODO confirm confirmations and rateLimits
+      confirmations: 2,
+      rateLimits: {
+        blockWindow: 20_000_000_000n,
+        blockWindowSize: 10,
+        tx: 10_000_000_000n,
+      },
+    },
+  },
+  TESTNET: {
+    // Arbitrum Sepolia
+    Arbitrum: {
+      attenuatedCttpBridgeAddresses: ['0xTODO'],
+      cctpTokenMessengerAddress: '0x9f3B8679c73C2Fef8b59B4f3444d4e156fb70AA5',
+      chainId: 421614,
+      confirmations: 2,
+      rateLimits: {
+        blockWindow: 20_000_000_000n,
+        blockWindowSize: 10,
+        tx: 10_000_000_000n,
+      },
+    },
+    // Base Sepolia
+    Base: {
+      attenuatedCttpBridgeAddresses: ['0xTODO'],
+      cctpTokenMessengerAddress: '0x9f3B8679c73C2Fef8b59B4f3444d4e156fb70AA5',
+      chainId: 84532,
+      confirmations: 2,
+      rateLimits: {
+        blockWindow: 20_000_000_000n,
+        blockWindowSize: 10,
+        tx: 10_000_000_000n,
+      },
+    },
+    // Ethereum Sepolia
+    Ethereum: {
+      attenuatedCttpBridgeAddresses: ['0xTODO'],
+      cctpTokenMessengerAddress: '0x9f3B8679c73C2Fef8b59B4f3444d4e156fb70AA5',
+      chainId: 11155111,
+      confirmations: 2,
+      rateLimits: {
+        blockWindow: 20_000_000_000n,
+        blockWindowSize: 10,
+        tx: 10_000_000_000n,
+      },
+    },
+    // OP Sepolia
+    Optimism: {
+      attenuatedCttpBridgeAddresses: ['0xTODO'],
+      cctpTokenMessengerAddress: '0x9f3B8679c73C2Fef8b59B4f3444d4e156fb70AA5',
+      chainId: 11155420,
+      confirmations: 2,
+      rateLimits: {
+        blockWindow: 20_000_000_000n,
+        blockWindowSize: 10,
+        tx: 10_000_000_000n,
+      },
+    },
+    // Polygon PoS Amoy
+    Polygon: {
+      attenuatedCttpBridgeAddresses: ['0xTODO'],
+      cctpTokenMessengerAddress: '0x9f3B8679c73C2Fef8b59B4f3444d4e156fb70AA5',
+      chainId: 80002,
+      confirmations: 2,
+      rateLimits: {
+        blockWindow: 20_000_000_000n,
+        blockWindowSize: 10,
+        tx: 10_000_000_000n,
+      },
+    },
+  },
+});
+harden(ChainPolicies);

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

@@ -4,7 +4,7 @@ import { Fail } from '@endo/errors';
 import { mustMatch } from '@endo/patterns';
 import { FeeConfigShape } from '../type-guards.js';
 
-const { add, isGTE, min, subtract } = AmountMath;
+const { add, isGTE, subtract } = AmountMath;
 
 /**
  * @import {Amount} from '@agoric/ertp';
@@ -15,7 +15,7 @@ const { add, isGTE, min, subtract } = AmountMath;
 /** @param {FeeConfig} feeConfig */
 export const makeFeeTools = feeConfig => {
   mustMatch(feeConfig, FeeConfigShape, 'Must provide feeConfig');
-  const { flat, variableRate, maxVariable } = feeConfig;
+  const { flat, variableRate } = feeConfig;
   const feeTools = harden({
     /**
      * Calculate the net amount to advance after withholding fees.
@@ -34,8 +34,7 @@ export const makeFeeTools = feeConfig => {
      * @throws {Error} if requested does not exceed fees
      */
     calculateAdvanceFee(requested) {
-      const variable = min(multiplyBy(requested, variableRate), maxVariable);
-      const fee = add(variable, flat);
+      const fee = add(multiplyBy(requested, variableRate), flat);
       !isGTE(fee, requested) || Fail`Request must exceed fees.`;
       return fee;
     },

package/tools/cli-tools.ts

@@ -0,0 +1,9 @@
+export const flags = (
+  record: Record<string, string | number | bigint | undefined>,
+): string[] => {
+  // @ts-expect-error undefined is filtered out
+  const skipUndef: [string, string][] = Object.entries(record).filter(
+    ([_k, v]) => v !== undefined,
+  );
+  return skipUndef.map(([k, v]) => [`--${k}`, `${v}`]).flat();
+};

package/tools/mock-io.ts

@@ -0,0 +1,14 @@
+import type { Writable } from 'node:stream';
+
+/**
+ * mock stdout / stderr, for example
+ *
+ * @param buf - caller-provided buffer for written data
+ */
+export const mockStream = <T extends Writable>(buf: string[]): T =>
+  ({
+    write: txt => {
+      buf.push(txt);
+      return true;
+    },
+  }) as T;

package/src/exos/README.md

@@ -1,26 +0,0 @@
-##   **StatusManager** state diagram, showing different transitions
-
-
-### Contract state diagram
-
-*Transactions are qualified by the OCW and EventFeed before arriving to the Advancer.*
-
-```mermaid
-stateDiagram-v2
-  [*] --> Advanced: Advancer .advance()
-  Advanced --> Settled: Settler .settle() after fees
-  [*] --> Observed: Advancer .observed()
-  Observed --> Settled: Settler .settle() sans fees
-  Settled --> [*]
-```
-
-### Complete state diagram (starting from OCW)
-
-```mermaid
-stateDiagram-v2
-  Observed --> Qualified
-  Observed --> Unqualified
-  Qualified --> Advanced
-  Advanced --> Settled
-  Qualified --> Settled
-```

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;
-  },
-};