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

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/zoe/src/contractSupport/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} 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,146 @@
+/* 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 {OperatorKit} from '../exos/operator-kit.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 '../exos/transaction-feed.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,
+          /** @type {string & keyof OperatorKit['invitationMakers'] } */
+          invitationMakerName: 'SubmitEvidence',
+          /** @type {Parameters<OperatorKit['invitationMakers']['SubmitEvidence']> } */
+          invitationArgs: [evidence],
+        },
+        proposal: {},
+      };
+
+      outputActionAndHint(
+        { method: 'executeOffer', offer },
+        { stderr, stdout },
+      );
+    });
+
+  return operator;
+};

package/src/cli/transfer.js

@@ -1,44 +1,54 @@
+/* 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' */
 /** @import { VStorage } from '@agoric/client-utils' */
 /** @import { SigningStargateClient } from '@cosmjs/stargate' */
 /** @import { JsonRpcProvider as ethProvider } from 'ethers' */
 
 const transfer = async (
-  /** @type {file} */ configFile,
+  /** @type {File} */ configFile,
   /** @type {string} */ amount,
-  /** @type {string} */ destination,
+  /** @type {string} */ EUD,
   out = console,
   fetch = globalThis.fetch,
   /** @type {VStorage | undefined} */ vstorage,
   /** @type {{signer: SigningStargateClient, address: string} | undefined} */ nobleSigner,
   /** @type {ethProvider | undefined} */ ethProvider,
+  env = process.env,
+  setTimeout = globalThis.setTimeout,
 ) => {
   const execute = async (
     /** @type {import('./config').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 +61,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 +95,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;

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

@@ -5,7 +5,7 @@ export const queryFastUSDCLocalChainAccount = async (
   out = console,
 ) => {
   const agoricAddr = await vstorage.readLatest(
-    'published.fastUSDC.settlementAccount',
+    'published.fastUsdc.settlementAccount',
   );
   out.log(`Got Fast USDC Local Chain Account ${agoricAddr}`);
   return agoricAddr;

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 */

package/src/clientSupport.js

@@ -0,0 +1,98 @@
+// @ts-check
+import { assertAllDefined } from '@agoric/internal';
+
+/**
+ * @import {USDCProposalShapes} from './pool-share-math.js';
+ */
+
+/**
+ * @param {Pick<
+ *   import('@agoric/vats/tools/board-utils.js').AgoricNamesRemotes,
+ *   'brand'
+ * >} agoricNames
+ * @param {object} opts
+ * @param {string} opts.offerId
+ * @param {bigint} opts.fastLPAmount
+ * @param {bigint} opts.usdcAmount
+ * @returns {import('@agoric/smart-wallet/src/offers.js').OfferSpec & {proposal: USDCProposalShapes['deposit']}}
+ */
+const makeDepositOffer = ({ brand }, { offerId, fastLPAmount, usdcAmount }) => {
+  assertAllDefined({ offerId, fastLPAmount, usdcAmount });
+
+  return {
+    id: offerId,
+    invitationSpec: {
+      source: 'agoricContract',
+      instancePath: ['fastUsdc'],
+      callPipe: [['makeDepositInvitation']],
+    },
+    /** @type {USDCProposalShapes['deposit']} */
+    // @ts-expect-error https://github.com/Agoric/agoric-sdk/issues/10491
+    proposal: {
+      give: {
+        USDC: {
+          brand: brand.USDC,
+          value: usdcAmount,
+        },
+      },
+      want: {
+        PoolShare: {
+          brand: brand.FastLP,
+          value: fastLPAmount,
+        },
+      },
+    },
+  };
+};
+
+/**
+ * @param {Pick<
+ *   import('@agoric/vats/tools/board-utils.js').AgoricNamesRemotes,
+ *   'brand'
+ * >} agoricNames
+ * @param {object} opts
+ * @param {string} opts.offerId
+ * @param {bigint} opts.fastLPAmount
+ * @param {bigint} opts.usdcAmount
+ * @returns {import('@agoric/smart-wallet/src/offers.js').OfferSpec}
+ */
+const makeWithdrawOffer = (
+  { brand },
+  { offerId, fastLPAmount, usdcAmount },
+) => ({
+  id: offerId,
+  invitationSpec: {
+    source: 'agoricContract',
+    instancePath: ['fastUsdc'],
+    callPipe: [['makeWithdrawInvitation']],
+  },
+  proposal: {
+    give: {
+      PoolShare: {
+        // @ts-expect-error https://github.com/Agoric/agoric-sdk/issues/10491
+        brand: brand.FastLP,
+        value: fastLPAmount,
+      },
+    },
+    want: {
+      USDC: {
+        // @ts-expect-error https://github.com/Agoric/agoric-sdk/issues/10491
+        brand: brand.USDC,
+        value: usdcAmount,
+      },
+    },
+  },
+});
+
+/**
+ * @satisfies {Record<
+ *   string,
+ *   Record<string, import('@agoric/smart-wallet/src/types.js').OfferMaker>
+ * >}
+ */
+export const Offers = {
+  fastUsdc: {
+    Deposit: makeDepositOffer,
+    Withdraw: makeWithdrawOffer,
+  },
+};

package/src/constants.js

@@ -7,12 +7,29 @@ export const TxStatus = /** @type {const} */ ({
   /** tx was observed but not advanced */
   Observed: 'OBSERVED',
   /** IBC transfer is initiated */
+  Advancing: 'ADVANCING',
+  /** IBC transfer is complete */
   Advanced: 'ADVANCED',
-  /** settlement for matching advance received and funds dispersed */
-  Settled: 'SETTLED',
+  /** IBC transfer failed (timed out) */
+  AdvanceFailed: 'ADVANCE_FAILED',
+  /** Advance skipped and waiting for forward */
+  AdvanceSkipped: 'ADVANCE_SKIPPED',
+  /** settlement for matching advance received and funds disbursed */
+  Disbursed: 'DISBURSED',
+  /** fallback: do not collect fees */
+  Forwarded: 'FORWARDED',
+  /** failed to forward to EUD */
+  ForwardFailed: 'FORWARD_FAILED',
 });
 harden(TxStatus);
 
+// According to the state diagram
+export const TerminalTxStatus = {
+  [TxStatus.Forwarded]: true,
+  [TxStatus.ForwardFailed]: true,
+  [TxStatus.Disbursed]: true,
+};
+
 /**
  * Status values for the StatusManager.
  *
@@ -22,6 +39,12 @@ export const PendingTxStatus = /** @type {const} */ ({
   /** tx was observed but not advanced */
   Observed: 'OBSERVED',
   /** IBC transfer is initiated */
+  Advancing: 'ADVANCING',
+  /** IBC transfer failed (timed out) */
+  AdvanceFailed: 'ADVANCE_FAILED',
+  /** IBC transfer is complete */
   Advanced: 'ADVANCED',
+  /** Advance skipped and waiting for forward */
+  AdvanceSkipped: 'ADVANCE_SKIPPED',
 });
 harden(PendingTxStatus);