Lending

The pool’s exit leaf is a NUMS point that nobody can sign. If the operator is unavailable, lenders and borrowers have no exit path: their virtual outputs cannot be spent, renewed, or exited, and they expire. See Exit.

A lending vault is five contracts. The pool is one. A lender deposit, a borrower deposit, a lender staging output, and a borrower staging output are the other four. The constructor of the pool names no lender and no borrower. Each standing output names payScript, the script that receives the token or the payout. Anyone may sweep that output. The sweep asks for no signature. The pool is one output, so one spend settles it. The standing outputs do not spend the pool when people fund them. One sweep spends the pool once and settles up to four of them. Output i settles input i. The next sweep spends the pool that sweep created. A lender deposit carries stablecoin. open creates the pool. sweep mints one lender share per stablecoin unit. A borrower deposit carries bitcoin. open creates the pool when it is first. sweep mints one collateral token per sat above the carrier. To leave, the holder sends the token to a staging output. That send is the authorization. A later sweep burns the token and pays payScript in the same spend. Lender shares pay stablecoin. Collateral tokens pay bitcoin. If any check fails, the emulator does not cosign, so the standing output and the pool stay as they were. refund pays a standing output back to payScript and does not spend the pool. borrow and repay stay on the pool. They spend one holder’s own token output, so they are not a shared standing address. borrow pays stablecoin and mints a debt token. The collateral tokens come back. repay burns the debt and returns the debt plus the fixed fee feeBps. There is no interest clock. The fee is added once, when the debt is repaid. satsPerUnit is fixed at deployment, and the vault has no liquidation path. The contract checks the collateral ratio only at that fixed rate, never at market price. A borrower can hold the stablecoin after the collateral’s market value falls below the debt, and no spend forces the position closed. Lenders bear the exchange-rate risk in full. A lender share that rounds to zero stablecoin fails that spend, and the shares stay on the staging output. The payout division truncates, so the remainder of every payout stays in the pool’s stablecoin balance, and only a repay adds stablecoin back. When the last lender exits and the supply is gone, a remainder stays on the pool for good. A collateral staging output must hold no debt, and the pool’s remaining bitcoin must still cover the open debt at satsPerUnit. A pool spend cannot share a transaction with an oracle read. The pool’s continuation and the attestation both require output 0 to carry their own script, and one output 0 cannot carry two scripts. Read the oracle in a separate transaction (Oracle Output). Two ledger assets remember the lender supply and the debt supply, so the pool script does not change and a continuation needs no new constructor. The exit leaf on the pool is the NUMS point (Exit). payScript is the receiver’s witness program. The asset ids, feeBps, satsPerUnit, and noExitKey on a standing output match the pool, or new LendingPool does not name this pool. serverExitDelay is not a parameter. The client binds it (CSV delays).

lending_pool.ark

pragma arkade ^0.1.0;

