@agoric/inter-protocol 0.13.3 → 0.13.4-dev-d32a66a.0

package/src/stakeFactory/stakeFactory.js

@@ -1,236 +0,0 @@
-// @ts-check
-// @jessie-check
-import { AmountMath } from '@agoric/ertp';
-import { handleParamGovernance, ParamTypes } from '@agoric/governance';
-import { E, Far } from '@endo/far';
-import { makeMakeCollectFeesInvitation } from '../collectFees.js';
-import { makeAttestationFacets } from './attestation.js';
-import { ManagerKW as KW } from './constants.js';
-import { makeStakeFactoryKit } from './stakeFactoryKit.js';
-import { makeStakeFactoryManager } from './stakeFactoryManager.js';
-
-const { details: X } = assert;
-const { values } = Object;
-
-/**
- * Provide loans on the basis of staked assets that earn rewards.
- *
- * In addition to brands and issuers for `Staked`, `Minted`, and attestation,
- * terms of the contract include a periodic `InterestRate`
- * plus a `LoanFee` proportional to the amount borrowed, as well as
- * a `MintingRatio` of funds to (mint and) loan per unit of staked asset.
- * These terms are subject to change by the `Electorate`
- * and `electionManager` terms.
- *
- * @typedef {{
- *   DebtLimit: 'amount',
- *   MintingRatio: 'ratio',
- *   InterestRate: 'ratio',
- *   LoanFee: 'ratio',
- * }} StakeFactoryParams
- *
- * As in vaultFactory, `timerService` provides the periodic signal to
- * charge interest according to `chargingPeriod` and `recordingPeriod`.
- *
- * @typedef { GovernanceTerms<StakeFactoryParams> & {
- *   timerService: TimerService,
- *   chargingPeriod: bigint,
- *   recordingPeriod: bigint,
- *   lienAttestationName?: string,
- * }} StakeFactoryTerms
- *
- * The public facet provides access to invitations to get a loan
- * or to return an attestation in order to release a lien on staked assets.
- *
- * @typedef {{
- *   makeLoanInvitation: () => Promise<Invitation>,
- *   makeReturnAttInvitation: () => Promise<Invitation>,
- * }} StakeFactoryPublic
- *
- * To take out a loan, get an `AttestationMaker` for your address from
- * the creator of this contract, and use
- * `E(attMaker).makeAttestation(stakedAmount)` to take out a lien
- * and get a payment that attests to the lien. Provide the payment
- * in the `Attestation` keyword of an offer,
- * using `{ want: { Debt: amountWanted }}`.
- *
- * Then, using the invitationMakers pattern, use `AdjustBalances` to
- * pay down the loan or otherwise adjust the `Debt` and `Attestation`.
- *
- * Finally, `Close` the loan, providing `{ give: Debt: debtAmount }}`
- *
- * To start the contract, authorize minting assets by providing `feeMintAccess`
- * and provide access to the underlying staking infrastructure in `lienBridge`.
- *
- * @typedef {{
- *   feeMintAccess: FeeMintAccess,
- *   initialPoserInvitation: Invitation,
- *   lienBridge: ERef<StakingAuthority>,
- *   storageNode: StorageNode,
- *   marshaller: Marshaller,
- * }} StakeFactoryPrivateArgs
- *
- * The creator facet can make an `AttestationMaker` for each account, which
- * authorizes placing a lien some of the staked assets in that account.
- * @typedef {{
- *   provideAttestationMaker: (addr: string) => AttestationTool,
- *   makeCollectFeesInvitation: () => Promise<Invitation>,
- * }} StakeFactoryCreator
- *
- * @type {ContractStartFn<StakeFactoryPublic, ERef<GovernedCreatorFacet<StakeFactoryCreator>>,
- *                        StakeFactoryTerms, StakeFactoryPrivateArgs>}
- */
-export const start = async (
-  zcf,
-  {
-    feeMintAccess,
-    initialPoserInvitation,
-    lienBridge,
-    storageNode,
-    marshaller,
-  },
-) => {
-  const {
-    brands: { Stake: stakeBrand },
-    timerService,
-    chargingPeriod,
-    recordingPeriod,
-  } = zcf.getTerms();
-  assert.typeof(chargingPeriod, 'bigint', 'chargingPeriod must be a bigint');
-  assert.typeof(recordingPeriod, 'bigint', 'recordingPeriod must be a bigint');
-  assert(storageNode && marshaller, 'missing storageNode or marshaller');
-
-  /** @type {ZCFMint<'nat'>} */
-  const debtMint = await zcf.registerFeeMint(KW.Debt, feeMintAccess);
-  const { brand: debtBrand } = debtMint.getIssuerRecord();
-
-  const att = await makeAttestationFacets(zcf, stakeBrand, lienBridge);
-  const attestBrand = await E(att.publicFacet).getBrand();
-
-  const { augmentPublicFacet, makeGovernorFacet, params } =
-    await handleParamGovernance(
-      zcf,
-      initialPoserInvitation,
-      {
-        DebtLimit: ParamTypes.AMOUNT,
-        InterestRate: ParamTypes.RATIO,
-        LoanFee: ParamTypes.RATIO,
-        MintingRatio: ParamTypes.RATIO,
-      },
-      storageNode,
-      marshaller,
-    );
-
-  /** For temporary staging of newly minted tokens */
-  const { zcfSeat: mintSeat } = zcf.makeEmptySeatKit();
-  const { zcfSeat: rewardPoolSeat } = zcf.makeEmptySeatKit();
-
-  /**
-   * Let the manager add rewards to the rewardPoolSeat
-   * without directly exposing the rewardPoolSeat to them.
-   *
-   * @type {MintAndReallocate}
-   */
-  const mintAndReallocate = (toMint, fee, seat, ...otherSeats) => {
-    const kept = AmountMath.subtract(toMint, fee);
-    debtMint.mintGains(harden({ [KW.Debt]: toMint }), mintSeat);
-    try {
-      rewardPoolSeat.incrementBy(
-        mintSeat.decrementBy(harden({ [KW.Debt]: fee })),
-      );
-      seat.incrementBy(mintSeat.decrementBy(harden({ [KW.Debt]: kept })));
-      zcf.reallocate(
-        rewardPoolSeat,
-        mintSeat,
-        seat,
-        ...otherSeats.filter(s => s.hasStagedAllocation()),
-      );
-    } catch (e) {
-      mintSeat.clear();
-      rewardPoolSeat.clear();
-      // Make best efforts to burn the newly minted tokens, for hygiene.
-      // That only relies on the internal mint, so it cannot fail without
-      // there being much larger problems. There's no risk of tokens being
-      // stolen here because the staging for them was already cleared.
-      debtMint.burnLosses(harden({ [KW.Debt]: toMint }), mintSeat);
-      throw e;
-    } finally {
-      assert(
-        values(mintSeat.getCurrentAllocation()).every(a =>
-          AmountMath.isEmpty(a),
-        ),
-        X`Stage should be empty of Debt`,
-      );
-    }
-    // TODO add aggregate debt tracking at the vaultFactory level #4482
-    // totalDebt = AmountMath.add(totalDebt, toMint);
-  };
-
-  const burnDebt = (toBurn, seat) => {
-    debtMint.burnLosses(harden({ [KW.Debt]: toBurn }), seat);
-  };
-
-  const mintPowers = Far('mintPowers', {
-    burnDebt,
-    getGovernedParams: () => params, // XXX until governance support is durable
-    mintAndReallocate,
-  });
-
-  const startTimeStamp = await E(timerService).getCurrentTimestamp();
-  const { manager } = makeStakeFactoryManager(
-    zcf,
-    debtMint,
-    harden({ Attestation: attestBrand, debt: debtBrand, Stake: stakeBrand }),
-    mintPowers,
-    { timerService, chargingPeriod, recordingPeriod, startTimeStamp },
-  );
-
-  /**
-   * @param {ZCFSeat} seat
-   */
-  const offerHandler = seat => {
-    const { helper, pot } = makeStakeFactoryKit(zcf, seat, manager);
-
-    return harden({
-      publicSubscribers: {
-        // XXX should come from manager directly https://github.com/Agoric/agoric-sdk/issues/5814
-        asset: manager.getAssetSubscriber(),
-        vault: pot.getSubscriber(),
-      },
-      invitationMakers: Far('invitation makers', {
-        AdjustBalances: () =>
-          zcf.makeInvitation(
-            seatx => helper.adjustBalancesHook(seatx),
-            'AdjustBalances',
-          ),
-        CloseVault: () =>
-          zcf.makeInvitation(seatx => helper.closeHook(seatx), 'CloseVault'),
-      }),
-      vault: pot,
-    });
-  };
-
-  const publicFacet = augmentPublicFacet(
-    harden({
-      makeLoanInvitation: () =>
-        zcf.makeInvitation(offerHandler, 'make stakeFactory'),
-      makeReturnAttInvitation: att.publicFacet.makeReturnAttInvitation,
-    }),
-  );
-
-  /** @type {ERef<StakeFactoryCreator>} */
-  const creatorFacet = Far('stakeFactory creator', {
-    provideAttestationMaker: att.creatorFacet.provideAttestationTool,
-    makeCollectFeesInvitation: () => {
-      return makeMakeCollectFeesInvitation(
-        zcf,
-        rewardPoolSeat,
-        debtBrand,
-        'Minted',
-      ).makeCollectFeesInvitation();
-    },
-  });
-
-  return { publicFacet, creatorFacet: makeGovernorFacet(creatorFacet) };
-};
-harden(start);

