@agoric/fast-usdc 0.2.0-u19.2 → 0.2.0-u21.0

package/src/type-guards.js

@@ -1,7 +1,6 @@
 import { AmountShape, BrandShape, RatioShape } from '@agoric/ertp';
 import { M } from '@endo/patterns';
 import {
-  CosmosChainInfoShape,
   DenomDetailShape,
   DenomShape,
 } from '@agoric/orchestration/src/typeGuards.js';
@@ -10,13 +9,13 @@ import { PendingTxStatus } from './constants.js';
 /**
  * @import {Amount, Brand, NatValue, Payment} from '@agoric/ertp';
  * @import {TypedPattern} from '@agoric/internal';
- * @import {FastUsdcTerms} from './fast-usdc.contract.js';
+ * @import {CosmosChainInfo, Denom, DenomDetail, OrchestrationAccount, IBCConnectionInfo, CaipChainId} from '@agoric/orchestration';
  * @import {USDCProposalShapes} from './pool-share-math.js';
- * @import {CctpTxEvidence, FastUSDCConfig, FeeConfig, PendingTx, PoolMetrics, ChainPolicy, FeedPolicy, AddressHook, EvmAddress, EvmHash, RiskAssessment, EvidenceWithRisk} from './types.js';
+ * @import {CctpTxEvidence, FastUSDCConfig, FastUsdcTerms, FeeConfig, PendingTx, PoolMetrics, ChainPolicy, FeedPolicy, AddressHook, EvmAddress, EvmHash, RiskAssessment, EvidenceWithRisk} from './types.js';
  */
 
 /**
- * @param {Brand} brand must be a 'nat' brand, not checked
+ * @param {Brand<'nat'>} brand must be a 'nat' brand, not checked
  * @param {NatValue} [min]
  */
 export const makeNatAmountShape = (brand, min) =>
