@agoric/inter-protocol 0.13.2-dev-73ca139.0 → 0.13.2-dev-a9d6a3b.0

package/src/my-lien.js

@@ -1,84 +0,0 @@
-// @jessie-check
-
-import { AmountMath } from '@agoric/ertp';
-import { E, Far } from '@endo/far';
-
-const { Fail } = assert;
-
-/**
- * per golang/cosmos/x/lien/lien.go
- *
- * @typedef { 'bonded' | 'liened' | 'locked' | 'total' | 'unbonding' } AccountProperty
- */
-const XLien = /** @type { const } */ ({
-  LIEN_CHANGE_LIENED: 'LIEN_CHANGE_LIENED',
-  LIEN_GET_ACCOUNT_STATE: 'LIEN_GET_ACCOUNT_STATE',
-});
-
-/**
- * @typedef { Record<AccountProperty, T> & { currentTime: bigint } } AccountState<T>
- * @template T
- */
-
-export const LienBridgeId = /** @type {const} */ ('lien');
-
-/**
- * @param {ERef<import('@agoric/vats').ScopedBridgeManager>} lienBridgeManager
- * @param {Brand<'nat'>} brand
- * @param {string} [denom]
- * @returns {StakingAuthority}
- */
-export const makeStakeReporter = (lienBridgeManager, brand, denom = 'ubld') => {
-  const { make: makeAmt } = AmountMath;
-  const toStake = numeral => makeAmt(brand, BigInt(numeral));
-  /**
-   * @param {string} address
-   * @param {bigint} delta
-   * @returns {Promise<Amount<`nat`>>}
-   */
-  const changeLiened = async (address, delta) => {
-    assert.typeof(address, 'string');
-    const newAmount = await E(lienBridgeManager).toBridge({
-      type: XLien.LIEN_CHANGE_LIENED,
-      address,
-      denom,
-      delta: `${delta}`,
-    });
-    return harden(toStake(newAmount));
-  };
-
-  /** @type {StakingAuthority} */
-  const stakeReporter = Far('stakeReporter', {
-    increaseLiened: async (address, increase) => {
-      const delta = AmountMath.getValue(brand, increase);
-      return changeLiened(address, delta);
-    },
-    decreaseLiened: async (address, decrease) => {
-      const delta = -1n * AmountMath.getValue(brand, decrease);
-      return changeLiened(address, delta);
-    },
-    getAccountState: async (address, wantedBrand) => {
-      wantedBrand === brand ||
-        Fail`Cannot getAccountState for ${wantedBrand}. Expected ${brand}.`;
-      /** @type { AccountState<string> } */
-      const { currentTime, bonded, liened, locked, total, unbonding } = await E(
-        lienBridgeManager,
-      ).toBridge({
-        type: XLien.LIEN_GET_ACCOUNT_STATE,
-        address,
-        denom,
-        amount: '0',
-      });
-      return harden({
-        bonded: toStake(bonded),
-        liened: toStake(liened),
-        locked: toStake(locked),
-        total: toStake(total),
-        unbonding: toStake(unbonding),
-        currentTime: BigInt(currentTime),
-      });
-    },
-  });
-
-  return stakeReporter;
-};

package/src/stakeFactory/README.md

