@argonprotocol/mainchain 1.3.8 → 1.3.9

package/lib/index.js

@@ -401,8 +401,8 @@ var Vault = class _Vault {
         FIXED_U128_DECIMALS
       ),
       bitcoinBaseFee: vault.terms.bitcoinBaseFee.toBigInt(),
-      liquidityPoolProfitSharing: fromFixedNumber(
-        vault.terms.liquidityPoolProfitSharing.toBigInt(),
+      treasuryProfitSharing: fromFixedNumber(
+        vault.terms.treasuryProfitSharing.toBigInt(),
         PERMILL_DECIMALS
       )
     };
@@ -417,8 +417,8 @@ var Vault = class _Vault {
           FIXED_U128_DECIMALS
         ),
         bitcoinBaseFee: terms.bitcoinBaseFee.toBigInt(),
-        liquidityPoolProfitSharing: fromFixedNumber(
-          vault.terms.liquidityPoolProfitSharing.toBigInt(),
+        treasuryProfitSharing: fromFixedNumber(
+          vault.terms.treasuryProfitSharing.toBigInt(),
           PERMILL_DECIMALS
         )
       };
@@ -450,7 +450,7 @@ var Vault = class _Vault {
     return BigInt(maxRatio.multipliedBy(activated.toString()).toFixed(0, ROUND_FLOOR2));
   }
   /**
-   * Returns the amount of Argons available to match per liquidity pool
+   * Returns the amount of Argons available to match per treasury pool
    */
   activatedSecuritizationPerSlot() {
     const activated = this.activatedSecuritization();
@@ -494,10 +494,7 @@ var Vault = class _Vault {
         // convert to fixed u128
         bitcoinAnnualPercentRate: toFixedNumber(annualPercentRate, FIXED_U128_DECIMALS),
         bitcoinBaseFee: BigInt(baseFee),
-        liquidityPoolProfitSharing: toFixedNumber(
-          args.liquidityPoolProfitSharing,
-          PERMILL_DECIMALS
-        )
+        treasuryProfitSharing: toFixedNumber(args.treasuryProfitSharing, PERMILL_DECIMALS)
       },
       securitizationRatio: toFixedNumber(securitizationRatio, FIXED_U128_DECIMALS),
       securitization: BigInt(securitization),
@@ -577,7 +574,31 @@ var BitcoinLocks = class {
     }
     return void 0;
   }
