@agoric/fast-usdc 0.1.1-dev-02967de.0

package/src/fast-usdc.start.js

@@ -0,0 +1,264 @@
+import { deeplyFulfilledObject, makeTracer, objectMap } from '@agoric/internal';
+import { Fail } from '@endo/errors';
+import { E } from '@endo/far';
+import { makeMarshal } from '@endo/marshal';
+import { M } from '@endo/patterns';
+import { FastUSDCTermsShape, FeeConfigShape } from './type-guards.js';
+import { fromExternalConfig } from './utils/config-marshal.js';
+
+/**
+ * @import {DepositFacet} from '@agoric/ertp/src/types.js'
+ * @import {TypedPattern} from '@agoric/internal'
+ * @import {Instance, StartParams} from '@agoric/zoe/src/zoeService/utils'
+ * @import {Board} from '@agoric/vats'
+ * @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 {FastUsdcSF, FastUsdcTerms} from './fast-usdc.contract.js'
+ * @import {FeeConfig} from './types.js'
+ */
+
+const trace = makeTracer('FUSD-Start', true);
+
+const contractName = 'fastUsdc';
+
+/**
+ * @typedef {{
+ *   terms: FastUsdcTerms;
+ *   oracles: Record<string, string>;
+ *   feeConfig: FeeConfig;
+ * }} FastUSDCConfig
+ */
+/** @type {TypedPattern<FastUSDCConfig>} */
+export const FastUSDCConfigShape = M.splitRecord({
+  terms: FastUSDCTermsShape,
+  oracles: M.recordOf(M.string(), M.string()),
+  feeConfig: FeeConfigShape,
+});
+
+/**
+ * XXX Shouldn't the bridge or board vat handle this?
+ *
+ * @param {string} path
+ * @param {{
+ *   chainStorage: ERef<StorageNode>;
+ *   board: ERef<Board>;
+ * }} io
+ */
+const makePublishingStorageKit = async (path, { chainStorage, board }) => {
+  const storageNode = await E(chainStorage).makeChildNode(path);
+
+  const marshaller = await E(board).getPublishingMarshaller();
+  return { storageNode, marshaller };
+};
+
+const BOARD_AUX = 'boardAux';
+const marshalData = makeMarshal(_val => Fail`data only`);
+/**
+ * @param {Brand} brand
+ * @param {Pick<BootstrapPowers['consume'], 'board' | 'chainStorage'>} powers
+ */
+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));
+};
+
+/**
+ * @typedef { PromiseSpaceOf<{
+ *   fastUsdcKit: FastUSDCKit
+ *  }> & {
+ *   installation: PromiseSpaceOf<{ fastUsdc: Installation<FastUsdcSF> }>;
+ *   instance: PromiseSpaceOf<{ fastUsdc: Instance<FastUsdcSF> }>;
+ *   issuer: PromiseSpaceOf<{ FastLP: Issuer }>;
+ *   brand: PromiseSpaceOf<{ FastLP: Brand }>;
+ * }} FastUSDCCorePowers
+ *
+ * @typedef {StartedInstanceKitWithLabel & {
+ *   privateArgs: StartParams<FastUsdcSF>['privateArgs'];
+ * }} FastUSDCKit
+ */
+
+/**
+ * @throws if oracle smart wallets are not yet provisioned
+ *
+ * @param {BootstrapPowers & FastUSDCCorePowers } powers
+ * @param {{ options: LegibleCapData<FastUSDCConfig> }} config
+ */
+export const startFastUSDC = async (
+  {
+    produce: { fastUsdcKit },
+    consume: {
+      agoricNames,
+      namesByAddress,
+      board,
+      chainStorage,
+      chainTimerService: timerService,
+      localchain,
+      cosmosInterchainService,
+      startUpgradable,
+      zoe,
+    },
+    issuer: {
+      produce: { FastLP: produceShareIssuer },
+    },
+    brand: {
+      produce: { FastLP: produceShareBrand },
+    },
+    installation: {
+      consume: { fastUsdc },
+    },
+    instance: {
+      produce: { fastUsdc: produceInstance },
+    },
+  },
+  config,
+) => {
+  trace('startFastUSDC');
+
+  await null;
+  /** @type {Issuer<'nat'>} */
+  const USDCissuer = await E(agoricNames).lookup('issuer', 'USDC');
+  const brands = harden({
+    USDC: await E(USDCissuer).getBrand(),
+  });
+
+  const { terms, oracles, feeConfig } = fromExternalConfig(
+    config?.options, // just in case config is missing somehow
+    brands,
+    FastUSDCConfigShape,
+  );
+  trace('using terms', terms);
+  trace('using fee config', feeConfig);
+
+  trace('look up oracle deposit facets');
+  const oracleDepositFacets = await deeplyFulfilledObject(
+    objectMap(oracles, async address => {
+      /** @type {DepositFacet} */
+      const depositFacet = await E(namesByAddress).lookup(
+        address,
+        'depositFacet',
+      );
+      return depositFacet;
+    }),
+  );
+
+  const { storageNode, marshaller } = await makePublishingStorageKit(
+    contractName,
+    {
+      board,
+      // @ts-expect-error Promise<null> case is vestigial
+      chainStorage,
+    },
+  );
+
+  const privateArgs = await deeplyFulfilledObject(
+    harden({
+      agoricNames,
+      feeConfig,
+      localchain,
+      orchestrationService: cosmosInterchainService,
+      storageNode,
+      timerService,
+      marshaller,
+    }),
+  );
+
+  const kit = await E(startUpgradable)({
+    label: contractName,
+    installation: fastUsdc,
+    issuerKeywordRecord: harden({ USDC: USDCissuer }),
+    terms,
+    privateArgs,
+  });
+  fastUsdcKit.resolve(harden({ ...kit, privateArgs }));
+  const { instance, creatorFacet } = kit;
+
+  const {
+    issuers: { PoolShares: shareIssuer },
+    brands: { PoolShares: shareBrand },
+  } = await E(zoe).getTerms(instance);
+  produceShareIssuer.resolve(shareIssuer);
+  produceShareBrand.resolve(shareBrand);
+  await publishDisplayInfo(shareBrand, { board, chainStorage });
+
+  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);
+    }),
+  );
+
+  produceInstance.reset();
+  produceInstance.resolve(instance);
+  trace('startFastUSDC done', instance);
+};
+harden(startFastUSDC);
+
+/**
+ * @param {{
+ *   restoreRef: (b: ERef<ManifestBundleRef>) => Promise<Installation>;
+ * }} utils
+ * @param {{
+ *   installKeys: { fastUsdc: ERef<ManifestBundleRef> };
+ *   options: LegibleCapData<FastUSDCConfig>;
+ * }} param1
+ */
+export const getManifestForFastUSDC = (
+  { restoreRef },
+  { installKeys, options },
+) => {
+  return {
+    /** @type {BootstrapManifest} */
+    manifest: {
+      [startFastUSDC.name]: {
+        produce: {
+          fastUsdcKit: true,
+        },
+        consume: {
+          chainStorage: true,
+          chainTimerService: true,
+          localchain: true,
+          cosmosInterchainService: true,
+
+          // limited distribution durin MN2: contract installation
+          startUpgradable: true,
+          zoe: true, // only getTerms() is needed. XXX should be split?
+
+          // widely shared: name services
+          agoricNames: true,
+          namesByAddress: true,
+          board: true,
+        },
+        issuer: {
+          produce: { FastLP: true }, // UNTIL #10432
+        },
+        brand: {
+          produce: { FastLP: true }, // UNTIL #10432
+        },
+        instance: {
+          produce: { fastUsdc: true },
+        },
+        installation: {
+          consume: { fastUsdc: true },
+        },
+      },
+    },
+    installations: {
+      fastUsdc: restoreRef(installKeys.fastUsdc),
+    },
+    options,
+  };
+};