@@ -1,62 +0,0 @@
-# stakeFactory design notes
-
-The stakeFactory contract provides loans on the basis of
-staked assets that earn rewards.
-
-The following sequence diagram shows an interaction between stakeFactory and:
-  - dapp: with rich interaction but low privilege
-  - walletBridge: with high privilege and constrained interaction
-  - attestation: a service within the stakeFactory contract
-  - Cosmos_SDK: the Cosmos SDK layer, including the `x/lien` module
-
-Before this interaction, an `ag123` account has been provisioned,
-which provides an `AttestationMaker` for that account to the wallet.
-
-Note that the account already has 4000 BLD liened before this interaction.
-
-```mermaid
-sequenceDiagram
-    actor dapp
-    participant walletBridge
-    participant attestation
-    participant stakeFactory
-    participant Cosmos_SDK
-
-    note right of dapp: How dapp finds the current state
-
-    note right of walletBridge: walletBridge is provided to dapps and controlled by Wallet UI
-    dapp ->>+ walletBridge: getPurseBalance("BLD")
-    dapp -->> walletBridge: 5000
-
-    note right of attestation: ag123 is a cosmos address
-    dapp ->> attestation: getMax(ag123)
-    attestation ->> Cosmos_SDK: getAccountState(ag123)
-    note right of Cosmos_SDK: Cosmos supports lien
-    Cosmos_SDK -->> attestation: account status in which 4000 BLD liened
-    attestation  -->> dapp: account status in which 4000 BLD liened
-    note right of dapp: Treasury now knows
-
-    note right of dapp: Want to get 450 IST by liening 500 BLD
-    dapp ->> walletBridge: getReturnableAttestation(want: 450 IST, give: 500 BLD-Att)
-    note right of walletBridge: Blocks on user approval in wallet
-    walletBridge ->> attestation: makeAttestation(500 BLD)
-    attestation ->> Cosmos_SDK: increaseLiened(+500 BLD)
-    Cosmos_SDK -->> attestation: new lien balance or throws
-
-    attestation -->> walletBridge: Payment of 500 BLD-Att liened on ag123
-
-    walletBridge ->> stakeFactory: offer w/payment for {give: 500 BLD-Att, want: 450 IST} 
-
-    stakeFactory --> walletBridge: Payment for 450 IST and offerResult
-    walletBridge --> dapp: notifiers from offerResult
-```
-
-## Components
-
-In addition to the `stakeFactory.js` module with the contract `start` function:
-
- - `params.js`: utilities for governance parameters
- - `stakeFactoryKit.js`: `makeStakeFactoryKit` is called once per loan
- - `stakeFactoryManager.js`: handles interest etc. for all loans
- - `attestation.js`: minting tokens that attest to liens,
-      and wrapping them in per-user attestation maker authorities.

package/src/stakeFactory/attestation.js