-  async getMarketRate(satoshis) {
+  async getMarketRate(priceIndex, satoshis) {
+    return priceIndex.getBtcMicrogonPrice(satoshis);
+  }
+  async getRedemptionRate(priceIndex, details) {
+    const { satoshis, peggedPrice } = details;
+    const satsPerArgon = Number(SATS_PER_BTC) / MICROGONS_PER_ARGON;
+    let price = Number(priceIndex.btcUsdPrice);
+    price = price / satsPerArgon * Number(satoshis);
+    if (peggedPrice !== void 0 && peggedPrice < price) {
+      price = Number(peggedPrice);
+    }
+    const r = Number(priceIndex.rValue);
+    let multiplier;
+    if (r >= 1) {
+      multiplier = 1;
+    } else if (r >= 0.9) {
+      multiplier = 20 * (r * r) - 38 * r + 19;
+    } else if (r >= 0.01) {
+      multiplier = (0.5618 * r + 0.3944) / r;
+    } else {
+      multiplier = 1 / r * (0.576 * r + 0.4);
+    }
+    return BigInt(Math.floor(price * multiplier));
+  }
+  async getMarketRateApi(satoshis) {
     const client = this.client;
     const sats = client.createType("U64", satoshis.toString());
     const marketRate = await client.rpc.state.call("BitcoinApis_market_rate", sats.toHex(true));
@@ -587,7 +608,7 @@ var BitcoinLocks = class {
     }
     return rate.value.toBigInt();
   }
-  async getRedemptionRate(satoshis) {
+  async getRedemptionRateApi(satoshis) {
     const client = this.client;
     const sats = client.createType("U64", satoshis.toString());
     const marketRate = await client.rpc.state.call("BitcoinApis_redemption_rate", sats.toHex(true));
@@ -682,6 +703,7 @@ var BitcoinLocks = class {
       cosignHdIndex: cosign_hd_index.toNumber(),
       claimHdIndex: claim_hd_index.toNumber()
     };
+    const securityFees = utxo.securityFees.toBigInt();
     const vaultClaimHeight = utxo.vaultClaimHeight.toNumber();
     const openClaimHeight = utxo.openClaimHeight.toNumber();
     const createdAtHeight = utxo.createdAtHeight.toNumber();
@@ -705,6 +727,7 @@ var BitcoinLocks = class {
       vaultClaimHeight,
       openClaimHeight,
       createdAtHeight,
+      securityFees,
       isVerified,
       isRejectedNeedsRelease,
       fundHoldExtensionsByBitcoinExpirationHeight
@@ -800,7 +823,7 @@ var BitcoinLocks = class {
     return mintsPending;
   }
   async createInitializeLockTx(args) {
-    const { vault, argonKeyring, satoshis, tip = 0n, ownerBitcoinPubkey } = args;
+    const { vault, priceIndex, argonKeyring, satoshis, tip = 0n, ownerBitcoinPubkey } = args;
     const client = this.client;
     if (ownerBitcoinPubkey.length !== 33) {
       throw new Error(
@@ -813,7 +836,7 @@ var BitcoinLocks = class {
       client.tx.bitcoinLocks.initialize(vault.vaultId, satoshis, ownerBitcoinPubkey),
       argonKeyring
     );
-    const marketPrice = await this.getMarketRate(BigInt(satoshis));
+    const marketPrice = await this.getMarketRate(priceIndex, satoshis);
     const isVaultOwner = argonKeyring.address === vault.operatorAccountId;
     const securityFee = isVaultOwner ? 0n : vault.calculateBitcoinFee(marketPrice);
     const { canAfford, availableBalance, txFee } = await submitter.canAfford({
@@ -861,14 +884,15 @@ var BitcoinLocks = class {
       securityFee
     };
   }
-  async requiredSatoshisForArgonLiquidity(argonAmount) {
-    const marketRatePerBitcoin = await this.getMarketRate(SATS_PER_BTC);
+  async requiredSatoshisForArgonLiquidity(priceIndex, argonAmount) {
+    const marketRatePerBitcoin = priceIndex.getBtcMicrogonPrice(SATS_PER_BTC);
     return argonAmount * SATS_PER_BTC / marketRatePerBitcoin;
   }
   async requestRelease(args) {
     const client = this.client;
     const {
       lock,
+      priceIndex,
       releaseRequest: { bitcoinNetworkFee, toScriptPubkey },
       argonKeyring,
       tip,
@@ -882,10 +906,7 @@ var BitcoinLocks = class {
       client.tx.bitcoinLocks.requestRelease(lock.utxoId, toScriptPubkey, bitcoinNetworkFee),
       argonKeyring
     );
-    let redemptionPrice = await this.getRedemptionRate(lock.satoshis);
-    if (redemptionPrice > lock.peggedPrice) {
-      redemptionPrice = lock.peggedPrice;
-    }
+    const redemptionPrice = await this.getRedemptionRate(priceIndex, lock);
     const canAfford = await submitter.canAfford({
       tip,
       unavailableBalance: BigInt(redemptionPrice)
@@ -908,17 +929,13 @@ var BitcoinLocks = class {
       blockHeight
     };
   }
-  async releasePrice(satoshis, peggedPrice) {
-    const redemptionRate = await this.getRedemptionRate(satoshis);
-    if (redemptionRate > peggedPrice) {
-      return redemptionRate;
-    }
-    return peggedPrice;
+  async releasePrice(priceIndex, lock) {
+    return await this.getRedemptionRate(priceIndex, lock);
   }
-  async getRatchetPrice(lock, vault) {
+  async getRatchetPrice(lock, priceIndex, vault) {
     const { createdAtHeight, vaultClaimHeight, peggedPrice, satoshis } = lock;
     const client = this.client;
-    const marketRate = await this.getMarketRate(BigInt(satoshis));
+    const marketRate = await this.getMarketRate(priceIndex, BigInt(satoshis));
     let ratchetingFee = vault.terms.bitcoinBaseFee;
     let burnAmount = 0n;
     if (marketRate > peggedPrice) {
@@ -929,7 +946,7 @@ var BitcoinLocks = class {
       const remainingDuration = 1 - elapsed;
       ratchetingFee = BigInt(remainingDuration * Number(lockFee));
     } else {
-      burnAmount = await this.releasePrice(lock.satoshis, peggedPrice);
+      burnAmount = await this.releasePrice(priceIndex, lock);
     }
     return {
       ratchetingFee,
@@ -938,9 +955,9 @@ var BitcoinLocks = class {
     };
   }
   async ratchet(args) {
-    const { lock, argonKeyring, tip = 0n, vault, txProgressCallback } = args;
+    const { lock, priceIndex, argonKeyring, tip = 0n, vault, txProgressCallback } = args;
     const client = this.client;
-    const ratchetPrice = await this.getRatchetPrice(lock, vault);
+    const ratchetPrice = await this.getRatchetPrice(lock, priceIndex, vault);
     const txSubmitter = new TxSubmitter(
       client,
       client.tx.bitcoinLocks.ratchet(lock.utxoId),
@@ -972,15 +989,22 @@ var BitcoinLocks = class {
     const api = await client.at(blockHash);
     const blockHeight = await api.query.system.number().then((x) => x.toNumber());
     const bitcoinBlockHeight = await api.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => x.unwrap().blockHeight.toNumber());
-    const { amountBurned, newPeggedPrice, originalPeggedPrice } = ratchetEvent.data;
-    let mintAmount = newPeggedPrice.toBigInt();
-    if (newPeggedPrice > originalPeggedPrice) {
+    const {
+      amountBurned,
+      liquidityPromised: liquidityPromisedRaw,
+      newPeggedPrice,
+      originalPeggedPrice
+    } = ratchetEvent.data;
+    const liquidityPromised = liquidityPromisedRaw.toBigInt();
+    let mintAmount = liquidityPromised;
+    if (liquidityPromised > originalPeggedPrice.toBigInt()) {
       mintAmount -= originalPeggedPrice.toBigInt();
     }
     return {
       txFee: submission.finalFee ?? 0n,
       securityFee: ratchetPrice.ratchetingFee,
       pendingMint: mintAmount,
+      liquidityPromised,
       newPeggedPrice: newPeggedPrice.toBigInt(),
       burned: amountBurned.toBigInt(),
       blockHeight,
@@ -989,6 +1013,64 @@ var BitcoinLocks = class {
   }
 };
 
+// src/PriceIndex.ts
+import BigNumber4 from "bignumber.js";
+var PriceIndex = class {
+  btcUsdPrice;
+  argonotUsdPrice;
+  argonUsdPrice;
+  argonUsdTargetPrice;
+  argonTimeWeightedAverageLiquidity;
+  lastUpdatedTick;
+  async load(client) {
+    const current = await client.query.priceIndex.current();
+    if (!current.isSome) {
+      this.argonUsdPrice = void 0;
+      this.argonotUsdPrice = void 0;
+      this.btcUsdPrice = void 0;
+      this.argonUsdTargetPrice = void 0;
+      this.argonTimeWeightedAverageLiquidity = void 0;
+      this.lastUpdatedTick = void 0;
+      return this;
+    }
+    const value = current.unwrap();
+    this.btcUsdPrice = fromFixedNumber(value.btcUsdPrice.toBigInt(), FIXED_U128_DECIMALS);
+    this.argonotUsdPrice = fromFixedNumber(value.argonotUsdPrice.toBigInt(), FIXED_U128_DECIMALS);
+    this.argonUsdPrice = fromFixedNumber(value.argonUsdPrice.toBigInt(), FIXED_U128_DECIMALS);
+    this.argonUsdTargetPrice = fromFixedNumber(
+      value.argonUsdTargetPrice.toBigInt(),
+      FIXED_U128_DECIMALS
+    );
+    this.argonTimeWeightedAverageLiquidity = fromFixedNumber(
+      value.argonTimeWeightedAverageLiquidity.toBigInt(),
+      FIXED_U128_DECIMALS
+    );
+    this.lastUpdatedTick = value.tick.toNumber();
+    return this;
+  }
+  getBtcMicrogonPrice(satoshis) {
+    if (this.btcUsdPrice === void 0 || this.argonUsdPrice === void 0) {
+      throw new Error("PriceIndex not loaded");
+    }
+    const satoshiCents = this.btcUsdPrice.multipliedBy(satoshis).dividedBy(SATS_PER_BTC);
+    const microgons = satoshiCents.multipliedBy(MICROGONS_PER_ARGON).dividedBy(this.argonUsdPrice);
+    return BigInt(microgons.integerValue(BigNumber4.ROUND_DOWN).toString());
+  }
+  get rValue() {
+    if (this.argonUsdTargetPrice === void 0 || this.argonUsdPrice === void 0) {
+      throw new Error("PriceIndex not loaded");
+    }
+    return this.argonUsdPrice.div(this.argonUsdTargetPrice);
+  }
+  get argonCpi() {
+    if (this.argonUsdTargetPrice === void 0 || this.argonUsdPrice === void 0) {
+      throw new Error("PriceIndex not loaded");
+    }
+    const ratio = this.argonUsdTargetPrice.div(this.argonUsdPrice);
+    return ratio.minus(1);
+  }
+};
+
 // src/index.ts
 import { u8aToHex as u8aToHex2, hexToU8a as hexToU8a2, u8aEq } from "@polkadot/util";
 import { GenericEvent as GenericEvent2, GenericBlock, GenericAddress } from "@polkadot/types/generic";
@@ -1045,6 +1127,7 @@ export {
   Null,
   Option,
   PERMILL_DECIMALS,
+  PriceIndex,
   Range,
   Result,
   SATS_PER_BTC,