// The pool only. Deposits and exits are separate contracts.
// One sweep spends this output once and up to four standing outputs. Output i settles input i.
// feeBps is the fixed fee paid on repay. satsPerUnit is the collateral sats required per stable unit.
// Lender supply and debt supply are ledger assets on this output, so this script stays fixed.
// noExitKey is the BIP341 NUMS point: 50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0
contract LendingPool(
  bytes32 stableTxid, int stableGidx,
  bytes32 lenderTxid, int lenderGidx,
  bytes32 collTxid, int collGidx,
  bytes32 debtTxid, int debtGidx,
  bytes32 lenderLedgTxid, int lenderLedgGidx,
  bytes32 debtLedgTxid, int debtLedgGidx,
  bytes32 ctrlTxid, int ctrlGidx,
  int feeBps, int satsPerUnit,
  pubkey noExitKey
) {
  const int DUST = 330;

  private function samePool() {
    require(tx.outputs[0].scriptPubKey == tx.input.current.scriptPubKey, "pool");
  }

  private function batch() {
    require(this.activeInputIndex == 0, "pool input");
    require(tx.numInputs >= 2, "batch");
    require(tx.numInputs <= 5, "batch");
    require(tx.numOutputs == tx.numInputs, "outputs");
    samePool();
  }

  private function held(bytes32 txid, int gidx) int {
    let row = tx.inputs[0].assets.tryLookup(txid, gidx);
    if (row.found) {
      return row.amount;
    }
    return 0;
  }

  private function keepCtrl() {
    require(tx.outputs[0].assets.lookup(ctrlTxid, ctrlGidx) == 1, "ctrl");
    let ctrlGroup = tx.assetGroups.find(ctrlTxid, ctrlGidx);
    require(ctrlGroup.delta == 0, "ctrl supply");
  }

  // Sweep standing stablecoin deposits. Mint one lender share per unit.
  function sweepLender() {
    batch();
    int added = 0;
    int[4] slots = [1, 2, 3, 4];
    for (i, slot) in slots {
      if (tx.numInputs > slot) {
        int part = tx.inputs[slot].assets.lookup(stableTxid, stableGidx);
        require(tx.outputs[slot].assets.lookup(lenderTxid, lenderGidx) == part, "shares");
        added = added + part;
      }
    }
    require(added > 0, "stable");
    int prev = held(stableTxid, stableGidx);
    int ledg = held(lenderLedgTxid, lenderLedgGidx);
    require(tx.outputs[0].value == tx.inputs[0].value, "btc");
    keepCtrl();
    require(tx.outputs[0].assets.lookup(stableTxid, stableGidx) == prev + added, "stable");
    require(tx.outputs[0].assets.lookup(lenderLedgTxid, lenderLedgGidx) == ledg + added, "ledger");
    let shareGroup = tx.assetGroups.find(lenderTxid, lenderGidx);
    require(shareGroup.delta == added, "issued");
    require(shareGroup.controlIs(ctrlTxid, ctrlGidx), "control");
    let ledgGroup = tx.assetGroups.find(lenderLedgTxid, lenderLedgGidx);
    require(ledgGroup.delta == added, "ledger");
    require(ledgGroup.controlIs(ctrlTxid, ctrlGidx), "ledger control");
  }

  // Sweep standing bitcoin deposits. Mint one collateral token per sat above the carrier.
  function sweepBorrower() {
    batch();
    int added = 0;
    int[4] slots = [1, 2, 3, 4];
    for (i, slot) in slots {
      if (tx.numInputs > slot) {
        int part = tx.inputs[slot].value - DUST;
        require(tx.outputs[slot].assets.lookup(collTxid, collGidx) == part, "collateral token");
        added = added + part;
      }
    }
    require(added > 0, "collateral");
    int prev = held(stableTxid, stableGidx);
    keepCtrl();
    require(tx.outputs[0].value == tx.inputs[0].value + added, "btc");
    if (prev == 0) {
      require(!tx.outputs[0].assets.has(stableTxid, stableGidx), "no stable");
    } else {
      require(tx.outputs[0].assets.lookup(stableTxid, stableGidx) == prev, "stable");
    }
    let collGroup = tx.assetGroups.find(collTxid, collGidx);
    require(collGroup.delta == added, "issued");
    require(collGroup.controlIs(ctrlTxid, ctrlGidx), "control");
  }

  // Take stablecoin against collateral tokens the holder keeps.
  function borrow(int take) {
    require(this.activeInputIndex == 0, "pool input");
    require(tx.numInputs == 3, "pool, collateral, carriers");
    require(take > 0, "take");
    require(satsPerUnit > 0, "ratio");
    require(tx.inputs[1].value == DUST, "coll carrier");
    require(tx.inputs[1].assets.length == 1, "coll only");
    int coll = tx.inputs[1].assets.lookup(collTxid, collGidx);
    require(coll >= take * satsPerUnit, "collateral");
    require(tx.inputs[2].assets.length == 0, "sats");
    require(tx.inputs[2].value == DUST + DUST, "carriers");
    int prev = held(stableTxid, stableGidx);
    require(prev >= take, "liquidity");
    int debt = held(debtLedgTxid, debtLedgGidx);
    int collSats = tx.inputs[0].value - DUST;
    require(collSats >= (debt + take) * satsPerUnit, "pool ratio");
    require(tx.numOutputs == 3, "three outputs");
    samePool();
    require(tx.outputs[0].value == tx.inputs[0].value, "btc");
    keepCtrl();
    if (prev == take) {
      require(!tx.outputs[0].assets.has(stableTxid, stableGidx), "drained");
    } else {
      require(tx.outputs[0].assets.lookup(stableTxid, stableGidx) == prev - take, "stable");
    }
    require(tx.outputs[0].assets.lookup(debtLedgTxid, debtLedgGidx) == debt + take, "debt ledger");
    let holder = tx.inputs[1].scriptPubKey;
    require(tx.outputs[1].scriptPubKey == holder, "holder");
    require(tx.outputs[1].value == DUST, "coll carrier");
    require(tx.outputs[1].assets.lookup(collTxid, collGidx) == coll, "coll back");
    require(tx.outputs[1].assets.length == 1, "coll only");
    require(tx.outputs[2].scriptPubKey == holder, "holder");
    require(tx.outputs[2].value == DUST, "debt carrier");
    require(tx.outputs[2].assets.lookup(debtTxid, debtGidx) == take, "debt");
    require(tx.outputs[2].assets.lookup(stableTxid, stableGidx) == take, "stable out");
    require(tx.outputs[2].assets.length == 2, "debt and stable");
    let collGroup = tx.assetGroups.find(collTxid, collGidx);
    require(collGroup.delta == 0, "coll supply");
    let debtGroup = tx.assetGroups.find(debtTxid, debtGidx);
    require(debtGroup.delta == take, "debt issued");
    require(debtGroup.controlIs(ctrlTxid, ctrlGidx), "control");
    let ledgGroup = tx.assetGroups.find(debtLedgTxid, debtLedgGidx);
    require(ledgGroup.delta == take, "ledger");
    require(ledgGroup.controlIs(ctrlTxid, ctrlGidx), "ledger control");
    let stableGroup = tx.assetGroups.find(stableTxid, stableGidx);
    require(stableGroup.delta == 0, "stable supply");
  }

  // Burn debt. The stablecoin returned is the debt plus the fixed fee.
  function repay() {
    require(this.activeInputIndex == 0, "pool input");
    require(tx.numInputs == 3, "pool, debt, payment");
    require(tx.inputs[1].assets.length == 1, "debt only");
    require(tx.inputs[1].value == DUST, "debt carrier");
    int owed = tx.inputs[1].assets.lookup(debtTxid, debtGidx);
    require(owed > 0, "debt");
    int due = owed + (owed * feeBps) / 10000;
    require(tx.inputs[2].value == DUST, "pay carrier");
    require(tx.inputs[2].assets.length == 1, "stable only");
    require(tx.inputs[2].assets.lookup(stableTxid, stableGidx) == due, "fee");
    int prev = held(stableTxid, stableGidx);
    int debt = tx.inputs[0].assets.lookup(debtLedgTxid, debtLedgGidx);
    require(owed <= debt, "ledger");
    require(tx.numOutputs == 2, "two outputs");
    samePool();
    require(tx.outputs[0].value == tx.inputs[0].value, "btc");
    keepCtrl();
    require(tx.outputs[0].assets.lookup(stableTxid, stableGidx) == prev + due, "stable");
    if (debt == owed) {
      require(!tx.outputs[0].assets.has(debtLedgTxid, debtLedgGidx), "debt cleared");
    } else {
      require(tx.outputs[0].assets.lookup(debtLedgTxid, debtLedgGidx) == debt - owed, "debt ledger");
    }
    require(tx.outputs[1].scriptPubKey == tx.inputs[1].scriptPubKey, "holder");
    require(tx.outputs[1].value == DUST + DUST, "carriers back");
    require(tx.outputs[1].assets.length == 0, "no assets");
    let debtGroup = tx.assetGroups.find(debtTxid, debtGidx);
    require(debtGroup.sumInputs == owed, "debt in");
    require(debtGroup.sumOutputs == 0, "burned");
    require(debtGroup.controlIs(ctrlTxid, ctrlGidx), "control");
    let ledgGroup = tx.assetGroups.find(debtLedgTxid, debtLedgGidx);
    require(ledgGroup.delta == 0 - owed, "ledger");
    require(ledgGroup.controlIs(ctrlTxid, ctrlGidx), "ledger control");
    let stableGroup = tx.assetGroups.find(stableTxid, stableGidx);
    require(stableGroup.delta == 0, "stable supply");
  }

  // Sweep lender staging outputs. Burn the shares and pay each its fraction of the stablecoin.
  function withdrawLender() {
    batch();
    int supply = tx.inputs[0].assets.lookup(lenderLedgTxid, lenderLedgGidx);
    int prev = tx.inputs[0].assets.lookup(stableTxid, stableGidx);
    require(supply > 0, "supply");
    int burned = 0;
    int paid = 0;
    int[4] slots = [1, 2, 3, 4];
    for (i, slot) in slots {
      if (tx.numInputs > slot) {
        int part = tx.inputs[slot].assets.lookup(lenderTxid, lenderGidx);
        int partPay = (part * prev) / supply;
        require(partPay > 0, "payout");
        require(tx.outputs[slot].assets.lookup(stableTxid, stableGidx) == partPay, "stable out");
        burned = burned + part;
        paid = paid + partPay;
      }
    }
    require(burned <= supply, "supply");
    require(prev >= paid, "liquidity");
    require(tx.outputs[0].value == tx.inputs[0].value, "btc");
    keepCtrl();
    if (prev == paid) {
      require(!tx.outputs[0].assets.has(stableTxid, stableGidx), "drained");
    } else {
      require(tx.outputs[0].assets.lookup(stableTxid, stableGidx) == prev - paid, "stable");
    }
    if (supply == burned) {
      require(!tx.outputs[0].assets.has(lenderLedgTxid, lenderLedgGidx), "ledger cleared");
    } else {
      require(tx.outputs[0].assets.lookup(lenderLedgTxid, lenderLedgGidx) == supply - burned, "ledger");
    }
    let shareGroup = tx.assetGroups.find(lenderTxid, lenderGidx);
    require(shareGroup.sumInputs == burned, "shares in");
    require(shareGroup.sumOutputs == 0, "burned");
    require(shareGroup.controlIs(ctrlTxid, ctrlGidx), "control");
    let ledgGroup = tx.assetGroups.find(lenderLedgTxid, lenderLedgGidx);
    require(ledgGroup.delta == 0 - burned, "ledger");
    require(ledgGroup.controlIs(ctrlTxid, ctrlGidx), "ledger control");
    let stableGroup = tx.assetGroups.find(stableTxid, stableGidx);
    require(stableGroup.delta == 0, "stable supply");
  }

  // Sweep borrower staging outputs. Burn the collateral tokens and pay that many sats.
  function withdrawColl() {
    batch();
    int burned = 0;
    int[4] slots = [1, 2, 3, 4];
    for (i, slot) in slots {
      if (tx.numInputs > slot) {
        int part = tx.inputs[slot].assets.lookup(collTxid, collGidx);
        require(tx.outputs[slot].value == part + DUST, "btc out");
        burned = burned + part;
      }
    }
    require(burned > 0, "burned");
    require(tx.inputs[0].value >= burned + DUST, "btc");
    int debt = held(debtLedgTxid, debtLedgGidx);
    int left = tx.inputs[0].value - DUST - burned;
    require(left >= debt * satsPerUnit, "ratio");
    int prev = held(stableTxid, stableGidx);
    require(tx.outputs[0].value == tx.inputs[0].value - burned, "btc");
    keepCtrl();
    if (prev == 0) {
      require(!tx.outputs[0].assets.has(stableTxid, stableGidx), "no stable");
    } else {
      require(tx.outputs[0].assets.lookup(stableTxid, stableGidx) == prev, "stable");
    }
    let collGroup = tx.assetGroups.find(collTxid, collGidx);
    require(collGroup.sumInputs == burned, "coll in");
    require(collGroup.sumOutputs == 0, "burned");
    require(collGroup.controlIs(ctrlTxid, ctrlGidx), "control");
  }

  function unilateral(signature noExitSig) tapscript {
    require(older(serverExitDelay));
    require(checkSig(noExitSig, noExitKey));
  }
}