@@ -1,271 +0,0 @@
-// @jessie-check
-
-// Ambient types. https://github.com/Agoric/agoric-sdk/issues/6512
-import './types.js';
-
-import { AmountMath, AssetKind } from '@agoric/ertp';
-import { E, Far } from '@endo/far';
-import {
-  mustMatch,
-  M,
-  makeCopyBag,
-  makeScalarMapStore,
-  provideLazy,
-} from '@agoric/store';
-import { assertProposalShape } from '@agoric/zoe/src/contractSupport/index.js';
-import { AttKW as KW } from './constants.js';
-import { makeAttestationTool } from './attestationTool.js';
-
-const { Fail } = assert;
-
-/**
- * @typedef {{
- *   mintAttestation: unknown,
- *   returnAttestation: OfferHandler,
- *   getLiened: (address: Address, brand: Brand<'nat'>) => Amount<'nat'>,
- *   getAccountState: unknown,
- *   wrapLienedAmount: unknown,
- *   unwrapLienedAmount: unknown,
- * }} LienMint
- */
-
-/**
- * To support `makeAttestation`, we directly mint attestation payments.
- * We still use a ZCFMint because returning attestations is done
- * through Zoe offers.
- *
- * @param {ZCF} zcf
- * @template {AssetKind} K
- * @param {ZCFMint<K>} zcfMint
- * @param {Amount<K>} amountToMint
- * @returns {Promise<Payment<K>>}
- */
-const mintZCFMintPayment = (zcf, zcfMint, amountToMint) => {
-  const { userSeat, zcfSeat } = zcf.makeEmptySeatKit();
-  zcfMint.mintGains(harden({ [KW.Attestation]: amountToMint }), zcfSeat);
-  zcfSeat.exit();
-  return E(userSeat).getPayout(KW.Attestation);
-};
-
-/**
- * Make a ZCFMint attentuated so that minting represents
- * putting a lien on staked assets. Payments can be returned,
- * releasing (part of) the lien.
- *
- * NOTE: Using Issuer.combine or AmountMath.add could result in
- * Payments / Amounts with multiple addresses.
- * Callers are responsible to split any such payment before returning.
- *
- * @param {ZCF} zcf
- * @param {Brand<'nat'>} stakeBrand brand of the staked assets
- * @param {ERef<StakingAuthority>} lienBridge bridge to account state
- */
-const makeAttestationIssuerKit = async (zcf, stakeBrand, lienBridge) => {
-  const { subtract, makeEmpty, isGTE, coerce } = AmountMath;
-  const empty = makeEmpty(stakeBrand);
-  /** @type { ZCFMint<'copyBag'> } */
-  const attMint = await zcf.makeZCFMint(KW.Attestation, AssetKind.COPY_BAG);
-  /** @type {{ issuer: Issuer<'copyBag'>, brand: Brand<'copyBag'>}} */
-  const { issuer, brand: attBrand } = attMint.getIssuerRecord();
-
-  /**
-   * @param {Address} address
-   * @param {Amount<'nat'>} lienedAmount
-   * @returns {Amount<'copyBag'>}
-   */
-  const wrapLienedAmount = (address, lienedAmount) =>
-    AmountMath.make(attBrand, makeCopyBag([[address, lienedAmount.value]]));
-
-  /** @param {Amount<'copyBag'>} attestationAmount */
-  const unwrapLienedAmount = attestationAmount => {
-    attestationAmount.brand === attBrand ||
-      Fail`The escrowed attestation ${attestationAmount} was not of the attestation brand ${attBrand}`;
-    mustMatch(
-      attestationAmount.value.payload,
-      harden([[M.string(), M.bigint()]]),
-      'attestationAmount',
-    );
-    /** @type {[Address, bigint][]} */
-    const [[address, valueReturned]] = attestationAmount.value.payload;
-    const lienedAmount = AmountMath.make(stakeBrand, valueReturned);
-    return { address, lienedAmount };
-  };
-
-  /**
-   * Non-authoritative store of nonzero lien amounts.
-   *
-   * @type {MapStore<Address, Amount<'nat'>>}
-   */
-  const amountByAddress = makeScalarMapStore('amount');
-
-  /**
-   * Get non-authoritative liened amount from the JS store, without using the lienBridge.
-   *
-   * @param {Address} address
-   * @param {Brand<'nat'>} brand
-   */
-  const getLiened = (address, brand) => {
-    assert.typeof(address, 'string');
-    assert.equal(brand, stakeBrand);
-    if (amountByAddress.has(address)) {
-      return amountByAddress.get(address);
-    }
-    // Don't bother storing empty amounts.
-    return empty;
-  };
-
-  const getAccountState = async (address, brand) => {
-    const liened = getLiened(address, brand);
-    const s = await E(lienBridge).getAccountState(address, brand);
-    assert(AmountMath.isEqual(liened, s.liened));
-    return s;
-  };
-
-  /** @type {(m: Amount, s: Amount) => Amount} */
-  const subtractOrZero = (m, s) => (isGTE(m, s) ? subtract(m, s) : empty);
-  // check that x <= hi - lo
-  const checkDelta = (x, label, hi, lo) => {
-    const bound = subtractOrZero(hi, lo);
-    isGTE(bound, coerce(stakeBrand, x)) ||
-      // TODO: X`...${raw(label)}...`
-      Fail`Only ${bound} was ${label}, but an attestation was attempted for ${x}`;
-  };
-  const assertAccountStateOK = async (address, toLien) => {
-    const s = await getAccountState(address, stakeBrand);
-    const unlocked = subtractOrZero(s.total, s.locked);
-    checkDelta(toLien, 'unliened', s.total, s.liened);
-    checkDelta(toLien, 'bonded and unliened', s.bonded, s.liened);
-    checkDelta(toLien, 'unlocked and unliened', unlocked, s.liened);
-  };
-
-  /**
-   * @param {Address} address
-   * @param {Amount<'nat'>} lienDelta
-   */
-  const mintAttestation = async (address, lienDelta) => {
-    // This account state check is primarily to provide useful diagnostics.
-    // Since things like the bonded amount can change out from under us,
-    // we shouldn't rely on it completely.
-    // PERFORMANCE NOTE: this check shouldn't be necessary and skipping it
-    // may speed things up.
-    await assertAccountStateOK(address, lienDelta);
-
-    // Since our mint is not subject to normal supply/demand,
-    // minting here and failing in changeLiened below does no harm.
-    const attestationPayment = await mintZCFMintPayment(
-      zcf,
-      attMint,
-      wrapLienedAmount(address, lienDelta),
-    );
-
-    const newLiened = await E(lienBridge).increaseLiened(address, lienDelta);
-    // COMMIT: update the stored liened amount and issue the attestation.
-    if (amountByAddress.has(address)) {
-      amountByAddress.set(address, newLiened);
-    } else {
-      amountByAddress.init(address, newLiened);
-    }
-    return attestationPayment;
-  };
-
-  /** @param {ZCFSeat} seat */
-  const returnAttestation = async seat => {
-    assertProposalShape(seat, {
-      give: { [KW.Attestation]: null },
-      want: {},
-    });
-
-    const {
-      give: { [KW.Attestation]: attestationAmount },
-    } = seat.getProposal();
-    if (AmountMath.isEmpty(attestationAmount)) {
-      seat.exit();
-      return;
-    }
-    const { address, lienedAmount: amountReturned } =
-      unwrapLienedAmount(attestationAmount);
-    const newLiened = await E(lienBridge).decreaseLiened(
-      address,
-      amountReturned,
-    );
-    // COMMIT. Burn the escrowed attestation payment and exit the seat.
-    if (newLiened === empty) {
-      amountByAddress.delete(address);
-    } else {
-      amountByAddress.set(address, newLiened);
-    }
-    attMint.burnLosses(harden({ Attestation: attestationAmount }), seat);
-    seat.exit();
-  };
-
-  /** @type {ERef<LienMint>} */
-  const lienMint = Far('LienMint', {
-    mintAttestation,
-    returnAttestation,
-    getLiened,
-    getAccountState,
-    wrapLienedAmount,
-    /**
-     * @param {Amount<'copyBag'>} attAmt
-     * @throws if `attAmt` payload length is not 1
-     */
-    unwrapLienedAmount: attAmt => unwrapLienedAmount(attAmt).lienedAmount,
-  });
-  return harden({ issuer, brand: attBrand, lienMint });
-};
-
-/**
- * Authorize each account holder to lien some of their staked assets
- * and get an attestation that the lien is in place.
- *
- * @param {ZCF} zcf
- * @param {Brand<'nat'>} stakeBrand
- * @param {ERef<StakingAuthority>} lienBridge
- *
- * NOTE: the liened amount is kept both here in JS and on the
- * other side of the lienBridge. The mint created here
- * is the authority on the liened amount. The liened amount
- * on the other side of the bridge may lag. Do not create two
- * mints that share a bridge.
- *
- * The provideAttestationMaker method on the returned creatorFacet
- * provides the authorization for an address. The account holder
- * can then use attMaker.makeAttestation(lienDelta).
- *
- * The keyword for use in returnAttestation offers is `Attestation`.
- */
-export const makeAttestationFacets = async (zcf, stakeBrand, lienBridge) => {
-  /** @type {MapStore<Address, AttestationTool>} */
-  const attMakerByAddress = makeScalarMapStore('address');
-
-  const { issuer, brand, lienMint } = await makeAttestationIssuerKit(
-    zcf,
-    stakeBrand,
-    lienBridge,
-  );
-
-  return harden({
-    publicFacet: Far('attestation publicFacet', {
-      getIssuer: () => issuer,
-      getBrand: () => brand,
-      makeReturnAttInvitation: () =>
-        zcf.makeInvitation(lienMint.returnAttestation, 'returnAttestation'),
-    }),
-    creatorFacet: Far('creator', {
-      /**
-       * IMPORTANT: The attestation maker should only be given to the owner of the
-       * address. Only the owner can authorize creation of attestations and
-       * the resulting liens on their underlying tokens.
-       *
-       * @param {Address} address
-       */
-      provideAttestationTool: address => {
-        assert.typeof(address, 'string');
-        return provideLazy(attMakerByAddress, address, () =>
-          makeAttestationTool(address, lienMint, stakeBrand, zcf),
-        );
-      },
-      getLiened: lienMint.getLiened,
-    }),
-  });
-};

