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

package/src/exos/operator-kit.js

@@ -1,120 +0,0 @@
-import { makeTracer } from '@agoric/internal';
-import { Fail } from '@endo/errors';
-import { M } from '@endo/patterns';
-import { CctpTxEvidenceShape } from '../type-guards.js';
-
-const trace = makeTracer('TxOperator');
-
-/**
- * @import {Zone} from '@agoric/zone';
- * @import {CctpTxEvidence} from '../types.js';
- */
-
-/**
- * @typedef {object} OperatorPowers
- * @property {(evidence: CctpTxEvidence, operatorKit: OperatorKit) => void} submitEvidence
- */
-
-/**
- * @typedef {object} OperatorStatus
- * @property {boolean} [disabled]
- * @property {string} operatorId
- */
-
-/**
- * @typedef {Readonly<{ operatorId: string, powers: OperatorPowers }> & {disabled: boolean}} State
- */
-
-const OperatorKitI = {
-  admin: M.interface('Admin', {
-    disable: M.call().returns(),
-  }),
-
-  invitationMakers: M.interface('InvitationMakers', {
-    SubmitEvidence: M.call(CctpTxEvidenceShape).returns(M.promise()),
-  }),
-
-  operator: M.interface('Operator', {
-    submitEvidence: M.call(CctpTxEvidenceShape).returns(M.promise()),
-    getStatus: M.call().returns(M.record()),
-  }),
-};
-
-/**
- * @param {Zone} zone
- * @param {{ makeInertInvitation: Function }} staticPowers
- */
-export const prepareOperatorKit = (zone, staticPowers) =>
-  zone.exoClassKit(
-    'Operator Kit',
-    OperatorKitI,
-    /**
-     * @param {string} operatorId
-     * @param {OperatorPowers} powers facet of the durable transaction feed
-     * @returns {State}
-     */
-    (operatorId, powers) => {
-      return {
-        operatorId,
-        powers,
-        disabled: false,
-      };
-    },
-    {
-      admin: {
-        disable() {
-          trace(`operator ${this.state.operatorId} disabled`);
-          this.state.disabled = true;
-        },
-      },
-      /**
-       * NB: when this kit is an offer result, the smart-wallet will detect the `invitationMakers`
-       * key and save it for future offers.
-       */
-      invitationMakers: {
-        /**
-         * Provide an API call in the form of an invitation maker, so that the
-         * capability is available in the smart-wallet bridge.
-         *
-         * NB: The `Invitation` object is evidence that the operation took
-         * place, rather than as a means of performing it as in the
-         * fluxAggregator contract used for price oracles.
-         *
-         * @param {CctpTxEvidence} evidence
-         * @returns {Promise<Invitation>}
-         */
-        async SubmitEvidence(evidence) {
-          const { operator } = this.facets;
-          // TODO(bootstrap integration): cause this call to throw and confirm that it
-          // shows up in the the smart-wallet UpdateRecord `error` property
-          await operator.submitEvidence(evidence);
-          return staticPowers.makeInertInvitation(
-            'evidence was pushed in the invitation maker call',
-          );
-        },
-      },
-      operator: {
-        /**
-         * submit evidence from this operator
-         *
-         * @param {CctpTxEvidence} evidence
-         */
-        async submitEvidence(evidence) {
-          const { state } = this;
-          !state.disabled || Fail`submitEvidence for disabled operator`;
-          const result = state.powers.submitEvidence(evidence, this.facets);
-          return result;
-        },
-        /** @returns {OperatorStatus} */
-        getStatus() {
-          const { state } = this;
-          return {
-            operatorId: state.operatorId,
-            disabled: state.disabled,
-          };
-        },
-      },
-    },
-  );
-
-/** @typedef {ReturnType<ReturnType<typeof prepareOperatorKit>>} OperatorKit */

package/src/exos/settler.js