lender_deposit.ark

pragma arkade ^0.1.0;

import "./lending_pool.ark";

// Standing stablecoin deposit. payScript receives the lender shares.
// open creates the pool. sweep joins a pool that already exists. refund pays this output back.
contract LenderDeposit(
  bytes payScript,
  bytes32 stableTxid, int stableGidx,
  bytes32 lenderTxid, int lenderGidx,
  bytes32 collTxid, int collGidx,
  bytes32 debtTxid, int debtGidx,
  bytes32 lenderLedgTxid, int lenderLedgGidx,
  bytes32 debtLedgTxid, int debtLedgGidx,
  bytes32 ctrlTxid, int ctrlGidx,
  int feeBps, int satsPerUnit,
  pubkey noExitKey
) {
  const int DUST = 330;

  private function isPool(bytes script) {
    require(script == new LendingPool(
      stableTxid, stableGidx, lenderTxid, lenderGidx, collTxid, collGidx,
      debtTxid, debtGidx, lenderLedgTxid, lenderLedgGidx, debtLedgTxid, debtLedgGidx,
      ctrlTxid, ctrlGidx, feeBps, satsPerUnit, noExitKey
    ), "pool");
  }

  function open() {
    require(tx.numInputs == 1, "one input");
    require(this.activeInputIndex == 0, "deposit input");
    require(tx.inputs[0].value == DUST + DUST, "carriers");
    require(tx.inputs[0].assets.length == 1, "stable only");
    int added = tx.inputs[0].assets.lookup(stableTxid, stableGidx);
    require(added > 0, "stable");
    require(tx.numOutputs == 2, "two outputs");
    isPool(tx.outputs[0].scriptPubKey);
    require(tx.outputs[0].value == DUST, "pool carrier");
    require(tx.outputs[0].assets.lookup(ctrlTxid, ctrlGidx) == 1, "ctrl");
    require(tx.outputs[0].assets.lookup(stableTxid, stableGidx) == added, "stable");
    require(tx.outputs[0].assets.lookup(lenderLedgTxid, lenderLedgGidx) == added, "ledger");
    require(!tx.outputs[0].assets.has(debtLedgTxid, debtLedgGidx), "no debt");
    require(tx.outputs[1].scriptPubKey == payScript, "lender");
    require(tx.outputs[1].value == DUST, "carrier");
    require(tx.outputs[1].assets.lookup(lenderTxid, lenderGidx) == added, "shares");
    require(tx.outputs[1].assets.length == 1, "share assets");
    let shareGroup = tx.assetGroups.find(lenderTxid, lenderGidx);
    require(shareGroup.delta == added, "issued");
    require(shareGroup.isFresh, "fresh shares");
    require(shareGroup.controlIs(ctrlTxid, ctrlGidx), "control");
    let ledgGroup = tx.assetGroups.find(lenderLedgTxid, lenderLedgGidx);
    require(ledgGroup.delta == added, "ledger issued");
    require(ledgGroup.isFresh, "fresh ledger");
    require(ledgGroup.controlIs(ctrlTxid, ctrlGidx), "ledger control");
    let ctrlGroup = tx.assetGroups.find(ctrlTxid, ctrlGidx);
    require(ctrlGroup.delta == 1, "ctrl issued");
    require(ctrlGroup.isFresh, "fresh ctrl");
  }

  function sweep() {
    require(tx.numInputs >= 2, "batch");
    require(tx.numInputs <= 5, "batch");
    require(tx.numOutputs == tx.numInputs, "outputs");
    require(this.activeInputIndex >= 1, "deposit input");
    isPool(tx.inputs[0].scriptPubKey);
    int idx = this.activeInputIndex;
    require(tx.inputs[idx].value == DUST, "carrier");
    require(tx.inputs[idx].assets.length == 1, "stable only");
    int mine = tx.inputs[idx].assets.lookup(stableTxid, stableGidx);
    require(mine > 0, "stable");
    require(tx.outputs[idx].scriptPubKey == payScript, "lender");
    require(tx.outputs[idx].value == DUST, "share carrier");
    require(tx.outputs[idx].assets.lookup(lenderTxid, lenderGidx) == mine, "shares");
    require(tx.outputs[idx].assets.length == 1, "share assets");
  }

  function refund() {
    require(tx.numInputs == 1, "one input");
    require(this.activeInputIndex == 0, "this output");
    require(tx.numOutputs == 1, "one output");
    int amt = tx.inputs[0].assets.lookup(stableTxid, stableGidx);
    require(tx.outputs[0].scriptPubKey == payScript, "lender");
    require(tx.outputs[0].value == tx.inputs[0].value, "value");
    require(tx.outputs[0].assets.lookup(stableTxid, stableGidx) == amt, "stable");
    require(tx.outputs[0].assets.length == 1, "stable only");
  }
}