package/src/stakeFactory/attestationTool.js

@@ -1,67 +0,0 @@
-// @jessie-check
-
-/**
- * @typedef {Readonly<{
- *   address: Address,
- *   lienMint: *,
- *   stakeBrand: Brand<'nat'>,
- *   zcf: ZCF,
- * }>} State
- * @typedef {{
- *   state: State,
- * }} MethodContext
- */
-
-import { defineKind } from '@agoric/vat-data';
-/**
- * @param {Address} address
- * @param {import('./attestation').LienMint} lienMint
- * @param {Brand<'nat'>} stakeBrand
- * @param {ZCF} zcf
- */
-const initState = (address, lienMint, stakeBrand, zcf) => {
-  return { address, lienMint, stakeBrand, zcf };
-};
-
-const behavior = {
-  /**
-   * @param {MethodContext} context
-   * @param {Amount<'nat'>} lienedDelta
-   */
-  makeAttestation: ({ state }, lienedDelta) =>
-    state.lienMint.mintAttestation(state.address, lienedDelta),
-
-  /** @param {MethodContext} context */
-  getAccountState: ({ state }) =>
-    state.lienMint.getAccountState(state.address, state.stakeBrand),
-
-  /** @param {MethodContext} context */
-  makeReturnAttInvitation: ({ state }) =>
-    state.zcf.makeInvitation(
-      state.lienMint.returnAttestation,
-      'returnAttestation',
-    ),
-
-  /**
-   * @param {MethodContext} context
-   * @param {Amount<'nat'>} lienedAmount
-   */
-  wrapLienedAmount: ({ state }, lienedAmount) =>
-    state.lienMint.wrapLienedAmount(state.address, lienedAmount),
-
-  /**
-   * @param {MethodContext} context
-   * @param {Amount<'copyBag'>} attAmount
-   */
-  unwrapLienedAmount: ({ state }, attAmount) =>
-    state.lienMint.unwrapLienedAmount(attAmount),
-};
-
-/**
- * @returns {AttestationTool}
- */
-export const makeAttestationTool = defineKind(
-  'AttestationTool',
-  initState,
-  behavior,
-);