package/src/stakeFactory/stakeFactoryKit.js

@@ -1,455 +0,0 @@
-// @ts-check
-// @jessie-check
-import { AmountMath, AssetKind } from '@agoric/ertp';
-import { assertProposalShape } from '@agoric/zoe/src/contractSupport/index.js';
-import { ceilMultiplyBy } from '@agoric/zoe/src/contractSupport/ratio.js';
-import { makePublishKit } from '@agoric/notifier';
-import { bindAllMethods } from '@agoric/internal';
-import { M, matches } from '@agoric/store';
-import { defineKindMulti } from '@agoric/vat-data';
-import { makeTracer } from '../makeTracer.js';
-import { addSubtract, assertOnlyKeys, stageDelta } from '../contractSupport.js';
-import { calculateCurrentDebt, reverseInterest } from '../interest-math.js';
-import { ManagerKW as KW } from './constants.js';
-
-const { details: X, quote: q } = assert;
-
-const trace = makeTracer('R1');
-
-/**
- * Calculate the fee, the amount to mint and the resulting debt.
- *
- * @param {Ratio} feeCoeff fee coefficient
- * @param {Amount} currentDebt
- * @param {Amount} giveAmount
- * @param {Amount} wantAmount
- */
-const calculateFee = (feeCoeff, currentDebt, giveAmount, wantAmount) => {
-  const fee = ceilMultiplyBy(wantAmount, feeCoeff);
-  const toMint = AmountMath.add(wantAmount, fee);
-  const newDebt = addSubtract(currentDebt, toMint, giveAmount);
-  return { newDebt, toMint, fee };
-};
-
-/**
- * @typedef {Readonly<{
- *   collateralBrand: Brand,
- *   debtBrand: Brand,
- *   manager: import('./stakeFactoryManager.js').StakeFactoryManager,
- *   subscriber: Subscriber<unknown>
- *   vaultSeat: ZCFSeat,
- *   zcf: ZCF,
- * }>} ImmutableState
- * @typedef {{
- *   open: boolean,
- *   debtSnapshot: Amount<'nat'>,
- *   interestSnapshot: Ratio,
- *   publisher: Publisher<unknown> | null,
- * }} MutableState
- * @typedef {MutableState & ImmutableState} State
- * @typedef {{
- *   state: State,
- *   facets: {
- *     helper: import('@agoric/vat-data/src/types').KindFacet<typeof helperBehavior>,
- *     pot: import('@agoric/vat-data/src/types').KindFacet<typeof potBehavior>,
- *   },
- * }} MethodContext
- */
-
-/**
- * Make stakeFactory kit state
- *
- * @param {ZCF} zcf
- * @param {ZCFSeat} startSeat
- * @param {import('./stakeFactoryManager.js').StakeFactoryManager} manager
- * @returns {State}
- */
-const initState = (zcf, startSeat, manager) => {
-  const collateralBrand = manager.getCollateralBrand();
-  const debtBrand = manager.getDebtBrand();
-
-  const { zcfSeat: vaultSeat } = zcf.makeEmptySeatKit();
-
-  const emptyDebt = AmountMath.makeEmpty(debtBrand);
-
-  const initialDebt = (() => {
-    assertProposalShape(startSeat, {
-      give: { [KW.Attestation]: null },
-      want: { [KW.Debt]: null },
-    });
-    const {
-      give: { [KW.Attestation]: attestationGiven },
-      want: { [KW.Debt]: runWanted },
-    } = startSeat.getProposal();
-
-    const { maxDebt } = manager.maxDebtForLien(attestationGiven);
-    AmountMath.isGTE(maxDebt, runWanted) ||
-      assert.fail(
-        X`wanted ${runWanted}, more than max debt (${maxDebt}) for ${attestationGiven}`,
-      );
-
-    const { newDebt, fee, toMint } = calculateFee(
-      manager.getLoanFee(),
-      emptyDebt,
-      emptyDebt,
-      runWanted,
-    );
-    !AmountMath.isEmpty(fee) ||
-      assert.fail(
-        X`loan requested (${runWanted}) is too small; cannot accrue interest`,
-      );
-    assert(AmountMath.isEqual(newDebt, toMint), X`loan fee mismatch`);
-    trace('init', { runWanted, fee, attestationGiven });
-
-    vaultSeat.incrementBy(
-      startSeat.decrementBy(harden({ [KW.Attestation]: attestationGiven })),
-    );
-
-    manager.mintAndReallocate(toMint, fee, startSeat, vaultSeat);
-
-    startSeat.exit();
-    return newDebt;
-  })();
-  manager.applyDebtDelta(emptyDebt, initialDebt);
-
-  const { publisher, subscriber } = makePublishKit();
-
-  /** @type {ImmutableState} */
-  const immutable = {
-    collateralBrand,
-    debtBrand,
-    manager,
-    subscriber,
-    vaultSeat,
-    zcf,
-  };
-  return {
-    ...immutable,
-    open: true,
-    // Two values from the same moment
-    interestSnapshot: manager.getCompoundedInterest(),
-    debtSnapshot: initialDebt,
-    publisher,
-  };
-};
-const helperBehavior = {
-  /**
-   * @param {MethodContext} context
-   * @param {ZCFSeat} seat
-   */
-  getCollateralAllocated: ({ state }, seat) =>
-    seat.getAmountAllocated(KW.Attestation, state.collateralBrand),
-  /**
-   * @param {MethodContext} context
-   * @param {ZCFSeat} seat
-   */
-  getMintedAllocated: ({ state }, seat) =>
-    seat.getAmountAllocated(KW.Debt, state.debtBrand),
-  /**
-   * @param {MethodContext} context
-   */
-  getCollateralAmount: ({ state, facets }) => {
-    const { collateralBrand, vaultSeat } = state;
-    const { helper } = facets;
-    const emptyCollateral = AmountMath.makeEmpty(
-      collateralBrand,
-      AssetKind.COPY_BAG,
-    );
-    // getCollateralAllocated would return final allocations
-    return vaultSeat.hasExited()
-      ? emptyCollateral
-      : helper.getCollateralAllocated(vaultSeat);
-  },
-
-  /**
-   * @param {MethodContext} context
-   *  @param {boolean} newActive */
-  snapshotState: ({ state, facets }, newActive) => {
-    const { debtSnapshot: debt, interestSnapshot: interest } = state;
-    const { helper } = facets;
-    /** @type {VaultNotification} */
-    const result = harden({
-      debtSnapshot: { debt, interest },
-      locked: helper.getCollateralAmount(),
-      // newPhase param is so that makeTransferInvitation can finish without setting the vault's phase
-      // TODO refactor https://github.com/Agoric/agoric-sdk/issues/4415
-      vaultState: newActive ? 'active' : 'closed',
-    });
-    return result;
-  },
-
-  /**
-   * call this whenever anything changes!
-   *
-   * @param {MethodContext} context
-   */
-  updateUiState: async ({ state, facets }) => {
-    const { open: active, publisher } = state;
-    if (!publisher) {
-      console.warn('updateUiState called after ui.publisher removed');
-      return;
-    }
-    const uiState = facets.helper.snapshotState(active);
-    trace('updateUiState', uiState);
-
-    if (active) {
-      publisher.publish(uiState);
-    } else {
-      publisher.finish(uiState);
-      state.publisher = null;
-    }
-  },
-
-  /**
-   * Called whenever the debt is paid or created through a transaction,
-   * but not for interest accrual.
-   *
-   * @param {MethodContext} context
-   * @param {Amount} newDebt - principal and all accrued interest
-   */
-  updateDebtSnapshot: ({ state }, newDebt) => {
-    const { manager } = state;
-    // update local state
-    state.debtSnapshot = newDebt;
-    state.interestSnapshot = manager.getCompoundedInterest();
-  },
-
-  /**
-   * Update the debt balance and propagate upwards to
-   * maintain aggregate debt and liquidation order.
-   *
-   * @param {MethodContext} context
-   * @param {Amount} oldDebt - prior principal and all accrued interest
-   * @param {Amount} newDebt - actual principal and all accrued interest
-   */
-  updateDebtAccounting: ({ state, facets }, oldDebt, newDebt) => {
-    const { manager } = state;
-    const { helper } = facets;
-    helper.updateDebtSnapshot(newDebt);
-    // update vault manager which tracks total debt
-    manager.applyDebtDelta(oldDebt, newDebt);
-  },
-
-  /**
-   * @param {MethodContext} context
-   */
-  assertVaultHoldsNoMinted: ({ state, facets }) => {
-    const { vaultSeat } = state;
-    const { helper } = facets;
-    AmountMath.isEmpty(helper.getMintedAllocated(vaultSeat)) ||
-      assert.fail(X`Vault should be empty of debt`);
-  },
-
-  /**
-   * Adjust principal and collateral (atomically for offer safety)
-   *
-   * @param {MethodContext} context
-   * @param {ZCFSeat} clientSeat
-   */
-  adjustBalancesHook: ({ state, facets }, clientSeat) => {
-    const { collateralBrand, debtBrand, manager, vaultSeat } = state;
-    const { helper, pot } = facets;
-    assert(state.open);
-
-    const proposal = clientSeat.getProposal();
-    assertOnlyKeys(proposal, [KW.Attestation, KW.Debt]);
-
-    const debt = pot.getCurrentDebt();
-    const collateral = helper.getCollateralAllocated(vaultSeat);
-
-    const emptyCollateral = AmountMath.makeEmpty(
-      collateralBrand,
-      AssetKind.COPY_BAG,
-    );
-    const giveColl = proposal.give.Attestation || emptyCollateral;
-    const wantColl = proposal.want.Attestation || emptyCollateral;
-
-    // new = after the transaction gets applied
-    const newCollateral = addSubtract(collateral, giveColl, wantColl);
-    // max debt supported by current Collateral as modified by proposal
-    const { amountLiened, maxDebt: newMaxDebt } =
-      manager.maxDebtForLien(newCollateral);
-
-    const emptyDebt = AmountMath.makeEmpty(debtBrand);
-    const give = AmountMath.min(proposal.give.Debt || emptyDebt, debt);
-    const want = proposal.want.Debt || emptyDebt;
-    const giveDebtOnly = matches(
-      proposal,
-      harden({ give: { [KW.Debt]: M.record() }, want: {}, exit: M.any() }),
-    );
-
-    // Calculate the fee, the amount to mint and the resulting debt. We'll
-    // verify that the target debt doesn't violate the collateralization ratio,
-    // then mint, reallocate, and burn.
-    const { newDebt, fee, toMint } = calculateFee(
-      manager.getLoanFee(),
-      debt,
-      give,
-      want,
-    );
-    assert(
-      giveDebtOnly || AmountMath.isGTE(newMaxDebt, newDebt),
-      `cannot borrow ${q(newDebt)} against ${q(amountLiened)}; max is ${q(
-        newMaxDebt,
-      )}`,
-    );
-
-    trace('adjustBalancesHook', {
-      targetCollateralAmount: newCollateral,
-      vaultCollateral: newCollateral,
-      fee,
-      toMint,
-      newDebt,
-    });
-
-    stageDelta(clientSeat, vaultSeat, giveColl, wantColl, KW.Attestation);
-    stageDelta(clientSeat, vaultSeat, give, emptyDebt, KW.Debt);
-    manager.mintAndReallocate(toMint, fee, clientSeat, vaultSeat);
-
-    // parent needs to know about the change in debt
-    helper.updateDebtAccounting(debt, newDebt);
-
-    manager.burnDebt(give, vaultSeat);
-
-    helper.assertVaultHoldsNoMinted();
-
-    void helper.updateUiState();
-    clientSeat.exit();
-
-    return 'We have adjusted your balances; thank you for your business.';
-  },
-
-  /**
-   * Given sufficient Minted payoff, refund the attestation.
-   *
-   * @type {import('@agoric/vat-data/src/types').PlusContext<MethodContext, OfferHandler>}
-   */
-  closeHook: ({ state, facets }, seat) => {
-    const { debtBrand, manager, vaultSeat, zcf } = state;
-    const { helper, pot } = facets;
-    assert(state.open);
-    assertProposalShape(seat, {
-      give: { [KW.Debt]: null },
-      want: { [KW.Attestation]: null },
-    });
-
-    const currentDebt = pot.getCurrentDebt();
-    const {
-      give: { [KW.Debt]: runOffered },
-    } = seat.getProposal();
-    AmountMath.isGTE(runOffered, currentDebt) ||
-      assert.fail(
-        X`Offer ${runOffered} is not sufficient to pay off debt ${currentDebt}`,
-      );
-    vaultSeat.incrementBy(seat.decrementBy(harden({ [KW.Debt]: currentDebt })));
-    seat.incrementBy(
-      vaultSeat.decrementBy(
-        harden({ Attestation: vaultSeat.getAmountAllocated('Attestation') }),
-      ),
-    );
-
-    zcf.reallocate(seat, vaultSeat);
-
-    manager.burnDebt(currentDebt, vaultSeat);
-    state.open = false;
-    helper.updateDebtSnapshot(AmountMath.makeEmpty(debtBrand));
-    void helper.updateUiState();
-    helper.assertVaultHoldsNoMinted();
-    seat.exit();
-
-    return 'Your stakeFactory is closed; thank you for your business.';
-  },
-};
-
-const potBehavior = {
-  /** @param {MethodContext} context */
-  getSubscriber: ({ state }) => state.subscriber,
-  /** @param {MethodContext} context */
-  makeAdjustBalancesInvitation: ({ state, facets }) => {
-    const { zcf } = state;
-    const { helper } = facets;
-    assert(state.open);
-    return zcf.makeInvitation(
-      seat => helper.adjustBalancesHook(seat),
-      'AdjustBalances',
-    );
-  },
-  /** @param {MethodContext} context */
-  makeCloseInvitation: ({ state, facets }) => {
-    const { zcf } = state;
-    const { helper } = facets;
-    assert(state.open);
-    return zcf.makeInvitation(seat => helper.closeHook(seat), 'CloseVault');
-  },
-  /**
-   * The actual current debt, including accrued interest.
-   *
-   * This looks like a simple getter but it does a lot of the heavy lifting for
-   * interest accrual. Rather than updating all records when interest accrues,
-   * the vault manager updates just its rolling compounded interest. Here we
-   * calculate what the current debt is given what's recorded in this vault and
-   * what interest has compounded since this vault record was written.
-   *
-   * @see getNormalizedDebt
-   * @param {MethodContext} context
-   * @returns {Amount<'nat'>}
-   */
-  getCurrentDebt: ({ state }) => {
-    return calculateCurrentDebt(
-      state.debtSnapshot,
-      state.interestSnapshot,
-      state.manager.getCompoundedInterest(),
-    );
-  },
-  /** @param {MethodContext} context */
-  getNormalizedDebt: ({ state }) =>
-    reverseInterest(state.debtSnapshot, state.interestSnapshot),
-};
-
-const behavior = {
-  helper: helperBehavior,
-  pot: potBehavior,
-};
-
-/**
- * @param {MethodContext} context
- */
-const finish = ({ facets }) => {
-  const { helper } = facets;
-  void helper.updateUiState();
-};
-
-/**
- * Make stakeFactory kit, subject to stakeFactory terms.
- *
- * @param {ZCF} zcf
- * @param {ZCFSeat} startSeat
- * @param {import('./stakeFactoryManager.js').StakeFactoryManager} manager
- * @throws {Error} if startSeat proposal is not consistent with governance parameters in manager
- */
-const makeStakeFactoryKitInternal = defineKindMulti(
-  'stakeFactoryKit',
-  initState,
-  behavior,
-  { finish },
-);
-
-/**
- * Make stakeFactory kit, subject to stakeFactory terms.
- *
- * TODO refactor to remove this wrapper around the kind and to stop using
- * `bindAllMethods`.
- *
- * @param {ZCF} zcf
- * @param {ZCFSeat} startSeat
- * @param {import('./stakeFactoryManager.js').StakeFactoryManager} manager
- * @throws {Error} if startSeat proposal is not consistent with governance parameters in manager
- */
-export const makeStakeFactoryKit = (zcf, startSeat, manager) => {
-  const { helper, pot } = makeStakeFactoryKitInternal(zcf, startSeat, manager);
-  return harden({
-    // XXX work- around for change from auto - binding
-    helper: bindAllMethods(helper),
-    pot,
-  });
-};