@@ -1,97 +0,0 @@
-import { assertAllDefined } from '@agoric/internal';
-import { atob } from '@endo/base64';
-import { makeError, q } from '@endo/errors';
-import { M } from '@endo/patterns';
-
-import { addressTools } from '../utils/address.js';
-
-/**
- * @import {FungibleTokenPacketData} from '@agoric/cosmic-proto/ibc/applications/transfer/v2/packet.js';
- * @import {Denom} from '@agoric/orchestration';
- * @import {IBCChannelID, VTransferIBCEvent} from '@agoric/vats';
- * @import {Zone} from '@agoric/zone';
- * @import {NobleAddress} from '../types.js';
- * @import {StatusManager} from './status-manager.js';
- */
-
-/**
- * @param {Zone} zone
- * @param {object} caps
- * @param {StatusManager} caps.statusManager
- */
-export const prepareSettler = (zone, { statusManager }) => {
-  assertAllDefined({ statusManager });
-  return zone.exoClass(
-    'Fast USDC Settler',
-    M.interface('SettlerI', {
-      receiveUpcall: M.call(M.record()).returns(M.promise()),
-    }),
-    /**
-     *
-     * @param {{
-     *   sourceChannel: IBCChannelID;
-     *   remoteDenom: Denom
-     * }} config
-     */
-    config => harden(config),
-    {
-      /** @param {VTransferIBCEvent} event */
-      async receiveUpcall(event) {
-        if (event.packet.source_channel !== this.state.sourceChannel) {
-          // TODO #10390 log all early returns
-          // only interested in packets from the issuing chain
-          return;
-        }
-        const tx = /** @type {FungibleTokenPacketData} */ (
-          JSON.parse(atob(event.packet.data))
-        );
-        if (tx.denom !== this.state.remoteDenom) {
-          // only interested in uusdc
-          return;
-        }
-
-        if (!addressTools.hasQueryParams(tx.receiver)) {
-          // only interested in receivers with query params
-          return;
-        }
-
-        const { EUD } = addressTools.getQueryParams(tx.receiver);
-        if (!EUD) {
-          // only interested in receivers with EUD parameter
-          return;
-        }
-
-        // TODO discern between SETTLED and OBSERVED; each has different fees/destinations
-        const hasPendingSettlement = statusManager.hasPendingSettlement(
-          // given the sourceChannel check, we can be certain of this cast
-          /** @type {NobleAddress} */ (tx.sender),
-          BigInt(tx.amount),
-        );
-        if (!hasPendingSettlement) {
-          // TODO FAILURE PATH -> put money in recovery account or .transfer to receiver
-          // TODO should we have an ORPHANED TxStatus for this?
-          throw makeError(
-            `🚨 No pending settlement found for ${q(tx.sender)} ${q(tx.amount)}`,
-          );
-        }
-
-        // TODO disperse funds
-        // ~1. fee to contractFeeAccount
-        // ~2. remainder in poolAccount
-
-        // update status manager, marking tx `SETTLED`
-        statusManager.settle(
-          /** @type {NobleAddress} */ (tx.sender),
-          BigInt(tx.amount),
-        );
-      },
-    },
-    {
-      stateShape: harden({
-        sourceChannel: M.string(),
-        remoteDenom: M.string(),
-      }),
-    },
-  );
-};
-harden(prepareSettler);

package/src/exos/status-manager.js