package/src/stakeFactory/constants.js

@@ -1,18 +0,0 @@
-// @jessie-check
-
-export const AttKW = /** @type { const } */ ({
-  /** seat keyword for use in offers to return an attestation. */
-  Attestation: 'Attestation',
-});
-
-export const ManagerKW = /** @type { const } */ ({
-  [AttKW.Attestation]: AttKW.Attestation,
-  Debt: 'Debt',
-});
-
-export const ParamKW = /** @type { const } */ ({
-  DebtLimit: 'DebtLimit',
-  MintingRatio: 'MintingRatio',
-  InterestRate: 'InterestRate',
-  MintFee: 'MintFee',
-});

package/src/stakeFactory/params.js

@@ -1,30 +0,0 @@
-// @jessie-check
-
-import { CONTRACT_ELECTORATE, ParamTypes } from '@agoric/governance';
-import { ParamKW as PKey } from './constants.js';
-
-export const makeStakeFactoryTerms = (
-  { timerService, chargingPeriod, recordingPeriod },
-  {
-    electorateInvitationAmount,
-    debtLimit,
-    mintingRatio,
-    interestRate,
-    mintFee,
-  },
-) => ({
-  timerService,
-  chargingPeriod,
-  recordingPeriod,
-  governedParams: harden({
-    [PKey.DebtLimit]: { type: ParamTypes.AMOUNT, value: debtLimit },
-    [PKey.MintingRatio]: { type: ParamTypes.RATIO, value: mintingRatio },
-    [PKey.InterestRate]: { type: ParamTypes.RATIO, value: interestRate },
-    [PKey.MintFee]: { type: ParamTypes.RATIO, value: mintFee },
-    [CONTRACT_ELECTORATE]: {
-      type: ParamTypes.INVITATION,
-      value: electorateInvitationAmount,
-    },
-  }),
-});
-harden(makeStakeFactoryTerms);