package/src/pool-share-math.js

@@ -0,0 +1,189 @@
+import { AmountMath } from '@agoric/ertp/src/amountMath.js';
+import {
+  divideBy,
+  makeRatio,
+  makeRatioFromAmounts,
+  multiplyBy,
+} from '@agoric/zoe/src/contractSupport/ratio.js';
+import { Fail, q } from '@endo/errors';
+
+const { getValue, add, isEmpty, isEqual, isGTE, subtract } = AmountMath;
+
+/**
+ * @import {PoolStats} from './types';
+ * @import {RepayAmountKWR} from './exos/liquidity-pool';
+ */
+
+/**
+ * Invariant: shareWorth is the pool balance divided by shares outstanding.
+ *
+ * Use `makeParity(make(USDC, epsilon), PoolShares)` for an initial
+ * value, for some negligible `epsilon` such as 1n.
+ *
+ * @typedef {Ratio} ShareWorth
+ */
+
+/**
+ * Make a 1-to-1 ratio between amounts of 2 brands.
+ *
+ * @param {Amount<'nat'>} numerator
+ * @param {Brand<'nat'>} denominatorBrand
+ */
+export const makeParity = (numerator, denominatorBrand) => {
+  const value = getValue(numerator.brand, numerator);
+  return makeRatio(value, numerator.brand, value, denominatorBrand);
+};
+
+/**
+ * @typedef {{
+ *   deposit: {
+ *     give: { USDC: Amount<'nat'> },
+ *     want?: { PoolShare: Amount<'nat'> }
+ *   },
+ *   withdraw: {
+ *     give: { PoolShare: Amount<'nat'> }
+ *     want: { USDC: Amount<'nat'> },
+ *   }
+ * }} USDCProposalShapes
+ */
+
+/**
+ * Compute Shares payout from a deposit proposal, as well as updated shareWorth.
+ *
+ * Clearly:
+ *
+ * sharesOutstanding' = sharesOutstanding + Shares
+ * poolBalance' = poolBalance + ToPool
+ * shareWorth' = poolBalance' / sharesOutstanding'
+ *
+ * In order to maintain the ShareWorth invariant, we need:
+ *
+ * Shares = ToPool / shareWorth'
+ *
+ * Solving for Shares gives:
+ *
+ * Shares = ToPool * sharesOutstanding / poolBalance
+ *
+ * that is:
+ *
+ * Shares = ToPool / shareWorth
+ *
+ * @param {ShareWorth} shareWorth previous to the deposit
+ * @param {USDCProposalShapes['deposit']} proposal
+ * @returns {{ payouts: { PoolShare: Amount<'nat'> }; shareWorth: ShareWorth }}
+ */
+export const depositCalc = (shareWorth, { give, want }) => {
+  assert(!isEmpty(give.USDC)); // nice diagnostic provided by proposalShape
+
+  const { denominator: sharesOutstanding, numerator: poolBalance } = shareWorth;
+
+  const fairPoolShare = divideBy(give.USDC, shareWorth);
+  if (want?.PoolShare) {
+    isGTE(fairPoolShare, want.PoolShare) ||
+      Fail`deposit cannot pay out ${q(want.PoolShare)}; ${q(give.USDC)} only gets ${q(fairPoolShare)}`;
+  }
+  const outstandingPost = add(sharesOutstanding, fairPoolShare);
+  const balancePost = add(poolBalance, give.USDC);
+  const worthPost = makeRatioFromAmounts(balancePost, outstandingPost);
+  return harden({
+    payouts: { PoolShare: fairPoolShare },
+    shareWorth: worthPost,
+  });
+};
+
+/**
+ * Compute payout from a withdraw proposal, along with updated shareWorth
+ *
+ * @param {ShareWorth} shareWorth
+ * @param {USDCProposalShapes['withdraw']} proposal
+ * @returns {{ shareWorth: ShareWorth, payouts: { USDC: Amount<'nat'> }}}
+ */
+export const withdrawCalc = (shareWorth, { give, want }) => {
+  assert(!isEmpty(give.PoolShare));
+  assert(!isEmpty(want.USDC));
+
+  const payout = multiplyBy(give.PoolShare, shareWorth);
+  isGTE(payout, want.USDC) ||
+    Fail`cannot withdraw ${q(want.USDC)}; ${q(give.PoolShare)} only worth ${q(payout)}`;
+  const { denominator: sharesOutstanding, numerator: poolBalance } = shareWorth;
+  !isGTE(want.USDC, poolBalance) ||
+    Fail`cannot withdraw ${q(want.USDC)}; only ${q(poolBalance)} in pool`;
+  const balancePost = subtract(poolBalance, payout);
+  // giving more shares than are outstanding is impossible,
+  // so it's not worth a custom diagnostic. subtract will fail
+  const outstandingPost = subtract(sharesOutstanding, give.PoolShare);
+
+  const worthPost = makeRatioFromAmounts(balancePost, outstandingPost);
+  return harden({ shareWorth: worthPost, payouts: { USDC: payout } });
+};
+
+/**
+ * @param {ShareWorth} shareWorth
+ * @param {Amount<'nat'>} fees
+ */
+export const withFees = (shareWorth, fees) => {
+  const balancePost = add(shareWorth.numerator, fees);
+  return makeRatioFromAmounts(balancePost, shareWorth.denominator);
+};
+
+/**
+ *
+ * @param {Amount<'nat'>} requested
+ * @param {Amount<'nat'>} poolSeatAllocation
+ * @param {Amount<'nat'>} encumberedBalance
+ * @param {PoolStats} poolStats
+ * @throws {Error} if requested is not less than poolSeatAllocation
+ */
+export const borrowCalc = (
+  requested,
+  poolSeatAllocation,
+  encumberedBalance,
+  poolStats,
+) => {
+  // pool must never go empty
+  !isGTE(requested, poolSeatAllocation) ||
+    Fail`Cannot borrow. Requested ${q(requested)} must be less than pool balance ${q(poolSeatAllocation)}.`;
+
+  return harden({
+    encumberedBalance: add(encumberedBalance, requested),
+    poolStats: {
+      ...poolStats,
+      totalBorrows: add(poolStats.totalBorrows, requested),
+    },
+  });
+};
+
+/**
+ * @param {ShareWorth} shareWorth
+ * @param {Allocation} fromSeatAllocation
+ * @param {RepayAmountKWR} amounts
+ * @param {Amount<'nat'>} encumberedBalance aka 'outstanding borrows'
+ * @param {PoolStats} poolStats
+ * @throws {Error} if allocations do not match amounts or Principal exceeds encumberedBalance
+ */
+export const repayCalc = (
+  shareWorth,
+  fromSeatAllocation,
+  amounts,
+  encumberedBalance,
+  poolStats,
+) => {
+  (isEqual(fromSeatAllocation.Principal, amounts.Principal) &&
+    isEqual(fromSeatAllocation.PoolFee, amounts.PoolFee) &&
+    isEqual(fromSeatAllocation.ContractFee, amounts.ContractFee)) ||
+    Fail`Cannot repay. From seat allocation ${q(fromSeatAllocation)} does not equal amounts ${q(amounts)}.`;
+
+  isGTE(encumberedBalance, amounts.Principal) ||
+    Fail`Cannot repay. Principal ${q(amounts.Principal)} exceeds encumberedBalance ${q(encumberedBalance)}.`;
+
+  return harden({
+    shareWorth: withFees(shareWorth, amounts.PoolFee),
+    encumberedBalance: subtract(encumberedBalance, amounts.Principal),
+    poolStats: {
+      ...poolStats,
+      totalRepays: add(poolStats.totalRepays, amounts.Principal),
+      totalPoolFees: add(poolStats.totalPoolFees, amounts.PoolFee),
+      totalContractFees: add(poolStats.totalContractFees, amounts.ContractFee),
+    },
+  });
+};