borrower_deposit.ark

pragma arkade ^0.1.0;

import "./lending_pool.ark";

// Standing bitcoin deposit. payScript receives the collateral tokens.
contract BorrowerDeposit(
  bytes payScript,
  bytes32 stableTxid, int stableGidx,
  bytes32 lenderTxid, int lenderGidx,
  bytes32 collTxid, int collGidx,
  bytes32 debtTxid, int debtGidx,
  bytes32 lenderLedgTxid, int lenderLedgGidx,
  bytes32 debtLedgTxid, int debtLedgGidx,
  bytes32 ctrlTxid, int ctrlGidx,
  int feeBps, int satsPerUnit,
  pubkey noExitKey
) {
  const int DUST = 330;

  private function isPool(bytes script) {
    require(script == new LendingPool(
      stableTxid, stableGidx, lenderTxid, lenderGidx, collTxid, collGidx,
      debtTxid, debtGidx, lenderLedgTxid, lenderLedgGidx, debtLedgTxid, debtLedgGidx,
      ctrlTxid, ctrlGidx, feeBps, satsPerUnit, noExitKey
    ), "pool");
  }

  function open() {
    require(tx.numInputs == 1, "one input");
    require(this.activeInputIndex == 0, "deposit input");
    require(tx.inputs[0].assets.length == 0, "sats");
    require(tx.inputs[0].value > DUST + DUST, "dust");
    int added = tx.inputs[0].value - DUST - DUST;
    require(tx.numOutputs == 2, "two outputs");
    isPool(tx.outputs[0].scriptPubKey);
    require(tx.outputs[0].value == added + DUST, "pool sats");
    require(tx.outputs[0].assets.lookup(ctrlTxid, ctrlGidx) == 1, "ctrl");
    require(tx.outputs[0].assets.length == 1, "ctrl only");
    require(tx.outputs[1].scriptPubKey == payScript, "borrower");
    require(tx.outputs[1].value == DUST, "carrier");
    require(tx.outputs[1].assets.lookup(collTxid, collGidx) == added, "collateral token");
    require(tx.outputs[1].assets.length == 1, "coll assets");
    let collGroup = tx.assetGroups.find(collTxid, collGidx);
    require(collGroup.delta == added, "issued");
    require(collGroup.isFresh, "fresh coll");
    require(collGroup.controlIs(ctrlTxid, ctrlGidx), "control");
    let ctrlGroup = tx.assetGroups.find(ctrlTxid, ctrlGidx);
    require(ctrlGroup.delta == 1, "ctrl issued");
    require(ctrlGroup.isFresh, "fresh ctrl");
  }

  function sweep() {
    require(tx.numInputs >= 2, "batch");
    require(tx.numInputs <= 5, "batch");
    require(tx.numOutputs == tx.numInputs, "outputs");
    require(this.activeInputIndex >= 1, "deposit input");
    isPool(tx.inputs[0].scriptPubKey);
    int idx = this.activeInputIndex;
    require(tx.inputs[idx].assets.length == 0, "sats");
    require(tx.inputs[idx].value > DUST, "dust");
    int mine = tx.inputs[idx].value - DUST;
    require(tx.outputs[idx].scriptPubKey == payScript, "borrower");
    require(tx.outputs[idx].value == DUST, "carrier");
    require(tx.outputs[idx].assets.lookup(collTxid, collGidx) == mine, "collateral token");
    require(tx.outputs[idx].assets.length == 1, "coll assets");
  }

  function refund() {
    require(tx.numInputs == 1, "one input");
    require(this.activeInputIndex == 0, "this output");
    require(tx.numOutputs == 1, "one output");
    require(tx.inputs[0].assets.length == 0, "sats");
    require(tx.outputs[0].scriptPubKey == payScript, "borrower");
    require(tx.outputs[0].value == tx.inputs[0].value, "value");
    require(tx.outputs[0].assets.length == 0, "sats out");
  }
}