@@ -1,176 +0,0 @@
-import { M } from '@endo/patterns';
-import { makeError, q } from '@endo/errors';
-
-import { appendToStoredArray } from '@agoric/store/src/stores/store-utils.js';
-import { CctpTxEvidenceShape, PendingTxShape } from '../type-guards.js';
-import { PendingTxStatus } from '../constants.js';
-
-/**
- * @import {MapStore, SetStore} from '@agoric/store';
- * @import {Zone} from '@agoric/zone';
- * @import {CctpTxEvidence, NobleAddress, SeenTxKey, PendingTxKey, PendingTx} from '../types.js';
- */
-
-/**
- * Create the key for the pendingTxs MapStore.
- *
- * The key is a composite of `txHash` and `chainId` and not meant to be
- * parsable.
- *
- * @param {NobleAddress} addr
- * @param {bigint} amount
- * @returns {PendingTxKey}
- */
-const makePendingTxKey = (addr, amount) =>
-  `pendingTx:${JSON.stringify([addr, String(amount)])}`;
-
-/**
- * Get the key for the pendingTxs MapStore.
- *
- * @param {CctpTxEvidence} evidence
- * @returns {PendingTxKey}
- */
-const pendingTxKeyOf = evidence => {
-  const { amount, forwardingAddress } = evidence.tx;
-  return makePendingTxKey(forwardingAddress, amount);
-};
-
-/**
- * Get the key for the seenTxs SetStore.
- *
- * The key is a composite of `NobleAddress` and transaction `amount` and not
- * meant to be parsable.
- *
- * @param {CctpTxEvidence} evidence
- * @returns {SeenTxKey}
- */
-const seenTxKeyOf = evidence => {
-  const { txHash, chainId } = evidence;
-  return `seenTx:${JSON.stringify([txHash, chainId])}`;
-};
-
-/**
- * The `StatusManager` keeps track of Pending and Seen Transactions
- * via {@link PendingTxStatus} states, aiding in coordination between the `Advancer`
- * and `Settler`.
- *
- * XXX consider separate facets for `Advancing` and `Settling` capabilities.
- *
- * @param {Zone} zone
- */
-export const prepareStatusManager = zone => {
-  /** @type {MapStore<PendingTxKey, PendingTx[]>} */
-  const pendingTxs = zone.mapStore('PendingTxs', {
-    keyShape: M.string(),
-    valueShape: M.arrayOf(PendingTxShape),
-  });
-
-  /** @type {SetStore<SeenTxKey>} */
-  const seenTxs = zone.setStore('SeenTxs', {
-    keyShape: M.string(),
-  });
-
-  /**
-   * Ensures that `txHash+chainId` has not been processed
-   * and adds entry to `seenTxs` set.
-   *
-   * Also records the CctpTxEvidence and status in `pendingTxs`.
-   *
-   * @param {CctpTxEvidence} evidence
-   * @param {PendingTxStatus} status
-   */
-  const recordPendingTx = (evidence, status) => {
-    const seenKey = seenTxKeyOf(evidence);
-    if (seenTxs.has(seenKey)) {
-      throw makeError(`Transaction already seen: ${q(seenKey)}`);
-    }
-    seenTxs.add(seenKey);
-
-    appendToStoredArray(
-      pendingTxs,
-      pendingTxKeyOf(evidence),
-      harden({ ...evidence, status }),
-    );
-  };
-
-  return zone.exo(
-    'Fast USDC Status Manager',
-    M.interface('StatusManagerI', {
-      advance: M.call(CctpTxEvidenceShape).returns(M.undefined()),
-      observe: M.call(CctpTxEvidenceShape).returns(M.undefined()),
-      hasPendingSettlement: M.call(M.string(), M.bigint()).returns(M.boolean()),
-      settle: M.call(M.string(), M.bigint()).returns(M.undefined()),
-      lookupPending: M.call(M.string(), M.bigint()).returns(
-        M.arrayOf(PendingTxShape),
-      ),
-    }),
-    {
-      /**
-       * Add a new transaction with ADVANCED status
-       * @param {CctpTxEvidence} evidence
-       */
-      advance(evidence) {
-        recordPendingTx(evidence, PendingTxStatus.Advanced);
-      },
-
-      /**
-       * Add a new transaction with OBSERVED status
-       * @param {CctpTxEvidence} evidence
-       */
-      observe(evidence) {
-        recordPendingTx(evidence, PendingTxStatus.Observed);
-      },
-
-      /**
-       * Find an `ADVANCED` or `OBSERVED` tx waiting to be `SETTLED`
-       *
-       * @param {NobleAddress} address
-       * @param {bigint} amount
-       * @returns {boolean}
-       */
-      hasPendingSettlement(address, amount) {
-        const key = makePendingTxKey(address, amount);
-        const pending = pendingTxs.get(key);
-        return !!pending.length;
-      },
-
-      /**
-       * Mark an `ADVANCED` or `OBSERVED` transaction as `SETTLED` and remove it
-       *
-       * @param {NobleAddress} address
-       * @param {bigint} amount
-       */
-      settle(address, amount) {
-        const key = makePendingTxKey(address, amount);
-        const pending = pendingTxs.get(key);
-
-        if (!pending.length) {
-          throw makeError(`No unsettled entry for ${q(key)}`);
-        }
-
-        const pendingCopy = [...pending];
-        pendingCopy.shift();
-        // TODO, vstorage update for `TxStatus.Settled`
-        pendingTxs.set(key, harden(pendingCopy));
-      },
-
-      /**
-       * Lookup all pending entries for a given address and amount
-       *
-       * @param {NobleAddress} address
-       * @param {bigint} amount
-       * @returns {PendingTx[]}
-       */
-      lookupPending(address, amount) {
-        const key = makePendingTxKey(address, amount);
-        if (!pendingTxs.has(key)) {
-          throw makeError(`Key ${q(key)} not yet observed`);
-        }
-        return pendingTxs.get(key);
-      },
-    },
-  );
-};
-harden(prepareStatusManager);
-
-/** @typedef {ReturnType<typeof prepareStatusManager>} StatusManager */