package/src/type-guards.js

@@ -0,0 +1,95 @@
+import { AmountShape, BrandShape, RatioShape } from '@agoric/ertp';
+import { M } from '@endo/patterns';
+import { PendingTxStatus } from './constants.js';
+
+/**
+ * @import {TypedPattern} from '@agoric/internal';
+ * @import {FastUsdcTerms} from './fast-usdc.contract.js';
+ * @import {USDCProposalShapes} from './pool-share-math.js';
+ * @import {CctpTxEvidence, FeeConfig, PendingTx, PoolMetrics} from './types.js';
+ */
+
+/**
+ * @param {Brand} brand must be a 'nat' brand, not checked
+ * @param {NatValue} [min]
+ */
+export const makeNatAmountShape = (brand, min) =>
+  harden({ brand, value: min ? M.gte(min) : M.nat() });
+
+/** @param {Record<'PoolShares' | 'USDC', Brand<'nat'>>} brands */
+export const makeProposalShapes = ({ PoolShares, USDC }) => {
+  /** @type {TypedPattern<USDCProposalShapes['deposit']>} */
+  const deposit = M.splitRecord(
+    { give: { USDC: makeNatAmountShape(USDC, 1n) } },
+    { want: { PoolShare: makeNatAmountShape(PoolShares) } },
+  );
+  /** @type {TypedPattern<USDCProposalShapes['withdraw']>} */
+  const withdraw = M.splitRecord({
+    give: { PoolShare: makeNatAmountShape(PoolShares, 1n) },
+    want: { USDC: makeNatAmountShape(USDC, 1n) },
+  });
+  return harden({ deposit, withdraw });
+};
+
+/** @type {TypedPattern<FastUsdcTerms>} */
+export const FastUSDCTermsShape = harden({
+  usdcDenom: M.string(),
+});
+
+/** @type {TypedPattern<string>} */
+export const EvmHashShape = M.string({
+  stringLengthLimit: 66,
+});
+harden(EvmHashShape);
+
+/** @type {TypedPattern<CctpTxEvidence>} */
+export const CctpTxEvidenceShape = {
+  aux: {
+    forwardingChannel: M.string(),
+    recipientAddress: M.string(),
+  },
+  blockHash: EvmHashShape,
+  blockNumber: M.bigint(),
+  blockTimestamp: M.bigint(),
+  chainId: M.number(),
+  tx: {
+    amount: M.bigint(),
+    forwardingAddress: M.string(),
+  },
+  txHash: EvmHashShape,
+};
+harden(CctpTxEvidenceShape);
+
+/** @type {TypedPattern<PendingTx>} */
+// @ts-expect-error TypedPattern not recognized as record
+export const PendingTxShape = {
+  ...CctpTxEvidenceShape,
+  status: M.or(...Object.values(PendingTxStatus)),
+};
+harden(PendingTxShape);
+
+export const EudParamShape = {
+  EUD: M.string(),
+};
+harden(EudParamShape);
+
+const NatAmountShape = { brand: BrandShape, value: M.nat() };
+/** @type {TypedPattern<FeeConfig>} */
+export const FeeConfigShape = {
+  flat: NatAmountShape,
+  variableRate: RatioShape,
+  maxVariable: NatAmountShape,
+  contractRate: RatioShape,
+};
+harden(FeeConfigShape);
+
+/** @type {TypedPattern<PoolMetrics>} */
+export const PoolMetricsShape = {
+  encumberedBalance: AmountShape,
+  shareWorth: RatioShape,
+  totalContractFees: AmountShape,
+  totalPoolFees: AmountShape,
+  totalBorrows: AmountShape,
+  totalRepays: AmountShape,
+};
+harden(PoolMetricsShape);