lender_exit.ark

pragma arkade ^0.1.0;

import "./lending_pool.ark";

// Staging output for a lender exit. The holder sends lender shares here.
// payScript receives the stablecoin. Anyone may sweep this output with the pool.
contract LenderExit(
  bytes payScript,
  bytes32 stableTxid, int stableGidx,
  bytes32 lenderTxid, int lenderGidx,
  bytes32 collTxid, int collGidx,
  bytes32 debtTxid, int debtGidx,
  bytes32 lenderLedgTxid, int lenderLedgGidx,
  bytes32 debtLedgTxid, int debtLedgGidx,
  bytes32 ctrlTxid, int ctrlGidx,
  int feeBps, int satsPerUnit,
  pubkey noExitKey
) {
  const int DUST = 330;

  function exit() {
    require(tx.numInputs >= 2, "batch");
    require(tx.numInputs <= 5, "batch");
    require(tx.numOutputs == tx.numInputs, "outputs");
    require(this.activeInputIndex >= 1, "stage input");
    require(tx.inputs[0].scriptPubKey == new LendingPool(
      stableTxid, stableGidx, lenderTxid, lenderGidx, collTxid, collGidx,
      debtTxid, debtGidx, lenderLedgTxid, lenderLedgGidx, debtLedgTxid, debtLedgGidx,
      ctrlTxid, ctrlGidx, feeBps, satsPerUnit, noExitKey
    ), "pool");
    int idx = this.activeInputIndex;
    require(tx.inputs[idx].value == DUST, "carrier");
    require(tx.inputs[idx].assets.length == 1, "shares only");
    int mine = tx.inputs[idx].assets.lookup(lenderTxid, lenderGidx);
    require(mine > 0, "burned");
    int supply = tx.inputs[0].assets.lookup(lenderLedgTxid, lenderLedgGidx);
    int prev = tx.inputs[0].assets.lookup(stableTxid, stableGidx);
    int payout = (mine * prev) / supply;
    require(payout > 0, "payout");
    require(tx.outputs[idx].scriptPubKey == payScript, "lender");
    require(tx.outputs[idx].value == DUST, "carrier");
    require(tx.outputs[idx].assets.lookup(stableTxid, stableGidx) == payout, "stable out");
    require(tx.outputs[idx].assets.length == 1, "stable only");
  }

  function refund() {
    require(tx.numInputs == 1, "one input");
    require(this.activeInputIndex == 0, "this output");
    require(tx.numOutputs == 1, "one output");
    int amt = tx.inputs[0].assets.lookup(lenderTxid, lenderGidx);
    require(tx.outputs[0].scriptPubKey == payScript, "lender");
    require(tx.outputs[0].value == tx.inputs[0].value, "value");
    require(tx.outputs[0].assets.lookup(lenderTxid, lenderGidx) == amt, "shares");
    require(tx.outputs[0].assets.length == 1, "shares only");
  }
}

