@argonprotocol/mainchain 1.2.0 → 1.3.1

package/lib/{chunk-BQR6FEVP.js → chunk-FNSFV3MO.js}

@@ -15,7 +15,7 @@ import {
   keyringFromSuri,
   mnemonicGenerate,
   parseSubaccountRange
-} from "./chunk-RXCQYVE7.js";
+} from "./chunk-CGXT6XF7.js";
 
 // src/clis/index.ts
 import { Command as Command6, Option } from "@commander-js/extra-typings";
@@ -27,9 +27,7 @@ import { cryptoWaitReady } from "@polkadot/util-crypto";
 import { writeFileSync } from "node:fs";
 import * as process2 from "node:process";
 function accountCli() {
-  const program = new Command("accounts").description(
-    "Manage subaccounts from a single keypair"
-  );
+  const program = new Command("accounts").description("Manage subaccounts from a single keypair");
   program.command("watch").description("Watch for blocks closed by subaccounts").action(async () => {
     const accountset = await accountsetFromCli(program);
     const accountMiners = await accountset.watchBlocks();
@@ -68,10 +66,7 @@ function accountCli() {
   program.command("create").description('Create an account "env" file and optionally register keys').requiredOption(
     "--path <path>",
     "The path to an env file to create (convention is .env.<name>)"
-  ).option(
-    "--register-keys-to <url>",
-    "Register the keys to a url (normally this is localhost)"
-  ).action(async ({ registerKeysTo, path }) => {
+  ).option("--register-keys-to <url>", "Register the keys to a url (normally this is localhost)").action(async ({ registerKeysTo, path }) => {
     const { accountPassphrase, accountSuri, accountFilePath } = globalOptions(program);
     const accountset = await accountsetFromCli(program);
     process2.env.KEYS_MNEMONIC ||= mnemonicGenerate();
@@ -100,20 +95,14 @@ function accountCli() {
   program.command("new-key-seed").description("Create a new mnemonic for runtime keys").action(async () => {
     await cryptoWaitReady();
     const mnemonic = mnemonicGenerate();
-    console.log(
-      "New mnemonic (add this to your .env as KEYS_MNEMONIC):",
-      mnemonic
-    );
+    console.log("New mnemonic (add this to your .env as KEYS_MNEMONIC):", mnemonic);
     process2.exit(0);
   });
   program.command("register-keys").description("Create an insert-keys script with curl").argument(
     "[node-rpc-url]",
     "The url to your node host (should be installed on machine via localhost)",
     "http://localhost:9944"
-  ).option(
-    "--print-only",
-    "Output as curl commands instead of direct registration"
-  ).action(async (nodeRpcUrl, { printOnly }) => {
+  ).option("--print-only", "Output as curl commands instead of direct registration").action(async (nodeRpcUrl, { printOnly }) => {
     const accountset = await accountsetFromCli(program);
     if (printOnly) {
       const { gran, seal } = accountset.keys();
@@ -163,9 +152,7 @@ import Path from "node:path";
 // src/clis/vaultCli.ts
 import { Command as Command2 } from "@commander-js/extra-typings";
 function vaultCli() {
-  const program = new Command2("vaults").description(
-    "Monitor vaults and manage securitization"
-  );
+  const program = new Command2("vaults").description("Monitor vaults and manage securitization");
   program.command("list", { isDefault: true }).description("Show current state of vaults").action(async () => {
     const accountset = await accountsetFromCli(program);
     const vaults = new VaultMonitor(accountset, void 0, {
@@ -178,11 +165,7 @@ function vaultCli() {
     "-a, --argons <amount>",
     "The number of argons to set as securitization",
     parseFloat
-  ).option("--ratio <ratio>", "The new securitization ratio", parseFloat).option(
-    "--tip <amount>",
-    "The tip to include with the transaction",
-    parseFloat
-  ).action(async ({ tip, argons, vaultId, ratio }) => {
+  ).option("--ratio <ratio>", "The new securitization ratio", parseFloat).option("--tip <amount>", "The tip to include with the transaction", parseFloat).action(async ({ tip, argons, vaultId, ratio }) => {
     const accountset = await accountsetFromCli(program);
     const client = await accountset.client;
     const resolvedTip = tip ? BigInt(tip * MICROGONS_PER_ARGON) : 0n;
@@ -221,28 +204,13 @@ function vaultCli() {
       process.exit(1);
     }
   });
-  program.command("make-bitcoin-space").description(
-    "Make bitcoin space in a vault and lock it immediately in the same tx."
-  ).requiredOption("-v, --vault-id <id>", "The vault id to use", parseInt).requiredOption(
-    "-a, --argons <amount>",
-    "The number of argons to add",
-    parseFloat
-  ).requiredOption(
-    "--bitcoin-pubkey <pubkey>",
-    "The pubkey to use for the bitcoin lock"
-  ).option(
-    "--tip <amount>",
-    "The tip to include with the transaction",
-    parseFloat
-  ).action(async ({ tip, argons, vaultId, bitcoinPubkey }) => {
+  program.command("make-bitcoin-space").description("Make bitcoin space in a vault and lock it immediately in the same tx.").requiredOption("-v, --vault-id <id>", "The vault id to use", parseInt).requiredOption("-a, --argons <amount>", "The number of argons to add", parseFloat).requiredOption("--bitcoin-pubkey <pubkey>", "The pubkey to use for the bitcoin lock").option("--tip <amount>", "The tip to include with the transaction", parseFloat).action(async ({ tip, argons, vaultId, bitcoinPubkey }) => {
     let pubkey = bitcoinPubkey;
     if (!bitcoinPubkey.startsWith("0x")) {
       pubkey = `0x${bitcoinPubkey}`;
     }
     if (pubkey.length !== 68) {
-      throw new Error(
-        "Bitcoin pubkey must be 66 characters (add 0x in front optionally)"
-      );
+      throw new Error("Bitcoin pubkey must be 66 characters (add 0x in front optionally)");
     }
     const accountset = await accountsetFromCli(program);
     const client = await accountset.client;
@@ -267,32 +235,31 @@ function vaultCli() {
     const argonsAvailable = microgons - vault.availableBitcoinSpace();
     const account = await client.query.system.account(accountset.seedAddress);
     const freeBalance = account.data.free.toBigInt();
+    let satoshis = await bitcoinLocks.requiredSatoshisForArgonLiquidity(argonsAvailable);
+    satoshis -= 100n;
     const {
       tx: lockTx,
-      btcFee,
+      securityFee: btcFee,
       txFee
-    } = await bitcoinLocks.buildBitcoinLockTx({
-      vaultId,
-      keypair: accountset.txSubmitterPair,
-      amount: argonsAvailable,
-      bitcoinXpub: pubkey,
+    } = await bitcoinLocks.createInitializeLockTx({
+      vault,
+      argonKeyring: accountset.txSubmitterPair,
+      satoshis,
+      ownerBitcoinPubkey: Buffer.from(pubkey, "hex"),
       tip: resolvedTip,
       reducedBalanceBy: argonsNeeded + vaultTxFee + resolvedTip
     });
     if (argonsNeeded + txFee + vaultTxFee + resolvedTip + btcFee + existentialDeposit > freeBalance) {
-      console.warn(
-        "Insufficient balance to add bitcoin space and use bitcoins",
-        {
-          freeBalance,
-          txFee,
-          vaultTxFee,
-          btcFee,
-          argonsAvailable,
-          vaultMicrogons: microgons,
-          existentialDeposit,
-          neededBalanceAboveED: argonsNeeded + txFee + resolvedTip + btcFee + vaultTxFee
-        }
-      );
+      console.warn("Insufficient balance to add bitcoin space and use bitcoins", {
+        freeBalance,
+        txFee,
+        vaultTxFee,
+        btcFee,
+        argonsAvailable,
+        vaultMicrogons: microgons,
+        existentialDeposit,
+        neededBalanceAboveED: argonsNeeded + txFee + resolvedTip + btcFee + vaultTxFee
+      });
       process.exit(1);
     }
     console.log("Adding bitcoin space and locking bitcoins...", {
@@ -323,9 +290,7 @@ function vaultCli() {
 import { Command as Command3 } from "@commander-js/extra-typings";
 import { printTable as printTable2 } from "console-table-printer";
 function miningCli() {
-  const program = new Command3("mining").description(
-    "Watch mining seats or setup bidding"
-  );
+  const program = new Command3("mining").description("Watch mining seats or setup bidding");
   program.command("list", { isDefault: true }).description("Monitor all miners").action(async () => {
     const accountset = await accountsetFromCli(program);
     const bids = new MiningBids(accountset.client);
@@ -351,73 +316,61 @@ function miningCli() {
         );
       }
       if (!bids.nextCohort.length) {
-        console.log(
-          "-------------------------------------\nNo bids for next cohort"
-        );
+        console.log("-------------------------------------\nNo bids for next cohort");
       } else {
         bids.print();
       }
     }
-    const { unsubscribe } = await bids.watch(
-      accountset.namedAccounts,
-      void 0,
-      print
-    );
+    const { unsubscribe } = await bids.watch(accountset.namedAccounts, void 0, print);
     console.log("Watching miners...");
     const minMiners = api.consts.miningSlot.minCohortSize.toNumber();
-    const unsub = await api.query.miningSlot.nextFrameId(
-      async (nextFrameId) => {
-        const frames = new Array(nextFrameId.toNumber()).fill(0).map((_, i) => nextFrameId.toNumber() - i).sort();
-        const unseenFrames = new Set(frames);
-        const entries = await api.query.miningSlot.minersByCohort.entries();
-        const block = await api.query.system.number();
-        const sortedEntries = entries.sort((a, b) => {
-          const aIndex = a[0].args[0].toNumber();
-          const bIndex = b[0].args[0].toNumber();
-          return aIndex - bIndex;
-        });
-        for (const [rawFrameId, miners] of sortedEntries) {
-          const frameId = rawFrameId.args[0].toNumber();
-          unseenFrames.delete(frameId);
-          let i = 0;
-          for (const miner of miners) {
-            const address = miner.accountId.toHuman();
-            const startingFrameId = miner.startingFrameId.toNumber();
-            lastMiners[`${frameId}-${i}`] = {
-              miner: accountset.namedAccounts.get(address) ?? address,
-              bid: miner.bid.toBigInt(),
-              isLastDay: nextFrameId.toNumber() - startingFrameId === 10
-            };
-            i++;
-          }
-          while (i < minMiners) {
-            lastMiners[`${frameId}-${i}`] = {
-              miner: "none"
-            };
-            i++;
-          }
+    const unsub = await api.query.miningSlot.nextFrameId(async (nextFrameId) => {
+      const frames = new Array(nextFrameId.toNumber()).fill(0).map((_, i) => nextFrameId.toNumber() - i).sort();
+      const unseenFrames = new Set(frames);
+      const entries = await api.query.miningSlot.minersByCohort.entries();
+      const block = await api.query.system.number();
+      const sortedEntries = entries.sort((a, b) => {
+        const aIndex = a[0].args[0].toNumber();
+        const bIndex = b[0].args[0].toNumber();
+        return aIndex - bIndex;
+      });
+      for (const [rawFrameId, miners] of sortedEntries) {
+        const frameId = rawFrameId.args[0].toNumber();
+        unseenFrames.delete(frameId);
+        let i = 0;
+        for (const miner of miners) {
+          const address = miner.accountId.toHuman();
+          const startingFrameId = miner.startingFrameId.toNumber();
+          lastMiners[`${frameId}-${i}`] = {
+            miner: accountset.namedAccounts.get(address) ?? address,
+            bid: miner.bid.toBigInt(),
+            isLastDay: nextFrameId.toNumber() - startingFrameId === 10
+          };
+          i++;
         }
-        for (const frameId of unseenFrames) {
-          for (let i = 0; i < minMiners; i++) {
-            lastMiners[`${frameId}-${i}`] = {
-              miner: "none"
-            };
-          }
+        while (i < minMiners) {
+          lastMiners[`${frameId}-${i}`] = {
+            miner: "none"
+          };
+          i++;
         }
-        print(block.toNumber());
       }
-    );
+      for (const frameId of unseenFrames) {
+        for (let i = 0; i < minMiners; i++) {
+          lastMiners[`${frameId}-${i}`] = {
+            miner: "none"
+          };
+        }
+      }
+      print(block.toNumber());
+    });
     process.on("SIGINT", () => {
       unsubscribe();
       unsub();
       process.exit(0);
     });
   });
-  program.command("bid").description("Submit mining bids within a range of parameters").option("--min-bid <amount>", "The minimum bid amount to use", parseFloat).option("--max-bid <amount>", "The maximum bid amount to use", parseFloat).option(
-    "--max-seats <n>",
-    "The maximum number of seats to bid on for the slot",
-    parseInt
-  ).option(
+  program.command("bid").description("Submit mining bids within a range of parameters").option("--min-bid <amount>", "The minimum bid amount to use", parseFloat).option("--max-bid <amount>", "The maximum bid amount to use", parseFloat).option("--max-seats <n>", "The maximum number of seats to bid on for the slot", parseInt).option(
     "--max-balance <argons>",
     "Use a maximum amount of the user's balance for the slot. If this ends in a percent, it will be a percent of the funds"
   ).option("--bid-increment <argons>", "The bid increment", parseFloat, 0.01).option("--bid-delay <ticks>", "Delay between bids in ticks", parseInt, 0).option("--run-continuous", "Keep running and rebid every day").option(
@@ -474,9 +427,7 @@ function miningCli() {
               }
               maxBalanceToUse = amountToBid;
             } else {
-              maxBalanceToUse = BigInt(
-                Math.floor(parseFloat(maxBalance) * MICROGONS_PER_ARGON)
-              );
+              maxBalanceToUse = BigInt(Math.floor(parseFloat(maxBalance) * MICROGONS_PER_ARGON));
             }
             maxBidAmount ??= maxBalanceToUse / BigInt(seatsToWin);
           }
@@ -491,20 +442,13 @@ function miningCli() {
           if (cohortBidder && cohortBidder?.cohortStartingFrameId !== cohortStartingFrameId) {
             await stopBidder(unsubscribe);
           }
-          cohortBidder = new CohortBidder(
-            accountset,
-            cohortStartingFrameId,
-            subaccountRange,
-            {
-              maxBid: maxBidAmount,
-              minBid: BigInt((minBid ?? 0) * MICROGONS_PER_ARGON),
-              bidIncrement: BigInt(
-                Math.floor(bidIncrement * MICROGONS_PER_ARGON)
-              ),
-              maxBudget: maxBalanceToUse,
-              bidDelay
-            }
-          );
+          cohortBidder = new CohortBidder(accountset, cohortStartingFrameId, subaccountRange, {
+            maxBid: maxBidAmount,
+            minBid: BigInt((minBid ?? 0) * MICROGONS_PER_ARGON),
+            bidIncrement: BigInt(Math.floor(bidIncrement * MICROGONS_PER_ARGON)),
+            maxBudget: maxBalanceToUse,
+            bidDelay
+          });
           await cohortBidder.start();
         }
       });
@@ -517,10 +461,7 @@ function miningCli() {
     "--fee-argons <argons>",
     "How many argons should be sent to the proxy account for fees (proxies must pay fees)",
     parseFloat
-  ).option(
-    "--proxy-passphrase <passphrase>",
-    "The passphrase for your proxy account"
-  ).action(async ({ outfile, proxyPassphrase, feeArgons }) => {
+  ).option("--proxy-passphrase <passphrase>", "The passphrase for your proxy account").action(async ({ outfile, proxyPassphrase, feeArgons }) => {
     const { mainchainUrl } = globalOptions(program);
     const client = await getClient(mainchainUrl);
     const keyringPair = await saveKeyringPair({
@@ -528,15 +469,10 @@ function miningCli() {
       passphrase: proxyPassphrase
     });
     const address = keyringPair.address;
-    console.log(
-      `\u2705 Created proxy account at "${outfile}" with address ${address}`
-    );
+    console.log(`\u2705 Created proxy account at "${outfile}" with address ${address}`);
     const tx = client.tx.utility.batchAll([
       client.tx.proxy.addProxy(address, "MiningBid", 0),
-      client.tx.balances.transferAllowDeath(
-        address,
-        BigInt(feeArgons * MICROGONS_PER_ARGON)
-      )
+      client.tx.balances.transferAllowDeath(address, BigInt(feeArgons * MICROGONS_PER_ARGON))
     ]);
     let keypair;
     try {
@@ -564,53 +500,27 @@ function miningCli() {
 // src/clis/liquidityCli.ts
 import { Command as Command4 } from "@commander-js/extra-typings";
 function liquidityCli() {
-  const program = new Command4("liquidity-pools").description(
-    "Monitor or bond to liquidity pools"
-  );
+  const program = new Command4("liquidity-pools").description("Monitor or bond to liquidity pools");
   program.command("list", { isDefault: true }).description("Show or watch the vault bid pool rewards").action(async () => {
     const accountset = await accountsetFromCli(program);
-    const bidPool = new BidPool(
-      accountset.client,
-      accountset.txSubmitterPair
-    );
+    const bidPool = new BidPool(accountset.client, accountset.txSubmitterPair);
     await bidPool.watch();
   });
-  program.command("bond").description("Bond argons to a liquidity pool").requiredOption("-v, --vault-id <id>", "The vault id to use", parseInt).requiredOption(
-    "-a, --argons <amount>",
-    "The number of argons to set the vault to",
-    parseFloat
-  ).option(
-    "--tip <amount>",
-    "The tip to include with the transaction",
-    parseFloat
-  ).action(async ({ tip, argons, vaultId }) => {
+  program.command("bond").description("Bond argons to a liquidity pool").requiredOption("-v, --vault-id <id>", "The vault id to use", parseInt).requiredOption("-a, --argons <amount>", "The number of argons to set the vault to", parseFloat).option("--tip <amount>", "The tip to include with the transaction", parseFloat).action(async ({ tip, argons, vaultId }) => {
     const accountset = await accountsetFromCli(program);
     const resolvedTip = tip ? BigInt(tip * MICROGONS_PER_ARGON) : 0n;
     const microgons = BigInt(argons * MICROGONS_PER_ARGON);
-    const bidPool = new BidPool(
-      accountset.client,
-      accountset.txSubmitterPair
-    );
+    const bidPool = new BidPool(accountset.client, accountset.txSubmitterPair);
     await bidPool.bondArgons(vaultId, microgons, { tip: resolvedTip });
     console.log("Bonded argons to liquidity pool bond");
     process.exit();
   });
-  program.command("wait-for-space").description(
-    "Add bonded argons to a liquidity pool when the market rate is favorable"
-  ).requiredOption(
-    "--max-argons <amount>",
-    "Max daily argons to use per slot",
-    parseFloat
-  ).option(
+  program.command("wait-for-space").description("Add bonded argons to a liquidity pool when the market rate is favorable").requiredOption("--max-argons <amount>", "Max daily argons to use per slot", parseFloat).option(
     "--min-pct-sharing <percent>",
     "The minimum profit sharing percent to allow",
     parseInt,
     30
-  ).option(
-    "--tip <amount>",
-    "The tip to include with the transaction",
-    parseFloat
-  ).action(async ({ maxArgons, minPctSharing, tip }) => {
+  ).option("--tip <amount>", "The tip to include with the transaction", parseFloat).action(async ({ maxArgons, minPctSharing, tip }) => {
     const maxAmountPerSlot = BigInt(maxArgons * MICROGONS_PER_ARGON);
     const accountset = await accountsetFromCli(program);
     const vaults = new VaultMonitor(
@@ -620,33 +530,27 @@ function liquidityCli() {
       },
       { shouldLog: false }
     );
-    const bidPool = new BidPool(
-      accountset.client,
-      accountset.txSubmitterPair
-    );
+    const bidPool = new BidPool(accountset.client, accountset.txSubmitterPair);
     const resolvedTip = tip ? BigInt(tip * MICROGONS_PER_ARGON) : 0n;
     console.log("Waiting for liquidity pool space...");
-    vaults.events.on(
-      "liquidity-pool-space-above",
-      async (vaultId, amount) => {
-        const vault = vaults.vaultsById[vaultId];
-        if (vault.terms.liquidityPoolProfitSharing.times(100).toNumber() < minPctSharing) {
-          console.info(
-            `Skipping vault ${vaultId} due to lower profit sharing than ${minPctSharing}%`
-          );
-          return;
-        }
-        let amountToAdd = amount;
-        if (amountToAdd > maxAmountPerSlot) {
-          amountToAdd = maxAmountPerSlot;
-        }
-        await bidPool.bondArgons(vaultId, amountToAdd, { tip: resolvedTip });
-        console.log("Bonding argons to vault liquidity pool", {
-          vaultId,
-          amount: formatArgons(amountToAdd)
-        });
+    vaults.events.on("liquidity-pool-space-above", async (vaultId, amount) => {
+      const vault = vaults.vaultsById[vaultId];
+      if (vault.terms.liquidityPoolProfitSharing.times(100).toNumber() < minPctSharing) {
+        console.info(
+          `Skipping vault ${vaultId} due to lower profit sharing than ${minPctSharing}%`
+        );
+        return;
       }
-    );
+      let amountToAdd = amount;
+      if (amountToAdd > maxAmountPerSlot) {
+        amountToAdd = maxAmountPerSlot;
+      }
+      await bidPool.bondArgons(vaultId, amountToAdd, { tip: resolvedTip });
+      console.log("Bonding argons to vault liquidity pool", {
+        vaultId,
+        amount: formatArgons(amountToAdd)
+      });
+    });
     await vaults.monitor();
   });
   return program;
@@ -679,19 +583,7 @@ function bitcoinCli() {
     "-a, --argons <amount>",
     "Bitcoin argons needed. NOTE: your account must have enough to cover fees + tip after this amount.",
     parseFloat
-  ).requiredOption(
-    "--bitcoin-xpub <xpub>",
-    "The xpub key to use for bitcoin locking"
-  ).option(
-    "--max-lock-fee <argons>",
-    "The max lock fee you're willing to pay",
-    parseFloat
-  ).option(
-    "--tip <amount>",
-    "The tip to include with the transaction",
-    parseFloat,
-    0
-  ).action(async ({ argons, bitcoinXpub, maxLockFee, tip }) => {
+  ).requiredOption("--bitcoin-xpub <xpub>", "The xpub key to use for bitcoin locking").option("--max-lock-fee <argons>", "The max lock fee you're willing to pay", parseFloat).option("--tip <amount>", "The tip to include with the transaction", parseFloat, 0).action(async ({ argons, bitcoinXpub, maxLockFee, tip }) => {
     const amountToLock = BigInt(argons * MICROGONS_PER_ARGON);
     const accountset = await accountsetFromCli(program);
     await BitcoinLocks.waitForSpace(accountset, {
@@ -699,11 +591,11 @@ function bitcoinCli() {
       bitcoinXpub,
       maxLockFee: maxLockFee !== void 0 ? BigInt(maxLockFee * MICROGONS_PER_ARGON) : void 0,
       tip: BigInt(tip * MICROGONS_PER_ARGON)
-    }).then(({ vaultId, satoshis, txFee, btcFee }) => {
+    }).then(({ vaultId, satoshis, txFee, securityFee }) => {
       console.log(
         `Locked ${satoshis} satoshis in vault ${vaultId}. Tx fee=${formatArgons(
           txFee
-        )}, Lock fee=${formatArgons(btcFee)}.`
+        )}, Lock fee=${formatArgons(securityFee)}.`
       );
       process.exit(0);
     });
@@ -755,20 +647,15 @@ function buildCli() {
       "The path to your json seed file from polkadotjs"
     ).env("ACCOUNT_JSON_PATH")
   ).addOption(
-    new Option(
-      "--account-suri <secretUri>",
-      "A secret uri (suri) to use for the account"
-    ).env("ACCOUNT_SURI")
-  ).addOption(
-    new Option(
-      "--account-passphrase <password>",
-      "The password for your seed file"
-    ).env("ACCOUNT_PASSPHRASE")
+    new Option("--account-suri <secretUri>", "A secret uri (suri) to use for the account").env(
+      "ACCOUNT_SURI"
+    )
   ).addOption(
-    new Option(
-      "--account-passphrase-file <path>",
-      "The path to a password for your seed file"
+    new Option("--account-passphrase <password>", "The password for your seed file").env(
+      "ACCOUNT_PASSPHRASE"
     )
+  ).addOption(
+    new Option("--account-passphrase-file <path>", "The path to a password for your seed file")
   ).addOption(
     new Option(
       "-s, --subaccounts <range>",
@@ -851,4 +738,4 @@ export {
   addGlobalArgs,
   applyEnv
 };
-//# sourceMappingURL=chunk-BQR6FEVP.js.map
+//# sourceMappingURL=chunk-FNSFV3MO.js.map