Options

An options position is one contract. CoveredCall pays the holder when the fixing is above the strike. LimitedPut pays the holder when the fixing is below the strike. The read of the oracle output, the read fee, and the dust fold are Option. Both contracts call it. The writer and the holder are fixed in the constructor. arkade.trade runs a live desk that acts as the holder. The settlement price ST is the fixing for expiry, in USD cents. K is strike. Q is collateral. Division truncates. A covered call pays the holder Q * (ST - K) / ST when ST is above K. A limited put pays the holder Q * (K - ST) / ST when ST is below K. The put payment is at most Q. The holder receives no collateral when a covered call finishes at or below K, or a limited put finishes at or above K. settle spends this output as input 0 and the oracle output as input 1. Output 0 continues the oracle output. readFee sats of this output are added to that output. The payouts start at output 1 and sum to the locked value minus readFee. A leg of 330 sats or less folds into the other output. Anyone may submit settle once the emulator clock reaches expiry. writerScript and holderScript are 32-byte witness programs (tweakedPublicKey). Spend outputs use pkScript. serverExitDelay is not a parameter. The client binds it (CSV delays). unilateral is the exit if the operator is unavailable: after that delay, the writer alone signs. The holder gets nothing on that path. close checks the two signatures and does not check the outputs. The two parties can pay any scripts.

option.ark

pragma arkade ^0.1.0;

// The read of the oracle output, the read fee, and the dust fold. The call and the put each set the holder amount.
library Option {
  const int DUST = 330;
  const int PRICE_MAX = 1000000000;
  const int Q_MAX = 1000000000;
  const int STATE = 32;
  const int SIZE = 329;

  function open(int strike, int collateral, int expiry, bytes32 beaconTxid, int beaconGidx) {
    require(strike > 0, "strike");
    require(strike <= PRICE_MAX, "strike cap");
    require(collateral > DUST, "collateral");
    require(collateral <= Q_MAX, "collateral cap");
    require(checkTime(expiry), "before expiry");
    require(this.activeInputIndex == 0, "vault is input 0");
    require(tx.numInputs >= 2, "vault and beacon");
    require(tx.inputs[1].assets.lookup(beaconTxid, beaconGidx) == 1, "beacon");
  }

  function price(int expiry) int {
    bytes state = tx.inputs[1].packet(STATE);
    require(size(state) == SIZE, "state size");
    require(substr(state, 0, 1) == 0x01, "state version");
    int st = 0;
    int found = 0;
    int[8] slots = [9, 49, 89, 129, 169, 209, 249, 289];
    for (i, offset) in slots {
      if (found == 0 && substr(state, offset, 8) == num2bin(expiry, 8)) {
        st = bin2num(substr(state, (offset + 8), 8));
        found = 1;
      }
    }
    require(found == 1, "no fixing for expiry");
    require(st > 0, "price");
    require(st <= PRICE_MAX, "price cap");
    return st;
  }

  function pay(int ph, int collateral, int readFee, bytes32 holderScript, bytes32 writerScript) {
    require(ph <= collateral, "holder overpaid");
    int locked = tx.input.current.value;
    require(locked >= collateral, "underfunded");
    require(readFee >= 0, "fee");
    require(locked >= readFee, "fee");
    int pot = locked - readFee;
    int phPay = ph;
    if (phPay > pot) {
      phPay = pot;
    }
    int writerAmt = pot - phPay;
    let holderOut = tx.outputs[1].scriptPubKey;
    if (phPay > DUST && writerAmt > DUST) {
      require(tx.outputs[1].value >= phPay, "holder short");
      require(holderOut == holderScript, "holder script");
      require(tx.outputs[2].value >= writerAmt, "writer short");
      require(tx.outputs[2].scriptPubKey == writerScript, "writer script");
    }
    if (phPay <= DUST) {
      require(tx.outputs[1].value >= pot, "writer short");
      require(holderOut == writerScript, "writer script");
    }
    if (writerAmt <= DUST && phPay > DUST) {
      require(tx.outputs[1].value >= pot, "holder short");
      require(holderOut == holderScript, "holder script");
    }
  }
}

covered_call.ark

pragma arkade ^0.1.0;

import "./option.ark";

contract CoveredCall(
  pubkey writerPk,
  pubkey holderPk,
  bytes32 writerScript,
  bytes32 holderScript,
  int strike,
  int collateral,
  int expiry,
  bytes32 beaconTxid,
  int beaconGidx,
  int readFee
) {
  // Holder amount is collateral * (ST - K) / ST when ST is above the strike.
  function settle() {
    Option.open(strike, collateral, expiry, beaconTxid, beaconGidx);
    int st = Option.price(expiry);
    int ph = 0;
    if (st > strike) {
      ph = collateral * (st - strike) / st;
    }
    Option.pay(ph, collateral, readFee, holderScript, writerScript);
  }

  function close(signature writerSig, signature holderSig) {
    require(checkSig(writerSig, writerPk), "writer");
    require(checkSig(holderSig, holderPk), "holder");
  }

  function unilateral(signature writerSig) tapscript {
    require(older(serverExitDelay));
    require(checkSig(writerSig, writerPk));
  }
}

limited_put.ark

pragma arkade ^0.1.0;

import "./option.ark";

contract LimitedPut(
  pubkey writerPk,
  pubkey holderPk,
  bytes32 writerScript,
  bytes32 holderScript,
  int strike,
  int collateral,
  int expiry,
  bytes32 beaconTxid,
  int beaconGidx,
  int readFee
) {
  // Holder amount is collateral * (K - ST) / ST when ST is below the strike, and at most collateral.
  function settle() {
    Option.open(strike, collateral, expiry, beaconTxid, beaconGidx);
    int st = Option.price(expiry);
    int ph = 0;
    if (st < strike) {
      ph = collateral * (strike - st) / st;
      if (ph > collateral) {
        ph = collateral;
      }
    }
    Option.pay(ph, collateral, readFee, holderScript, writerScript);
  }

  function close(signature writerSig, signature holderSig) {
    require(checkSig(writerSig, writerPk), "writer");
    require(checkSig(holderSig, holderPk), "holder");
  }

  function unilateral(signature writerSig) tapscript {
    require(older(serverExitDelay));
    require(checkSig(writerSig, writerPk));
  }
}

arkadec covered_call.ark -o covered_call.json
arkadec limited_put.ark -o limited_put.json

Constructor

Parameter	Bound as
`writerPk`, `holderPk`	The writer and the holder, as 32-byte x-only keys. Both sign `close`. The writer signs `unilateral`.
`writerScript`, `holderScript`	32-byte witness programs. `settle` pays these scripts.
`strike`	`K`, in USD cents. Above 0 and at most 1000000000.
`collateral`	`Q`, in sats. Above 330 and at most 1000000000.
`expiry`	Unix seconds. `settle` waits for the emulator clock.
`beaconTxid`, `beaconGidx`	The oracle output’s identity asset. Input 1 holds one unit.
`readFee`	Sats added to the oracle output on `settle`. The Mutinynet deployment uses 1000.

Both contracts take these parameters. Option holds the checks they share.

Functions

CoveredCall.settle pays collateral * (ST - K) / ST when the fixing is above the strike. LimitedPut.settle pays collateral * (K - ST) / ST when the fixing is below the strike, and at most collateral. close requires both signatures. unilateral is the exit if the operator is unavailable. After serverExitDelay, the writer alone signs and can take the whole output.

Understand

Reference

Constructor

Functions

​Constructor

​Functions

Constructor

Functions