@argonprotocol/mainchain 1.3.8 → 1.3.9

package/browser/index.js

@@ -390,8 +390,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
       )
     };
@@ -406,8 +406,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
         )
       };
@@ -439,7 +439,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();
@@ -483,10 +483,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),
@@ -560,7 +557,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));
@@ -570,7 +591,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));
@@ -665,6 +686,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();
@@ -688,6 +710,7 @@ var BitcoinLocks = class {
       vaultClaimHeight,
       openClaimHeight,
       createdAtHeight,
+      securityFees,
       isVerified,
       isRejectedNeedsRelease,
       fundHoldExtensionsByBitcoinExpirationHeight
@@ -783,7 +806,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(
@@ -796,7 +819,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({
@@ -844,14 +867,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,
@@ -865,10 +889,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)
@@ -891,17 +912,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) {
@@ -912,7 +929,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,
@@ -921,9 +938,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),
@@ -955,15 +972,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,
@@ -971,6 +995,63 @@ var BitcoinLocks = class {
     };
   }
 };
+var PriceIndex = class {
+  constructor() {
+    __publicField(this, "btcUsdPrice");
+    __publicField(this, "argonotUsdPrice");
+    __publicField(this, "argonUsdPrice");
+    __publicField(this, "argonUsdTargetPrice");
+    __publicField(this, "argonTimeWeightedAverageLiquidity");
+    __publicField(this, "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(BigNumber2__default.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);
+  }
+};
 async function waitForLoad() {
   await cryptoWaitReady();
 }
@@ -984,6 +1065,6 @@ async function getClient(host, options) {
   return await ApiPromise.create({ provider, noInitWarn: true, ...options ?? {} });
 }
 
-export { BitcoinLocks, ExtrinsicError2 as ExtrinsicError, FIXED_U128_DECIMALS, MICROGONS_PER_ARGON, PERMILL_DECIMALS, SATS_PER_BTC, TxResult, TxSubmitter, Vault, WageProtector, checkForExtrinsicSuccess, createKeyringPair, dispatchErrorToExtrinsicError, dispatchErrorToString, formatArgons, fromFixedNumber, getAuthorFromHeader, getClient, getTickFromHeader, gettersToObject, keyringFromSuri, toFixedNumber, waitForLoad };
+export { BitcoinLocks, ExtrinsicError2 as ExtrinsicError, FIXED_U128_DECIMALS, MICROGONS_PER_ARGON, PERMILL_DECIMALS, PriceIndex, SATS_PER_BTC, TxResult, TxSubmitter, Vault, WageProtector, checkForExtrinsicSuccess, createKeyringPair, dispatchErrorToExtrinsicError, dispatchErrorToString, formatArgons, fromFixedNumber, getAuthorFromHeader, getClient, getTickFromHeader, gettersToObject, keyringFromSuri, toFixedNumber, waitForLoad };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map