package/src/types-index.d.ts

@@ -0,0 +1 @@
+export type * from './types.js';

package/src/types-index.js

@@ -0,0 +1 @@
+export {};

package/src/types.ts

@@ -0,0 +1,58 @@
+import type { ChainAddress } from '@agoric/orchestration';
+import type { IBCChannelID } from '@agoric/vats';
+import type { Amount } from '@agoric/ertp';
+import type { PendingTxStatus } from './constants.js';
+
+export type EvmHash = `0x${string}`;
+export type NobleAddress = `noble1${string}`;
+
+export interface CctpTxEvidence {
+  /** from Noble RPC */
+  aux: {
+    forwardingChannel: IBCChannelID;
+    recipientAddress: ChainAddress['value'];
+  };
+  blockHash: EvmHash;
+  blockNumber: bigint;
+  blockTimestamp: bigint;
+  chainId: number;
+  /** data covered by signature (aka txHash) */
+  tx: {
+    amount: bigint;
+    forwardingAddress: NobleAddress;
+  };
+  txHash: EvmHash;
+}
+
+export type LogFn = (...args: unknown[]) => void;
+
+export interface PendingTx extends CctpTxEvidence {
+  status: PendingTxStatus;
+}
+
+/** internal key for `StatusManager` exo */
+export type PendingTxKey = `pendingTx:${string}`;
+
+/** internal key for `StatusManager` exo */
+export type SeenTxKey = `seenTx:${string}`;
+
+export type FeeConfig = {
+  flat: Amount<'nat'>;
+  variableRate: Ratio;
+  maxVariable: Amount<'nat'>;
+  contractRate: Ratio;
+};
+
+export interface PoolStats {
+  totalBorrows: Amount<'nat'>;
+  totalContractFees: Amount<'nat'>;
+  totalPoolFees: Amount<'nat'>;
+  totalRepays: Amount<'nat'>;
+}
+
+export interface PoolMetrics extends PoolStats {
+  encumberedBalance: Amount<'nat'>;
+  shareWorth: Ratio;
+}
+
+export type * from './constants.js';