package/src/exos/transaction-feed.js

@@ -1,180 +0,0 @@
-import { makeTracer } from '@agoric/internal';
-import { prepareDurablePublishKit } from '@agoric/notifier';
-import { M } from '@endo/patterns';
-import { CctpTxEvidenceShape } from '../type-guards.js';
-import { defineInertInvitation } from '../utils/zoe.js';
-import { prepareOperatorKit } from './operator-kit.js';
-
-/**
- * @import {Zone} from '@agoric/zone';
- * @import {OperatorKit} from './operator-kit.js';
- * @import {CctpTxEvidence} from '../types.js';
- */
-
-const trace = makeTracer('TxFeed', true);
-
-/** Name in the invitation purse (keyed also by this contract instance) */
-export const INVITATION_MAKERS_DESC = 'oracle operator invitation';
-
-const TransactionFeedKitI = harden({
-  operatorPowers: M.interface('Transaction Feed Admin', {
-    submitEvidence: M.call(CctpTxEvidenceShape, M.any()).returns(),
-  }),
-  creator: M.interface('Transaction Feed Creator', {
-    // TODO narrow the return shape to OperatorKit
-    initOperator: M.call(M.string()).returns(M.record()),
-    makeOperatorInvitation: M.call(M.string()).returns(M.promise()),
-    removeOperator: M.call(M.string()).returns(),
-  }),
-  public: M.interface('Transaction Feed Public', {
-    getEvidenceSubscriber: M.call().returns(M.remotable()),
-  }),
-});
-
-/**
- * @param {Zone} zone
- * @param {ZCF} zcf
- */
-export const prepareTransactionFeedKit = (zone, zcf) => {
-  const kinds = zone.mapStore('Kinds');
-  const makeDurablePublishKit = prepareDurablePublishKit(
-    kinds,
-    'Transaction Feed',
-  );
-  /** @type {PublishKit<CctpTxEvidence>} */
-  const { publisher, subscriber } = makeDurablePublishKit();
-
-  const makeInertInvitation = defineInertInvitation(zcf, 'submitting evidence');
-
-  const makeOperatorKit = prepareOperatorKit(zone, {
-    makeInertInvitation,
-  });
-
-  return zone.exoClassKit(
-    'Fast USDC Feed',
-    TransactionFeedKitI,
-    () => {
-      /** @type {MapStore<string, OperatorKit>} */
-      const operators = zone.mapStore('operators', {
-        durable: true,
-      });
-      /** @type {MapStore<string, MapStore<string, CctpTxEvidence>>} */
-      const pending = zone.mapStore('pending', {
-        durable: true,
-      });
-      return { operators, pending };
-    },
-    {
-      creator: {
-        /**
-         * An "operator invitation" is an invitation to be an operator in the
-         * oracle network, with the able to submit data to submit evidence of
-         * CCTP transactions.
-         *
-         * @param {string} operatorId unique per contract instance
-         * @returns {Promise<Invitation<OperatorKit>>}
-         */
-        makeOperatorInvitation(operatorId) {
-          const { creator } = this.facets;
-          trace('makeOperatorInvitation', operatorId);
-
-          return zcf.makeInvitation(
-            /** @type {OfferHandler<OperatorKit>} */
-            seat => {
-              seat.exit();
-              return creator.initOperator(operatorId);
-            },
-            INVITATION_MAKERS_DESC,
-          );
-        },
-        /** @param {string} operatorId */
-        initOperator(operatorId) {
-          const { operators, pending } = this.state;
-          trace('initOperator', operatorId);
-
-          const operatorKit = makeOperatorKit(
-            operatorId,
-            this.facets.operatorPowers,
-          );
-          operators.init(operatorId, operatorKit);
-          pending.init(
-            operatorId,
-            zone.detached().mapStore('pending evidence'),
-          );
-
-          return operatorKit;
-        },
-
-        /** @param {string} operatorId */
-        async removeOperator(operatorId) {
-          const { operators } = this.state;
-          trace('removeOperator', operatorId);
-          const operatorKit = operators.get(operatorId);
-          operatorKit.admin.disable();
-          operators.delete(operatorId);
-        },
-      },
-      operatorPowers: {
-        /**
-         * Add evidence from an operator.
-         *
-         * @param {CctpTxEvidence} evidence
-         * @param {OperatorKit} operatorKit
-         */
-        submitEvidence(evidence, operatorKit) {
-          const { pending } = this.state;
-          trace(
-            'submitEvidence',
-            operatorKit.operator.getStatus().operatorId,
-            evidence,
-          );
-          const { operatorId } = operatorKit.operator.getStatus();
-
-          // TODO should this verify that the operator is one made by this exo?
-          // This doesn't work...
-          // operatorKit === operators.get(operatorId) ||
-          //   Fail`operatorKit mismatch`;
-
-          // TODO validate that it's a valid for Fast USDC before accepting
-          // E.g. that the `recipientAddress` is the FU settlement account and that
-          // the EUD is a chain supported by FU.
-          const { txHash } = evidence;
-
-          // accept the evidence
-          {
-            const pendingStore = pending.get(operatorId);
-            if (pendingStore.has(txHash)) {
-              trace(`operator ${operatorId} already reported ${txHash}`);
-            } else {
-              pendingStore.init(txHash, evidence);
-            }
-          }
-
-          // check agreement
-          const found = [...pending.values()].filter(store =>
-            store.has(txHash),
-          );
-          // TODO determine the real policy for checking agreement
-          if (found.length < pending.getSize()) {
-            // not all have seen it
-            return;
-          }
-
-          // TODO verify that all found deep equal
-
-          // all agree, so remove from pending and publish
-          for (const pendingStore of pending.values()) {
-            pendingStore.delete(txHash);
-          }
-          publisher.publish(evidence);
-        },
-      },
-      public: {
-        getEvidenceSubscriber: () => subscriber,
-      },
-    },
-  );
-};
-harden(prepareTransactionFeedKit);
-
-/** @typedef {ReturnType<ReturnType<typeof prepareTransactionFeedKit>>} TransactionFeedKit */