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

package/src/cli/config-commands.js

@@ -0,0 +1,108 @@
+/**
+ * @import {Command} from 'commander';
+ * @import {File} from './util/file.js';
+ * @import * as ConfigHelpers from './config.js';
+ */
+/**
+ *
+ * @param {Command} program
+ * @param {ConfigHelpers} configHelpers
+ * @param {() => File} makeConfigFile
+ */
+export const addConfigCommands = (program, configHelpers, makeConfigFile) => {
+  const config = program.command('config').description('Manage config');
+
+  config
+    .command('show')
+    .description('Show current config')
+    .action(async () => {
+      await configHelpers.show(makeConfigFile());
+    });
+
+  config
+    .command('init')
+    .description('Set initial config values')
+    .requiredOption(
+      '--noble-seed <seed>',
+      'Seed phrase for Noble account. CAUTION: Stored unencrypted in file system',
+    )
+    .requiredOption(
+      '--eth-seed <seed>',
+      'Seed phrase for Ethereum account. CAUTION: Stored unencrypted in file system',
+    )
+    .requiredOption(
+      '--agoric-seed <seed>',
+      'Seed phrase for Agoric LP account. CAUTION: Stored unencrypted in file system',
+    )
+    .option(
+      '--agoric-rpc [url]',
+      'Agoric RPC endpoint',
+      'http://127.0.0.1:26656',
+    )
+    .option(
+      '--agoric-api [url]',
+      'Agoric RPC endpoint',
+      'http://127.0.0.1:1317',
+    )
+    .option('--noble-rpc [url]', 'Noble RPC endpoint', 'http://127.0.0.1:26657')
+    .option('--noble-api [url]', 'Noble API endpoint', 'http://127.0.0.1:1318')
+    .option('--eth-rpc [url]', 'Ethereum RPC Endpoint', 'http://127.0.0.1:8545')
+    .option(
+      '--noble-to-agoric-channel [channel]',
+      'Channel ID on Noble for Agoric',
+      'channel-21',
+    )
+    .option(
+      '--token-messenger-address [address]',
+      'Address of TokenMessenger contract',
+      // Default to ETH mainnet contract address. For ETH sepolia, use 0x9f3B8679c73C2Fef8b59B4f3444d4e156fb70AA5
+      '0xbd3fa81b58ba92a82136038b25adec7066af3155',
+    )
+    .option(
+      '--token-contract-address [address]',
+      'Address of USDC token contract',
+      // Detault to ETH mainnet token address. For ETH sepolia, use 0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238
+      '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+    )
+    .action(async options => {
+      await configHelpers.init(makeConfigFile(), options);
+    });
+
+  config
+    .command('update')
+    .description('Update config values')
+    .option(
+      '--noble-seed [string]',
+      'Seed phrase for Noble account. CAUTION: Stored unencrypted in file system',
+    )
+    .option(
+      '--eth-seed [string]',
+      'Seed phrase for Ethereum account. CAUTION: Stored unencrypted in file system',
+    )
+    .option(
+      '--agoric-seed <seed>',
+      'Seed phrase for Agoric LP account. CAUTION: Stored unencrypted in file system',
+    )
+    .option('--agoric-rpc [url]', 'Agoric RPC endpoint')
+    .option('--agoric-api [url]', 'Agoric API endpoint')
+    .option('--noble-rpc [url]', 'Noble RPC endpoint')
+    .option('--noble-api [url]', 'Noble API endpoint')
+    .option('--eth-rpc [url]', 'Ethereum RPC Endpoint')
+    .option(
+      '--noble-to-agoric-channel [channel]',
+      'Channel ID on Noble for Agoric',
+    )
+    .option(
+      '--token-messenger-address [address]',
+      'Address of TokenMessenger contract',
+    )
+    .option(
+      '--token-contract-address [address]',
+      'Address of USDC token contract',
+    )
+    .action(async options => {
+      await configHelpers.update(makeConfigFile(), options);
+    });
+
+  return config;
+};

package/src/cli/config.js

@@ -1,24 +1,32 @@
 import * as readline from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
 
+/**
+   @typedef {{
+    bech32Prefix: string,
+    api: string,
+    USDCDenom: string
+  }} DestinationChain
+ */
+
 /**
    @typedef {{
     nobleSeed: string,
     ethSeed: string,
     nobleToAgoricChannel: string,
-    agoricRpc: string,
     nobleApi: string,
     nobleRpc: string,
     ethRpc: string,
     tokenMessengerAddress: string,
     tokenAddress: string
+    destinationChains?: DestinationChain[]
   }} ConfigOpts
  */
 
-/** @import { file } from '../util/file' */
+/** @import { File } from './util/file.js' */
 
-const init = async (
-  /** @type {file} */ configFile,
+export const init = async (
+  /** @type {File} */ configFile,
   /** @type {ConfigOpts} */ options,
   out = console,
   rl = readline.createInterface({ input, output }),
@@ -52,8 +60,8 @@ const init = async (
   await writeConfig();
 };
 
-const update = async (
-  /** @type {file} */ configFile,
+export const update = async (
+  /** @type {File} */ configFile,
   /** @type {Partial<ConfigOpts>} */ options,
   out = console,
 ) => {
@@ -83,7 +91,7 @@ const update = async (
   await updateConfig({ ...JSON.parse(file), ...options });
 };
 
-const show = async (/** @type {file} */ configFile, out = console) => {
+export const show = async (/** @type {File} */ configFile, out = console) => {
   let contents;
   await null;
   try {
@@ -97,5 +105,3 @@ const show = async (/** @type {file} */ configFile, out = console) => {
   out.log(`Config found at ${configFile.path}:`);
   out.log(contents);
 };
-
-export default { init, update, show };

package/src/cli/lp-commands.js

@@ -0,0 +1,160 @@
+/* eslint-env node */
+/**
+ * @import {Command} from 'commander';
+ * @import {Amount, Brand} from '@agoric/ertp';
+ * @import {OfferSpec} from '@agoric/smart-wallet/src/offers.js';
+ * @import {ExecuteOfferAction} from '@agoric/smart-wallet/src/smartWallet.js';
+ * @import {USDCProposalShapes} from '../pool-share-math.js';
+ */
+
+import {
+  fetchEnvNetworkConfig,
+  makeSmartWalletKit,
+} from '@agoric/client-utils';
+import { AmountMath } from '@agoric/ertp';
+import {
+  assertParsableNumber,
+  ceilDivideBy,
+  floorDivideBy,
+  multiplyBy,
+  parseRatio,
+} from '@agoric/ertp/src/ratio.js';
+import { InvalidArgumentError } from 'commander';
+import { outputActionAndHint } from './bridge-action.js';
+import { Offers } from '../clientSupport.js';
+
+export const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+/** @param {string} arg */
+const parseDecimal = arg => {
+  try {
+    assertParsableNumber(arg);
+    const n = Number(arg);
+    return n;
+  } catch {
+    throw new InvalidArgumentError('Not a number');
+  }
+};
+
+/**
+ * @param {string} amountString
+ * @param {Brand<'nat'>} usdc
+ */
+const parseUSDCAmount = (amountString, usdc) => {
+  const USDC_DECIMALS = 6;
+  const unit = AmountMath.make(usdc, 10n ** BigInt(USDC_DECIMALS));
+  return multiplyBy(unit, parseRatio(amountString, usdc));
+};
+
+/**
+ * @param {Command} program
+ * @param {{
+ *   fetch?: Window['fetch'];
+ *    smartWalletKit?: import('@agoric/client-utils').SmartWalletKit;
+ *   stdout: typeof process.stdout;
+ *   stderr: typeof process.stderr;
+ *   env: typeof process.env;
+ *   now: typeof Date.now;
+ * }} io
+ */
+export const addLPCommands = (
+  program,
+  { fetch, smartWalletKit, stderr, stdout, env, now },
+) => {
+  const loadSwk = async () => {
+    if (smartWalletKit) {
+      return smartWalletKit;
+    }
+    assert(fetch);
+    const networkConfig = await fetchEnvNetworkConfig({ env, fetch });
+    return makeSmartWalletKit({ delay, fetch }, networkConfig);
+  };
+  /** @type {undefined | ReturnType<typeof loadSwk>} */
+  let swkP;
+
+  program
+    .command('deposit')
+    .description('Deposit USDC into pool')
+    .addHelpText(
+      'after',
+      '\nPipe the STDOUT to a file such as deposit.json, then use the Agoric CLI to broadcast it:\n  agoric wallet send --offer deposit.json --from gov1 --keyring-backend="test"',
+    )
+    .requiredOption('--amount <number>', 'USDC amount', parseDecimal)
+    .option('--offerId <string>', 'Offer id', String, `lpDeposit-${now()}`)
+    .action(async opts => {
+      swkP ||= loadSwk();
+      const swk = await swkP;
+
+      /** @type {Brand<'nat'>} */
+      // @ts-expect-error it doesnt recognize usdc as a Brand type
+      const usdc = swk.agoricNames.brand.USDC;
+      assert(usdc, 'USDC brand not in agoricNames');
+
+      /** @type {Brand<'nat'>} */
+      // @ts-expect-error it doesnt recognize FastLP as a Brand type
+      const poolShare = swk.agoricNames.brand.FastLP;
+      assert(poolShare, 'FastLP brand not in agoricNames');
+
+      const usdcAmount = parseUSDCAmount(opts.amount, usdc);
+
+      const metrics = await swk.readPublished('fastUsdc.poolMetrics');
+      const fastLPAmount = floorDivideBy(usdcAmount, metrics.shareWorth);
+
+      const offer = Offers.fastUsdc.Deposit(swk.agoricNames, {
+        offerId: opts.offerId,
+        fastLPAmount: fastLPAmount.value,
+        usdcAmount: usdcAmount.value,
+      });
+
+      /** @type {ExecuteOfferAction} */
+      const bridgeAction = {
+        method: 'executeOffer',
+        offer,
+      };
+
+      outputActionAndHint(bridgeAction, { stderr, stdout }, swk.marshaller);
+    });
+
+  program
+    .command('withdraw')
+    .description("Withdraw USDC from the LP's pool share")
+    .addHelpText(
+      'after',
+      '\nPipe the STDOUT to a file such as withdraw.json, then use the Agoric CLI to broadcast it:\n  agoric wallet send --offer withdraw.json --from gov1 --keyring-backend="test"',
+    )
+    .requiredOption('--amount <number>', 'USDC amount', parseDecimal)
+    .option('--offerId <string>', 'Offer id', String, `lpWithdraw-${now()}`)
+    .action(async opts => {
+      swkP ||= loadSwk();
+      const swk = await swkP;
+
+      /** @type {Brand<'nat'>} */
+      // @ts-expect-error it doesnt recognize FastLP as a Brand type
+      const poolShare = swk.agoricNames.brand.FastLP;
+      assert(poolShare, 'FastLP brand not in agoricNames');
+
+      /** @type {Brand<'nat'>} */
+      // @ts-expect-error it doesnt recognize usdc as a Brand type
+      const usdc = swk.agoricNames.brand.USDC;
+      assert(usdc, 'USDC brand not in agoricNames');
+
+      const usdcAmount = parseUSDCAmount(opts.amount, usdc);
+
+      const metrics = await swk.readPublished('fastUsdc.poolMetrics');
+      const fastLPAmount = ceilDivideBy(usdcAmount, metrics.shareWorth);
+
+      const offer = Offers.fastUsdc.Withdraw(swk.agoricNames, {
+        offerId: opts.offerId,
+        fastLPAmount: fastLPAmount.value,
+        usdcAmount: usdcAmount.value,
+      });
+
+      outputActionAndHint(
+        { method: 'executeOffer', offer },
+        { stderr, stdout },
+        swk.marshaller,
+      );
+    });
+
+  return program;
+};

package/src/cli/operator-commands.js

@@ -0,0 +1,143 @@
+/* eslint-env node */
+/**
+ * @import {Command} from 'commander';
+ * @import {OfferSpec} from '@agoric/smart-wallet/src/offers.js';
+ * @import {ExecuteOfferAction} from '@agoric/smart-wallet/src/smartWallet.js';
+ */
+
+import {
+  fetchEnvNetworkConfig,
+  makeSmartWalletKit,
+} from '@agoric/client-utils';
+import { mustMatch } from '@agoric/internal';
+import { Nat } from '@endo/nat';
+import { InvalidArgumentError } from 'commander';
+import { INVITATION_MAKERS_DESC } from '../operator-kit-interface.js';
+import { CctpTxEvidenceShape } from '../type-guards.js';
+import { outputActionAndHint } from './bridge-action.js';
+
+export const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+/** @param {string} arg */
+const parseNat = arg => {
+  const n = Nat(BigInt(arg));
+  return n;
+};
+
+/** @param {string} arg */
+const parseHex = arg => {
+  if (!arg.startsWith('0x')) throw new InvalidArgumentError('not a hex string');
+  return arg;
+};
+
+/**
+ * @param {Command} program
+ * @param {{
+ *   fetch: Window['fetch'];
+ *   stdout: typeof process.stdout;
+ *   stderr: typeof process.stderr;
+ *   env: typeof process.env;
+ *   now: typeof Date.now;
+ * }} io
+ */
+export const addOperatorCommands = (
+  program,
+  { fetch, stderr, stdout, env, now },
+) => {
+  const operator = program
+    .command('operator')
+    .description('Oracle operator commands');
+
+  operator
+    .command('accept')
+    .description('Accept invitation to be an operator')
+    .addHelpText(
+      'after',
+      '\nPipe the STDOUT to a file such as accept.json, then use the Agoric CLI to broadcast it:\n  agoric wallet send --offer accept.json --from gov1 --keyring-backend="test"',
+    )
+    .option('--offerId <string>', 'Offer id', String, `operatorAccept-${now()}`)
+    .action(async opts => {
+      const networkConfig = await fetchEnvNetworkConfig({ env, fetch });
+
+      const swk = await makeSmartWalletKit({ delay, fetch }, networkConfig);
+      const instance = swk.agoricNames.instance.fastUsdc;
+      assert(instance, 'fastUsdc instance not in agoricNames');
+
+      /** @type {OfferSpec} */
+      const offer = {
+        id: opts.offerId,
+        invitationSpec: {
+          source: 'purse',
+          instance,
+          description: INVITATION_MAKERS_DESC,
+        },
+        proposal: {},
+      };
+
+      /** @type {ExecuteOfferAction} */
+      const bridgeAction = {
+        method: 'executeOffer',
+        offer,
+      };
+
+      outputActionAndHint(bridgeAction, { stderr, stdout });
+    });
+
+  operator
+    .command('attest')
+    .description('Attest to an observed Fast USDC transfer')
+    .addHelpText(
+      'after',
+      '\nPipe the STDOUT to a file such as attest.json, then use the Agoric CLI to broadcast it:\n  agoric wallet send --offer attest.json --from gov1 --keyring-backend="test"',
+    )
+    .requiredOption('--previousOfferId <string>', 'Offer id', String)
+    .requiredOption('--forwardingChannel <string>', 'Channel id', String)
+    .requiredOption('--recipientAddress <string>', 'bech32 address', String)
+    .requiredOption('--blockHash <0xhex>', 'hex hash', parseHex)
+    .requiredOption('--blockNumber <number>', 'number', parseNat)
+    .requiredOption('--blockTimestamp <number>', 'number', parseNat)
+    .requiredOption('--chainId <string>', 'chain id', Number)
+    .requiredOption('--amount <number>', 'number', parseNat)
+    .requiredOption('--forwardingAddress <string>', 'bech32 address', String)
+    .requiredOption('--sender <string>', 'Ethereum address initiating', String)
+    .requiredOption('--txHash <0xhexo>', 'hex hash', parseHex)
+    .option('--offerId <string>', 'Offer id', String, `operatorAttest-${now()}`)
+    .action(async opts => {
+      const {
+        offerId,
+        previousOfferId,
+        forwardingChannel,
+        recipientAddress,
+        amount,
+        forwardingAddress,
+        sender,
+        ...flat
+      } = opts;
+
+      const evidence = harden({
+        aux: { forwardingChannel, recipientAddress },
+        tx: { amount, forwardingAddress, sender },
+        ...flat,
+      });
+      mustMatch(evidence, CctpTxEvidenceShape);
+
+      /** @type {OfferSpec} */
+      const offer = {
+        id: offerId,
+        invitationSpec: {
+          source: 'continuing',
+          previousOffer: previousOfferId,
+          invitationMakerName: 'SubmitEvidence',
+          invitationArgs: [evidence],
+        },
+        proposal: {},
+      };
+
+      outputActionAndHint(
+        { method: 'executeOffer', offer },
+        { stderr, stdout },
+      );
+    });
+
+  return operator;
+};

package/src/cli/transfer.js

@@ -1,44 +1,66 @@
+/* eslint-env node */
 /* global globalThis */
 
-import { makeVStorage } from '@agoric/client-utils';
-import { depositForBurn, makeProvider } from '../util/cctp.js';
+import {
+  fetchEnvNetworkConfig,
+  makeVStorage,
+  pickEndpoint,
+} from '@agoric/client-utils';
+import { encodeAddressHook } from '@agoric/cosmic-proto/address-hooks.js';
+import { queryFastUSDCLocalChainAccount } from './util/agoric.js';
+import { depositForBurn, makeProvider } from './util/cctp.js';
 import {
   makeSigner,
   queryForwardingAccount,
   registerFwdAccount,
-} from '../util/noble.js';
-import { queryFastUSDCLocalChainAccount } from '../util/agoric.js';
+} from './util/noble.js';
+import { queryUSDCBalance } from './util/bank.js';
 
-/** @import { file } from '../util/file' */
+/** @import { File } from './util/file.js' */
 /** @import { VStorage } from '@agoric/client-utils' */
 /** @import { SigningStargateClient } from '@cosmjs/stargate' */
 /** @import { JsonRpcProvider as ethProvider } from 'ethers' */
 
-const transfer = async (
-  /** @type {file} */ configFile,
-  /** @type {string} */ amount,
-  /** @type {string} */ destination,
+/**
+ * @param {File} configFile
+ * @param {string} amount
+ * @param {string} EUD
+ * @param {typeof globalThis.console} [out]
+ * @param {typeof globalThis.fetch} [fetch]
+ * @param {VStorage} [vstorage]
+ * @param {{signer: SigningStargateClient, address: string}} [nobleSigner]
+ * @param {ethProvider} [ethProvider]
+ * @param {typeof process.env} [env]
+ * @param {typeof globalThis.setTimeout} [setTimeout]
+ */
+export const transfer = async (
+  configFile,
+  amount,
+  EUD,
   out = console,
   fetch = globalThis.fetch,
-  /** @type {VStorage | undefined} */ vstorage,
-  /** @type {{signer: SigningStargateClient, address: string} | undefined} */ nobleSigner,
-  /** @type {ethProvider | undefined} */ ethProvider,
+  vstorage,
+  nobleSigner,
+  ethProvider,
+  env = process.env,
+  setTimeout = globalThis.setTimeout,
 ) => {
   const execute = async (
-    /** @type {import('./config').ConfigOpts} */ config,
+    /** @type {import('./config.js').ConfigOpts} */ config,
   ) => {
+    const netConfig = await fetchEnvNetworkConfig({ env, fetch });
     vstorage ||= makeVStorage(
       { fetch },
-      { chainName: 'agoric', rpcAddrs: [config.agoricRpc] },
+      { chainName: 'agoric', rpcAddrs: [pickEndpoint(netConfig)] },
     );
     const agoricAddr = await queryFastUSDCLocalChainAccount(vstorage, out);
-    const appendedAddr = `${agoricAddr}?EUD=${destination}`;
-    out.log(`forwarding destination ${appendedAddr}`);
+    const encodedAddr = encodeAddressHook(agoricAddr, { EUD });
+    out.log(`forwarding destination ${encodedAddr}`);
 
     const { exists, address } = await queryForwardingAccount(
       config.nobleApi,
       config.nobleToAgoricChannel,
-      appendedAddr,
+      encodedAddr,
       out,
       fetch,
     );
@@ -51,18 +73,30 @@ const transfer = async (
           signer,
           signerAddress,
           config.nobleToAgoricChannel,
-          appendedAddr,
+          encodedAddr,
           out,
         );
         out.log(res);
       } catch (e) {
         out.error(
-          `Error registering noble forwarding account for ${appendedAddr} on channel ${config.nobleToAgoricChannel}`,
+          `Error registering noble forwarding account for ${encodedAddr} on channel ${config.nobleToAgoricChannel}`,
         );
         throw e;
       }
     }
 
+    const destChain = config.destinationChains?.find(chain =>
+      EUD.startsWith(chain.bech32Prefix),
+    );
+    if (!destChain) {
+      out.error(
+        `No destination chain found in config with matching bech32 prefix for ${EUD}, cannot query destination address`,
+      );
+      throw new Error();
+    }
+    const { api, USDCDenom } = destChain;
+    const startingBalance = await queryUSDCBalance(EUD, api, USDCDenom, fetch);
+
     ethProvider ||= makeProvider(config.ethRpc);
     await depositForBurn(
       ethProvider,
@@ -73,6 +107,34 @@ const transfer = async (
       amount,
       out,
     );
+
+    const refreshDelayMS = 1200;
+    const completeP = /** @type {Promise<void>} */ (
+      new Promise((res, rej) => {
+        const refreshUSDCBalance = async () => {
+          out.log('polling usdc balance');
+          const currentBalance = await queryUSDCBalance(
+            EUD,
+            api,
+            USDCDenom,
+            fetch,
+          );
+          if (currentBalance !== startingBalance) {
+            res();
+          } else {
+            setTimeout(() => refreshUSDCBalance().catch(rej), refreshDelayMS);
+          }
+        };
+        refreshUSDCBalance().catch(rej);
+      })
+    ).catch(e => {
+      out.error(
+        'Error checking destination address balance, could not detect completion of transfer.',
+      );
+      out.error(e.message);
+    });
+
+    await completeP;
   };
 
   let config;
@@ -87,5 +149,3 @@ const transfer = async (
   }
   await execute(config);
 };
-
-export default { transfer };

package/src/cli/util/agoric.js

@@ -0,0 +1,11 @@
+/** @import { VStorage } from '@agoric/client-utils' */
+
+export const queryFastUSDCLocalChainAccount = async (
+  /** @type {VStorage} */ vstorage,
+  out = console,
+) => {
+  const { value } = await vstorage.readLatest('published.fastUsdc');
+  const { settlementAccount } = JSON.parse(JSON.parse(value).values[0]);
+  out.log(`settlementAccount: ${settlementAccount}`);
+  return settlementAccount;
+};

package/src/cli/util/bank.js

@@ -0,0 +1,12 @@
+export const queryUSDCBalance = async (
+  /** @type {string} */ address,
+  /** @type {string} */ api,
+  /** @type {string} */ denom,
+  /** @type {typeof globalThis.fetch} */ fetch,
+) => {
+  const query = `${api}/cosmos/bank/v1beta1/balances/${address}`;
+  const json = await fetch(query).then(res => res.json());
+  const amount = json.balances?.find(b => b.denom === denom)?.amount ?? '0';
+
+  return BigInt(amount);
+};

package/src/{util → cli/util}/cctp.js

@@ -67,5 +67,5 @@ export const depositForBurn = async (
 
   out.log('Transaction confirmed in block', receipt.blockNumber);
   out.log('Transaction hash:', receipt.hash);
-  out.log('USDC transfer initiated successfully, our work here is done.');
+  out.log('USDC transfer initiated successfully');
 };

package/src/{util → cli/util}/file.js

@@ -27,4 +27,4 @@ export const makeFile = (
   return { read, write, exists, path };
 };
 
-/** @typedef {ReturnType<typeof makeFile>} file */
+/** @typedef {ReturnType<typeof makeFile>} File */