package/src/util/agoric.js

@@ -0,0 +1,12 @@
+/** @import { VStorage } from '@agoric/client-utils' */
+
+export const queryFastUSDCLocalChainAccount = async (
+  /** @type {VStorage} */ vstorage,
+  out = console,
+) => {
+  const agoricAddr = await vstorage.readLatest(
+    'published.fastUSDC.settlementAccount',
+  );
+  out.log(`Got Fast USDC Local Chain Account ${agoricAddr}`);
+  return agoricAddr;
+};

package/src/util/cctp.js

@@ -0,0 +1,71 @@
+import { Buffer } from 'node:buffer';
+import { bech32 } from 'bech32';
+import { ethers } from 'ethers';
+
+/**
+ * Adapted from https://docs.noble.xyz/cctp/mint#encoding
+ *
+ * @param {string} address
+ * @returns {string}
+ */
+export const encodeBech32Address = address => {
+  const decoded = bech32.decode(address);
+  const rawBytes = Buffer.from(bech32.fromWords(decoded.words));
+
+  const padded = Buffer.alloc(32);
+  rawBytes.copy(padded, 32 - rawBytes.length);
+
+  return `0x${padded.toString('hex')}`;
+};
+
+const tokenAbi = ['function approve(address spender, uint256 value) external'];
+
+const contractAbi = [
+  'function depositForBurn(uint256 amount, uint32 destinationDomain, bytes32 mintRecipient, address burnToken) external',
+];
+
+export const makeProvider = (/** @type {string} */ rpc) =>
+  new ethers.JsonRpcProvider(rpc);
+
+const USDC_DECIMALS = 6;
+// For CCTP, noble's domain is universally "4"
+const NOBLE_DOMAIN = 4;
+
+export const depositForBurn = async (
+  /** @type {ethers.JsonRpcProvider} */ provider,
+  /** @type {string} */ ethSeed,
+  /** @type {string} */ tokenMessengerAddress,
+  /** @type {string} */ tokenAddress,
+  /** @type {string} */ destination,
+  /** @type {string} */ amount,
+  out = console,
+) => {
+  const privateKey = ethSeed;
+  const wallet = new ethers.Wallet(privateKey, provider);
+  const contractAddress = tokenMessengerAddress;
+  const token = new ethers.Contract(tokenAddress, tokenAbi, wallet);
+  const contract = new ethers.Contract(contractAddress, contractAbi, wallet);
+  const parsedAmount = ethers.parseUnits(amount, USDC_DECIMALS);
+  out.log('approving');
+  const approveTx = await token.approve(contractAddress, parsedAmount);
+  out.log('Transaction sent, waiting for confirmation...');
+  const approveReceipt = await approveTx.wait();
+  out.log('Transaction confirmed in block', approveReceipt.blockNumber);
+  out.log('Transaction hash:', approveReceipt.hash);
+
+  const mintRecipient = encodeBech32Address(destination);
+  out.log('depositing for burn', parsedAmount, 4, mintRecipient, tokenAddress);
+  const tx = await contract.depositForBurn(
+    parsedAmount,
+    NOBLE_DOMAIN,
+    mintRecipient,
+    tokenAddress,
+  );
+
+  out.log('Transaction sent, waiting for confirmation...');
+  const receipt = await tx.wait();
+
+  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.');
+};