borrower_exit.ark

pragma arkade ^0.1.0;

import "./lending_pool.ark";

// Staging output for a borrower exit. The holder sends collateral tokens here.
// payScript receives the bitcoin. Anyone may sweep this output with the pool.
contract BorrowerExit(
  bytes payScript,
  bytes32 stableTxid, int stableGidx,
  bytes32 lenderTxid, int lenderGidx,
  bytes32 collTxid, int collGidx,
  bytes32 debtTxid, int debtGidx,
  bytes32 lenderLedgTxid, int lenderLedgGidx,
  bytes32 debtLedgTxid, int debtLedgGidx,
  bytes32 ctrlTxid, int ctrlGidx,
  int feeBps, int satsPerUnit,
  pubkey noExitKey
) {
  const int DUST = 330;

  function exit() {
    require(tx.numInputs >= 2, "batch");
    require(tx.numInputs <= 5, "batch");
    require(tx.numOutputs == tx.numInputs, "outputs");
    require(this.activeInputIndex >= 1, "stage input");
    require(tx.inputs[0].scriptPubKey == new LendingPool(
      stableTxid, stableGidx, lenderTxid, lenderGidx, collTxid, collGidx,
      debtTxid, debtGidx, lenderLedgTxid, lenderLedgGidx, debtLedgTxid, debtLedgGidx,
      ctrlTxid, ctrlGidx, feeBps, satsPerUnit, noExitKey
    ), "pool");
    int idx = this.activeInputIndex;
    require(tx.inputs[idx].value == DUST, "carrier");
    require(tx.inputs[idx].assets.length == 1, "coll only");
    int mine = tx.inputs[idx].assets.lookup(collTxid, collGidx);
    require(mine > 0, "burned");
    require(tx.outputs[idx].scriptPubKey == payScript, "borrower");
    require(tx.outputs[idx].value == mine + DUST, "btc out");
    require(tx.outputs[idx].assets.length == 0, "sats");
  }

  function refund() {
    require(tx.numInputs == 1, "one input");
    require(this.activeInputIndex == 0, "this output");
    require(tx.numOutputs == 1, "one output");
    int amt = tx.inputs[0].assets.lookup(collTxid, collGidx);
    require(tx.outputs[0].scriptPubKey == payScript, "borrower");
    require(tx.outputs[0].value == tx.inputs[0].value, "value");
    require(tx.outputs[0].assets.lookup(collTxid, collGidx) == amt, "collateral");
    require(tx.outputs[0].assets.length == 1, "coll only");
  }
}