@@ -110,13 +109,34 @@ export const AddressHookShape = {
 harden(AddressHookShape);
 
 const NatAmountShape = { brand: BrandShape, value: M.nat() };
+
+/** @type {TypedPattern<FeeConfig['destinationOverrides']>} */
+export const DestinationOverridesShape = M.recordOf(
+  M.string(),
+  M.splitRecord(
+    {},
+    {
+      flat: NatAmountShape,
+      variableRate: RatioShape,
+      contractRate: RatioShape,
+      relay: NatAmountShape,
+    },
+  ),
+);
+
 /** @type {TypedPattern<FeeConfig>} */
-export const FeeConfigShape = {
-  flat: NatAmountShape,
-  variableRate: RatioShape,
-  contractRate: RatioShape,
-};
-harden(FeeConfigShape);
+export const FeeConfigShape = M.splitRecord(
+  {
+    flat: NatAmountShape,
+    variableRate: RatioShape,
+    contractRate: RatioShape,
+  },
+  {
+    relay: NatAmountShape,
+    destinationOverrides: DestinationOverridesShape,
+  },
+  {},
+);
 
 /** @type {TypedPattern<PoolMetrics>} */
 export const PoolMetricsShape = {
@@ -150,8 +170,7 @@ harden(ChainPolicyShape);
 /**
  * @type {TypedPattern<FeedPolicy>}
  *
- * Should be JSON serializable so CLI can specify policy. E.g. no bigint,
- * undefined, remotable, etc.
+ * must be CopyData; no Brands or other Remotables
  */
 export const FeedPolicyShape = M.splitRecord(
   {
@@ -163,12 +182,30 @@ export const FeedPolicyShape = M.splitRecord(
 );
 harden(FeedPolicyShape);
 
+/**
+ * The version of CosmosChainInfoShape that matches the `valueShape` used in FUSDC's ChainHub's `chainInfos` mapStore.
+ * @type {TypedPattern<CosmosChainInfo>}
+ */
+export const CosmosChainInfoShapeV1 = M.splitRecord(
+  {
+    chainId: M.string(),
+  },
+  {
+    bech32Prefix: M.string(),
+    connections: M.record(),
+    stakingTokens: M.arrayOf({ denom: M.string() }),
+    // UNTIL https://github.com/Agoric/agoric-sdk/issues/9326
+    icqEnabled: M.boolean(),
+    pfmEnabled: M.boolean(),
+  },
+);
+
 /** @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),
+  chainInfo: M.recordOf(M.string(), CosmosChainInfoShapeV1),
   assetInfo: M.arrayOf([DenomShape, DenomDetailShape]),
 });

package/src/types.ts

@@ -1,17 +1,35 @@
+import type { Amount } from '@agoric/ertp';
 import type {
-  ChainAddress,
+  AccountId,
+  BaseChainInfo,
+  Bech32Address,
+  CaipChainId,
+  CosmosChainAddress,
   CosmosChainInfo,
   Denom,
   DenomDetail,
+  KnownNamespace,
 } from '@agoric/orchestration';
 import type { IBCChannelID } from '@agoric/vats';
-import type { Amount } from '@agoric/ertp';
-import type { CopyRecord, Passable } from '@endo/pass-style';
+import type { CopyRecord } from '@endo/pass-style';
 import type { PendingTxStatus, TxStatus } from './constants.js';
-import type { FastUsdcTerms } from './fast-usdc.contract.js';
-import type { RepayAmountKWR } from './exos/liquidity-pool.js';
+import type { RepayAmountKWR } from './utils/fees.js';
 
+// XXX duped with Zoe contractSupport ambient types
+type Ratio = {
+  numerator: Amount<'nat'>;
+  denominator: Amount<'nat'>;
+};
+
+/**
+ * Block hash is calculated using the keccak256 algorithm that always results
+ * in 32 bytes (64 hex characters prepended by 0x) no matter the input length.
+ */
 export type EvmHash = `0x${string}`;
+/**
+ * An address is always the last 20 bytes (40 hex charaters prepended by 0x) of
+ * the public key hash.
+ */
 export type EvmAddress = `0x${string & { length: 40 }}`;
 export type NobleAddress = `noble1${string}`;
 export type EvmChainID = number;
@@ -25,7 +43,7 @@ export interface CctpTxEvidence {
   /** from Noble RPC */
   aux: {
     forwardingChannel: IBCChannelID;
-    recipientAddress: ChainAddress['value'];
+    recipientAddress: CosmosChainAddress['value'] | AccountId;
   };
   /** on the source chain (e.g. L1 Ethereum and L2s Arbitrum, Base) */
   blockHash: EvmHash;
@@ -52,7 +70,7 @@ export interface CctpTxEvidence {
   txHash: EvmHash;
 }
 
-export interface EvidenceWithRisk {
+export interface EvidenceWithRisk extends CopyRecord {
   evidence: CctpTxEvidence;
   risk: RiskAssessment;
 }
@@ -70,8 +88,9 @@ export interface TransactionRecord extends CopyRecord {
 
 /** the record in vstorage at the path of the contract's node */
 export interface ContractRecord extends CopyRecord {
-  poolAccount: ChainAddress['value'];
-  settlementAccount: ChainAddress['value'];
+  nobleICA?: CosmosChainAddress['value'];
+  poolAccount: CosmosChainAddress['value'];
+  settlementAccount: CosmosChainAddress['value'];
 }
 
 export type LogFn = (...args: unknown[]) => void;
@@ -81,12 +100,22 @@ export interface PendingTx extends CctpTxEvidence {
 }
 
 export type FeeConfig = {
-  /** flat fee charged for every advance */
+  /** flat fee charged for every advance, eligible for LP disbursement */
   flat: Amount<'nat'>;
-  /** proportion of advance kept as a fee */
+  /** proportion of advance kept as a fee, eligible for LP disbursement */
   variableRate: Ratio;
-  /** proportion of fees that goes to the contract (remaining goes to LPs) */
+  /** proportion of `flat` and `variableRate` fees that goes to the contract (remaining goes to LPs) */
   contractRate: Ratio;
+  /**
+   * if present, a fee required to relay (e.g. CCTP to EVM/Solana). Not
+   * considered for LP disbursement - goes to `contractSeat`.
+   */
+  relay?: Amount<'nat'>;
+  /** Optional destination-specific overrides. If present, must supersede base values. */
+  destinationOverrides?: Record<
+    CaipChainId,
+    Partial<Omit<FeeConfig, 'destinationOverrides'>>
+  >;
 };
 
 export interface PoolStats {
@@ -127,13 +156,17 @@ export type FeedPolicy = {
   eventFilter?: string;
 } & CopyRecord;
 
+export type FastUsdcTerms = {
+  usdcDenom: Denom;
+};
+
 export type FastUSDCConfig = {
   terms: FastUsdcTerms;
   oracles: Record<string, string>;
   feeConfig: FeeConfig;
   feedPolicy: FeedPolicy;
   noNoble: boolean; // support a3p-integration, which has no noble chain
-  chainInfo: Record<string, CosmosChainInfo & Passable>;
+  chainInfo: Record<string, ChainHubChainInfo>;
   assetInfo: [Denom, DenomDetail & { brandKey?: string }][];
 } & CopyRecord;
 
@@ -142,9 +175,22 @@ export type AddressHook = {
   baseAddress: string;
   query: {
     /** end user destination address */
-    EUD: string;
+    EUD: Bech32Address;
   };
 };
 
+/**
+ * The shape of ChainInfo ChainHub is expecting for FUSDC.
+ *
+ * Note: this diverges from `CosmosChainInfo` and `BaseChainInfo` in that:
+ * - BaseChainInfo includes chainId for backwards compatibility with `CosmosChainInfoShapeV1`
+ */
+export type ChainHubChainInfo<N extends KnownNamespace = KnownNamespace> =
+  N extends 'cosmos' ? CosmosChainInfo : BaseChainInfoWithChainId<N>;
+
+interface BaseChainInfoWithChainId<N extends KnownNamespace = KnownNamespace>
+  extends BaseChainInfo<N> {
+  chainId: string;
+}
+
 export type * from './constants.js';
-export type { LiquidityPoolKit } from './exos/liquidity-pool.js';

package/src/utils/fees.js

@@ -1,56 +1,142 @@
 import { AmountMath } from '@agoric/ertp';
-import { multiplyBy } from '@agoric/zoe/src/contractSupport/ratio.js';
+import { multiplyBy } from '@agoric/ertp/src/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 } = AmountMath;
+const { add, isGTE, subtract, makeEmpty } = AmountMath;
 
 /**
  * @import {Amount} from '@agoric/ertp';
+ * @import {AccountId} from '@agoric/orchestration';
  * @import {FeeConfig} from '../types.js';
- * @import {RepayAmountKWR} from '../exos/liquidity-pool.js';
  */
 
-/** @param {FeeConfig} feeConfig */
+/**
+ * @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
+ */
 export const makeFeeTools = feeConfig => {
   mustMatch(feeConfig, FeeConfigShape, 'Must provide feeConfig');
-  const { flat, variableRate } = feeConfig;
+  const emptyAmount = makeEmpty(feeConfig.flat.brand);
+
   const feeTools = harden({
     /**
-     * Calculate the net amount to advance after withholding fees.
+     * 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}.
      *
      * @param {Amount<'nat'>} requested
-     * @throws {Error} if requested does not exceed fees
+     * @param {AccountId} destination
+     * @returns {Amount<'nat'>}
      */
-    calculateAdvance(requested) {
-      const fee = feeTools.calculateAdvanceFee(requested);
-      return subtract(requested, fee);
+    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'>}
+     */
+    calculateRelayFee(destination) {
+      const relay = getConfigValue(feeConfig, 'relay', destination);
+      return relay || emptyAmount;
     },
     /**
      * 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) {
-      const fee = add(multiplyBy(requested, variableRate), flat);
+    calculateAdvanceFee(requested, destination) {
+      const baseFee = feeTools.calculateBaseFee(requested, destination);
+      const relayFee = feeTools.calculateRelayFee(destination);
+      const fee = add(baseFee, relayFee);
       !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) {
-      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 });
+    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 });
     },
   });
   return feeTools;

package/tools/mock-evidence.ts

@@ -0,0 +1,205 @@
+import { encodeAddressHook } from '@agoric/cosmic-proto/address-hooks.js';
+import type { Bech32Address, CosmosChainAddress } from '@agoric/orchestration';
+import type { CctpTxEvidence, EvmAddress } from '../src/types.js';
+
+export type MockScenario =
+  | 'AGORIC_PLUS_OSMO'
+  | 'AGORIC_PLUS_DYDX'
+  | 'AGORIC_PLUS_AGORIC'
+  | 'AGORIC_NO_PARAMS'
+  | 'AGORIC_UNKNOWN_EUD'
+  | 'AGORIC_PLUS_ETHEREUM'
+  | 'AGORIC_PLUS_NOBLE'
+  | 'AGORIC_PLUS_NOBLE_B32EUD';
+
+export const Senders = {
+  default: '0xDefaultFakeEthereumAddress',
+} as unknown as Record<string, EvmAddress>;
+
+const blockTimestamp = 1632340000n;
+
+export const MockCctpTxEvidences: Record<
+  MockScenario,
+  (receiverAddress?: Bech32Address) => CctpTxEvidence
+> = {
+  AGORIC_PLUS_OSMO: (receiverAddress?: Bech32Address) => ({
+    blockHash:
+      '0x90d7343e04f8160892e94f02d6a9b9f255663ed0ac34caca98544c8143fee665',
+    blockNumber: 21037663n,
+    blockTimestamp,
+    txHash:
+      '0xc81bc6105b60a234c7c50ac17816ebcd5561d366df8bf3be59ff387552761702',
+    tx: {
+      amount: 150000000n,
+      forwardingAddress: 'noble1x0ydg69dh6fqvr27xjvp6maqmrldam6yfelqkd',
+      sender: Senders.default,
+    },
+    aux: {
+      forwardingChannel: 'channel-21',
+      recipientAddress:
+        receiverAddress ||
+        encodeAddressHook(settlementAddress.value, {
+          EUD: 'osmo183dejcnmkka5dzcu9xw6mywq0p2m5peks28men',
+        }),
+    },
+    chainId: 1,
+  }),
+  AGORIC_PLUS_DYDX: (receiverAddress?: Bech32Address) => ({
+    blockHash:
+      '0x80d7343e04f8160892e94f02d6a9b9f255663ed0ac34caca98544c8143fee699',
+    blockNumber: 21037669n,
+    blockTimestamp,
+    txHash:
+      '0xd81bc6105b60a234c7c50ac17816ebcd5561d366df8bf3be59ff387552761799',
+    tx: {
+      amount: 300000000n,
+      forwardingAddress: 'noble1x0ydg69dh6fqvr27xjvp6maqmrldam6yfelktz',
+      sender: Senders.default,
+    },
+    aux: {
+      forwardingChannel: 'channel-21',
+      recipientAddress:
+        receiverAddress ||
+        encodeAddressHook(settlementAddress.value, {
+          EUD: 'dydx183dejcnmkka5dzcu9xw6mywq0p2m5peks28men',
+        }),
+    },
+    chainId: 1,
+  }),
+  AGORIC_PLUS_AGORIC: (receiverAddress?: Bech32Address) => ({
+    blockHash:
+      '0x80d7343e04f8160892e94f02d6a9b9f255663ed0ac34caca98544c8143fee6z9',
+    blockNumber: 21037600n,
+    blockTimestamp,
+    txHash:
+      '0xd81bc6105b60a234c7c50ac17816ebcd5561d366df8bf3be59ff3875527617z9',
+    tx: {
+      amount: 250000000n,
+      forwardingAddress: 'noble17ww3rfusv895d92c0ncgj0fl9trntn70jz7hd5',
+      sender: Senders.default,
+    },
+    aux: {
+      forwardingChannel: 'channel-21',
+      recipientAddress:
+        receiverAddress ||
+        encodeAddressHook(settlementAddress.value, {
+          EUD: 'agoric13rj0cc0hm5ac2nt0sdup2l7gvkx4v9tyvgq3h2',
+        }),
+    },
+    chainId: 1,
+  }),
+  AGORIC_NO_PARAMS: (receiverAddress?: Bech32Address) => ({
+    blockHash:
+      '0x70d7343e04f8160892e94f02d6a9b9f255663ed0ac34caca98544c8143fee699',
+    blockNumber: 21037669n,
+    blockTimestamp,
+    txHash:
+      '0xa81bc6105b60a234c7c50ac17816ebcd5561d366df8bf3be59ff387552761799',
+    tx: {
+      amount: 200000000n,
+      forwardingAddress: 'noble1x0ydg69dh6fqvr27xjvp6maqmrldam6yfelyyy',
+      sender: Senders.default,
+    },
+    aux: {
+      forwardingChannel: 'channel-21',
+      recipientAddress: receiverAddress || settlementAddress.value,
+    },
+    chainId: 1,
+  }),
+  AGORIC_UNKNOWN_EUD: (receiverAddress?: Bech32Address) => ({
+    blockHash:
+      '0x70d7343e04f8160892e94f02d6a9b9f255663ed0ac34caca98544c8143fee699',
+    blockNumber: 21037669n,
+    blockTimestamp,
+    txHash:
+      '0xa81bc6105b60a234c7c50ac17816ebcd5561d366df8bf3be59ff387552761799',
+    tx: {
+      amount: 200000000n,
+      forwardingAddress: 'noble1x0ydg69dh6fqvr27xjvp6maqmrldam6yfelyyy',
+      sender: Senders.default,
+    },
+    aux: {
+      forwardingChannel: 'channel-21',
+      recipientAddress:
+        receiverAddress ||
+        encodeAddressHook(settlementAddress.value, {
+          EUD: 'random1addr',
+        }),
+    },
+    chainId: 1,
+  }),
+  AGORIC_PLUS_ETHEREUM: (receiverAddress?: Bech32Address) => ({
+    blockHash:
+      '0x80d7343e04f8160892e94f02d6a9b9f255663ed0ac34caca98544c8143fee6z9',
+    blockNumber: 21037600n,
+    blockTimestamp,
+    txHash:
+      '0xe81bc6105b60a234c7c50ac17816ebcd5561d366df8bf3be59ff3875527617z9',
+    tx: {
+      amount: 950000000n,
+      forwardingAddress: 'noble17ww3rfusv895d92c0ncgj0fl9trntn70jz7ee5',
+      sender: Senders.default,
+    },
+    aux: {
+      forwardingChannel: 'channel-21',
+      recipientAddress:
+        receiverAddress ||
+        encodeAddressHook(settlementAddress.value, {
+          EUD: 'eip155:1:0x1234567890123456789012345678901234567890',
+        }),
+    },
+    chainId: 8453,
+  }),
+  AGORIC_PLUS_NOBLE: (receiverAddress?: Bech32Address) => ({
+    blockHash:
+      '0x80d7343e04f8160892e94f02d6a9b9f255663ed0ac34caca98544c8143fee6z9',
+    blockNumber: 21037600n,
+    blockTimestamp,
+    txHash:
+      '0xe81bc6105b60a234c7c50ac17816ebcd5561d366df8bf3be59ff3875527617z9',
+    tx: {
+      amount: 950000000n,
+      forwardingAddress: 'noble17ww3rfusv895d92c0ncgj0fl9trntn70jz7ee5',
+      sender: Senders.default,
+    },
+    aux: {
+      forwardingChannel: 'channel-21',
+      recipientAddress:
+        receiverAddress ||
+        encodeAddressHook(settlementAddress.value, {
+          EUD: 'cosmos:noble-1:noble1u2l9za2wa7wvffhtekgyuvyvum06lwhqxfyr5d',
+        }),
+    },
+    chainId: 8453,
+  }),
+  /** Identical to AGORIC_PLUS_NOBLE, but the EUD is a bare bech32 */
+  AGORIC_PLUS_NOBLE_B32EUD: (receiverAddress?: Bech32Address) => ({
+    blockHash:
+      '0x80d7343e04f8160892e94f02d6a9b9f255663ed0ac34caca98544c8143fee6z9',
+    blockNumber: 21037600n,
+    blockTimestamp,
+    txHash:
+      '0xe81bc6105b60a234c7c50ac17816ebcd5561d366df8bf3be59ff3875527617z9',
+    tx: {
+      amount: 950000000n,
+      forwardingAddress: 'noble17ww3rfusv895d92c0ncgj0fl9trntn70jz7ee5',
+      sender: Senders.default,
+    },
+    aux: {
+      forwardingChannel: 'channel-21',
+      recipientAddress:
+        receiverAddress ||
+        encodeAddressHook(settlementAddress.value, {
+          EUD: 'noble1u2l9za2wa7wvffhtekgyuvyvum06lwhqxfyr5d',
+        }),
+    },
+    chainId: 8453,
+  }),
+};
+
+export const settlementAddress: CosmosChainAddress = harden({
+  chainId: 'agoric-3',
+  encoding: 'bech32' as const,
+  // Random value, copied from tests of address hooks
+  value: 'agoric16kv2g7snfc4q24vg3pjdlnnqgngtjpwtetd2h689nz09lcklvh5s8u37ek',
+});

package/src/add-operators.core.js

@@ -1,63 +0,0 @@
-import { makeTracer } from '@agoric/internal';
-import { inviteOracles } from './utils/core-eval.js';
-
-/**
- * @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 {FastUSDCConfig} from './types.js'
- * @import {FastUSDCCorePowers, FastUSDCKit} from './start-fast-usdc.core.js';
- */
-
-const trace = makeTracer('FUSD-AddOperators', true);
-
-/**
- * @throws if oracle smart wallets are not yet provisioned
- *
- * @param {BootstrapPowers & FastUSDCCorePowers } powers
- * @param {{ options: LegibleCapData<FastUSDCConfig> }} config
- */
-export const addOperators = async (
-  { consume: { namesByAddress, fastUsdcKit } },
-  config,
-) => {
-  trace(addOperators.name);
-
-  const kit = await fastUsdcKit;
-
-  const { creatorFacet } = kit;
-
-  trace(config);
-
-  // @ts-expect-error XXX LegibleCapData typedef
-  const { oracles } = config.options.structure;
-
-  await inviteOracles({ creatorFacet, namesByAddress }, oracles);
-};
-harden(addOperators);
-
-/**
- * @param {{
- *   restoreRef: (b: ERef<ManifestBundleRef>) => Promise<Installation>;
- * }} utils
- * @param {{
- *   options: LegibleCapData<FastUSDCConfig>;
- * }} param1
- */
-export const getManifestForAddOperators = ({ restoreRef: _ }, { options }) => {
-  return {
-    /** @type {BootstrapManifest} */
-    manifest: {
-      [addOperators.name]: {
-        consume: {
-          fastUsdcKit: true,
-
-          // widely shared: name services
-          agoricNames: true,
-          namesByAddress: true,
-        },
-      },
-    },
-    options,
-  };
-};