arkadec lending_pool.ark -o lending_pool.json
arkadec lender_deposit.ark -o lender_deposit.json
arkadec borrower_deposit.ark -o borrower_deposit.json
arkadec lender_exit.ark -o lender_exit.json
arkadec borrower_exit.ark -o borrower_exit.json

Shared parameters

Parameter	Bound as
`stableTxid`, `stableGidx`	The stablecoin lenders deposit and borrowers take.
`lenderTxid`, `lenderGidx`	The lender share. One unit is one stablecoin unit deposited.
`collTxid`, `collGidx`	The collateral token. One unit is one sat of bitcoin deposited.
`debtTxid`, `debtGidx`	The debt token. One unit is one stablecoin unit borrowed.
`lenderLedgTxid`, `lenderLedgGidx`	Ledger asset on the pool. Its amount is the lender supply.
`debtLedgTxid`, `debtLedgGidx`	Ledger asset on the pool. Its amount is the debt supply.
`ctrlTxid`, `ctrlGidx`	The control token. The pool keeps the one unit.
`feeBps`	Fixed fee on repay, in basis points of the debt.
`satsPerUnit`	Collateral sats required for one stablecoin unit of debt.
`noExitKey`	The BIP341 NUMS point. Nobody can spend the pool’s `unilateral`.

The four standing contracts add payScript. That is the witness program that receives the minted token, or the payout.

LendingPool

sweepLender spends the pool and one to four lender deposits. It checks that each output mints the stablecoin that input brought in. sweepBorrower spends the pool and one to four bitcoin deposits. It checks that each output mints the collateral that input brought in. borrow spends the pool, a collateral-token output, and 660 sats of carriers. It returns the collateral tokens, pays the stablecoin, and mints the debt token. The debt output carries 330 of the 660 sats. The other 330 sats stay in the transaction as a fee on every borrow, on top of feeBps on repay. repay spends the pool, a debt-token output, and a stablecoin output of the debt plus the fee. It burns the debt. withdrawLender spends the pool and one to four lender staging outputs. It burns the shares and checks each stablecoin payout. withdrawColl spends the pool and one to four borrower staging outputs. It burns the collateral tokens and checks each bitcoin payout. unilateral is the NUMS exit leaf. Nobody can spend it.

Standing outputs

LenderDeposit.open creates the pool from the first stablecoin deposit. sweep joins a later batch and requires output i to pay this output’s payScript. BorrowerDeposit.open creates the pool from the first bitcoin deposit. sweep joins a later batch the same way. LenderExit.exit requires output i to pay this output’s payScript the share of stablecoin for the shares on this output. BorrowerExit.exit requires output i to pay this output’s payScript one sat for each collateral token on this output. refund on each standing output pays that output back to payScript. The pool is not an input.

Understand

Reference

Shared parameters

LendingPool

Standing outputs

​Shared parameters

​LendingPool

​Standing outputs

Shared parameters

LendingPool

Standing outputs