@argonprotocol/mainchain 1.3.2 → 1.3.4

package/lib/{chunk-CGXT6XF7.js → chunk-P3OMJABP.js}

@@ -56,7 +56,7 @@ var WageProtector = class _WageProtector {
         new _WageProtector({
           argonUsdTargetPrice: cpi.value.argonUsdTargetPrice.toBigInt(),
           argonUsdPrice: cpi.value.argonUsdPrice.toBigInt(),
-          finalizedBlock: Buffer.from(finalizedBlock),
+          finalizedBlock: new Uint8Array(finalizedBlock),
           tick: cpi.value.tick.toBigInt()
         })
       );
@@ -81,9 +81,29 @@ var WageProtector = class _WageProtector {
   }
 };
 
+// src/config.ts
+var config = {};
+function getEnvVar(key) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[key];
+  }
+  return void 0;
+}
+function setConfig(newConfig) {
+  config = { ...config, ...newConfig };
+}
+function getConfig() {
+  return {
+    debug: config.debug ?? getEnvVar("DEBUG") === "true",
+    keysVersion: config.keysVersion ?? (getEnvVar("KEYS_VERSION") ? parseInt(getEnvVar("KEYS_VERSION")) : void 0),
+    keysMnemonic: config.keysMnemonic ?? getEnvVar("KEYS_MNEMONIC"),
+    subaccountRange: config.subaccountRange ?? getEnvVar("SUBACCOUNT_RANGE") ?? "0-9"
+  };
+}
+
 // src/TxSubmitter.ts
 function logExtrinsicResult(result) {
-  if (process.env.DEBUG) {
+  if (getConfig().debug) {
     const json = result.status.toJSON();
     const status = Object.keys(json)[0];
     console.debug('Transaction update: "%s"', status, json[status]);
@@ -103,18 +123,21 @@ var TxSubmitter = class {
     const { tip, unavailableBalance } = options;
     const account = await this.client.query.system.account(this.pair.address);
     let availableBalance = account.data.free.toBigInt();
+    const userBalance = availableBalance;
     if (unavailableBalance) {
       availableBalance -= unavailableBalance;
     }
     const existentialDeposit = options.includeExistentialDeposit ? this.client.consts.balances.existentialDeposit.toBigInt() : 0n;
     const fees = await this.feeEstimate(tip);
     const totalCharge = fees + (tip ?? 0n);
-    const canAfford = availableBalance > totalCharge + existentialDeposit;
-    return { canAfford, availableBalance, txFee: fees };
+    const canAfford = availableBalance >= totalCharge + existentialDeposit;
+    return { canAfford, availableBalance: userBalance, txFee: fees };
   }
   async submit(options = {}) {
-    const { logResults } = options;
+    const { logResults, waitForBlock, useLatestNonce, ...apiOptions } = options;
+    await waitForLoad();
     const result = new TxResult(this.client, logResults);
+    result.txProgressCallback = options.txProgressCallback;
     let toHuman = this.tx.toHuman().method;
     let txString = [];
     let api = formatCall(toHuman);
@@ -132,12 +155,12 @@ var TxSubmitter = class {
       args.push(toHuman.args);
     }
     args.unshift(txString.join("->"));
-    if (options.useLatestNonce && !options.nonce) {
-      options.nonce = await this.client.rpc.system.accountNextIndex(this.pair.address);
+    if (useLatestNonce && !apiOptions.nonce) {
+      apiOptions.nonce = await this.client.rpc.system.accountNextIndex(this.pair.address);
     }
-    console.log("Submitting transaction:", ...args);
-    await this.tx.signAndSend(this.pair, options, result.onResult.bind(result));
-    if (options.waitForBlock) {
+    console.log("Submitting transaction from %s:", this.pair.address, ...args);
+    await this.tx.signAndSend(this.pair, apiOptions, result.onResult.bind(result));
+    if (waitForBlock) {
       await result.inBlockPromise;
     }
     return result;
@@ -180,6 +203,7 @@ var TxResult = class {
    * The fee tip paid for the transaction.
    */
   finalFeeTip;
+  txProgressCallback;
   inBlockResolve;
   inBlockReject;
   finalizedResolve;
@@ -191,7 +215,7 @@ var TxResult = class {
     }
     const { events, status, dispatchError, isFinalized } = result;
     if (status.isInBlock) {
-      this.includedInBlock = Buffer.from(status.asInBlock);
+      this.includedInBlock = new Uint8Array(status.asInBlock);
       let encounteredError = dispatchError;
       let batchErrorIndex;
       for (const event of events) {
@@ -211,12 +235,21 @@ var TxResult = class {
         const error = dispatchErrorToExtrinsicError(this.client, encounteredError, batchErrorIndex);
         this.reject(error);
       } else {
-        this.inBlockResolve(Buffer.from(status.asInBlock));
+        this.inBlockResolve(new Uint8Array(status.asInBlock));
       }
     }
     if (isFinalized) {
       this.finalizedResolve(status.asFinalized);
     }
+    if (this.txProgressCallback) {
+      let percent = 0;
+      if (result.status.isBroadcast) {
+        percent = 50;
+      } else if (result.status.isInBlock) {
+        percent = 100;
+      }
+      this.txProgressCallback(percent, this);
+    }
   }
   reject(error) {
     this.inBlockReject(error);
@@ -271,10 +304,11 @@ async function gettersToObject(obj) {
   }
   return result;
 }
-function toFixedNumber(value, base) {
-  const decimalFactor = new BigNumber(10).pow(base);
-  const rawValue = new BigNumber(value.toString());
-  return BigInt(rawValue.times(decimalFactor).toFixed(0, ROUND_FLOOR));
+function toFixedNumber(value, decimals) {
+  const factor = new BigNumber(10).pow(decimals);
+  const bn = new BigNumber(value);
+  const int = bn.times(factor).integerValue(BigNumber.ROUND_DOWN);
+  return BigInt(int.toFixed(0));
 }
 function convertNumberToFixedU128(value) {
   return toFixedNumber(value, 18);
@@ -356,8 +390,12 @@ var JsonExt = class {
         if (typeof v === "bigint") {
           return `${v}n`;
         }
-        if (Buffer.isBuffer(v)) {
-          return Buffer.from(v).toJSON();
+        if (v instanceof Uint8Array) {
+          return {
+            type: "Buffer",
+            data: Array.from(v)
+            // Convert Uint8Array to an array of numbers
+          };
         }
         return v;
       },
@@ -370,7 +408,7 @@ var JsonExt = class {
         return BigInt(v.slice(0, -1));
       }
       if (typeof v === "object" && v !== null && v.type === "Buffer" && Array.isArray(v.data)) {
-        return Buffer.from(v.data);
+        return Uint8Array.from(v.data);
       }
       return v;
     });
@@ -412,9 +450,6 @@ var AccountRegistry = class _AccountRegistry {
   static factory = (name) => new _AccountRegistry(name);
 };
 
-// src/Accountset.ts
-import * as process2 from "node:process";
-
 // src/BlockWatch.ts
 function getTickFromHeader(client, header) {
   for (const x of header.digest.logs) {
@@ -628,13 +663,13 @@ var FrameCalculator = class {
       slotBiddingStartAfterTicks: x.slotBiddingStartAfterTicks.toNumber()
     }));
     this.genesisTick ??= await client.query.ticks.genesisTick().then((x) => x.toNumber());
-    const config = this.miningConfig;
+    const config2 = this.miningConfig;
     const genesisTick = this.genesisTick;
     return {
-      ticksBetweenFrames: config.ticksBetweenSlots,
-      slotBiddingStartAfterTicks: config.slotBiddingStartAfterTicks,
+      ticksBetweenFrames: config2.ticksBetweenSlots,
+      slotBiddingStartAfterTicks: config2.slotBiddingStartAfterTicks,
       genesisTick,
-      biddingStartTick: genesisTick + config.slotBiddingStartAfterTicks
+      biddingStartTick: genesisTick + config2.slotBiddingStartAfterTicks
     };
   }
 };
@@ -645,10 +680,10 @@ var AccountMiners = class _AccountMiners {
     this.accountset = accountset;
     this.options = options;
     this.frameCalculator = new FrameCalculator();
-    for (const seat of registeredMiners) {
-      this.trackedAccountsByAddress[seat.address] = {
-        startingFrameId: seat.startingFrameId,
-        subaccountIndex: seat.subaccountIndex
+    for (const miner of registeredMiners) {
+      this.trackedAccountsByAddress[miner.address] = {
+        startingFrameId: miner.seat.startingFrameId,
+        subaccountIndex: miner.subaccountIndex
       };
     }
   }
@@ -760,6 +795,7 @@ var AccountMiners = class _AccountMiners {
 };
 
 // src/Accountset.ts
+import { u8aToHex } from "@polkadot/util";
 var Accountset = class {
   txSubmitterPair;
   isProxy = false;
@@ -882,7 +918,7 @@ var Accountset = class {
       const index = indexRaw.toNumber();
       const bidAmount = bidAmountsByFrame[frameId]?.[index];
       addressToMiningIndex[address] = {
-        frameId,
+        startingFrameId: frameId,
         index,
         bidAmount: bidAmount ?? 0n
       };
@@ -892,7 +928,7 @@ var Accountset = class {
       const cohort = addressToMiningIndex[address];
       let isLastDay = false;
       if (cohort !== void 0) {
-        isLastDay = nextFrameId.toNumber() - cohort.frameId === 10;
+        isLastDay = nextFrameId.toNumber() - cohort.startingFrameId === 10;
       }
       return {
         address,
@@ -1021,11 +1057,9 @@ var Accountset = class {
     await client.disconnect();
   }
   keys(keysVersion) {
-    let version = keysVersion ?? 0;
-    if (process2.env.KEYS_VERSION) {
-      version = parseInt(process2.env.KEYS_VERSION) ?? 0;
-    }
-    const seedMnemonic = this.sessionKeyMnemonic ?? process2.env.KEYS_MNEMONIC;
+    const config2 = getConfig();
+    let version = keysVersion ?? config2.keysVersion ?? 0;
+    const seedMnemonic = this.sessionKeyMnemonic ?? config2.keysMnemonic;
     if (!seedMnemonic) {
       throw new Error("KEYS_MNEMONIC environment variable not set. Cannot derive keys.");
     }
@@ -1040,12 +1074,12 @@ var Accountset = class {
     return {
       seal: {
         privateKey: blockSealKey,
-        publicKey: `0x${Buffer.from(blockSealAccount.publicKey).toString("hex")}`,
+        publicKey: u8aToHex(blockSealAccount.publicKey),
         rawPublicKey: blockSealAccount.publicKey
       },
       gran: {
         privateKey: granKey,
-        publicKey: `0x${Buffer.from(grandpaAccount.publicKey).toString("hex")}`,
+        publicKey: u8aToHex(grandpaAccount.publicKey),
         rawPublicKey: grandpaAccount.publicKey
       }
     };
@@ -1148,10 +1182,11 @@ var Accountset = class {
 };
 function getDefaultSubaccountRange() {
   try {
-    return parseSubaccountRange(process2.env.SUBACCOUNT_RANGE ?? "0-9");
+    const config2 = getConfig();
+    return parseSubaccountRange(config2.subaccountRange ?? "0-9");
   } catch {
     console.error(
-      "Failed to parse SUBACCOUNT_RANGE environment variable. Defaulting to 0-9. Please check the format of the SUBACCOUNT_RANGE variable."
+      "Failed to parse SUBACCOUNT_RANGE configuration. Defaulting to 0-9. Please check the format of the subaccountRange config value."
     );
     return Array.from({ length: 10 }, (_, i) => i);
   }
@@ -1190,7 +1225,7 @@ var MiningBids = class {
   nextCohort = [];
   async maxCohortSize() {
     const client = await this.client;
-    return client.consts.miningSlot.maxCohortSize.toNumber();
+    return client.query.miningSlot.nextCohortSize().then((x) => x.toNumber());
   }
   async onCohortChange(options) {
     const { onBiddingStart, onBiddingEnd } = options;
@@ -1265,12 +1300,35 @@ var MiningBids = class {
 // src/Vault.ts
 import BigNumber2, * as BN2 from "bignumber.js";
 import bs58check from "bs58check";
+import { hexToU8a } from "@polkadot/util";
 var { ROUND_FLOOR: ROUND_FLOOR2 } = BN2;
 var Vault = class _Vault {
   constructor(id, vault, tickDuration) {
     this.tickDuration = tickDuration;
+    this.vaultId = id;
+    this.openedTick = vault.openedTick.toNumber();
+    this.openedDate = new Date(this.openedTick * this.tickDuration);
+    this.argonsScheduledForRelease = /* @__PURE__ */ new Map();
+    this.load(vault);
+  }
+  securitization;
+  argonsLocked;
+  argonsPendingActivation;
+  argonsScheduledForRelease;
+  terms;
+  operatorAccountId;
+  isClosed;
+  vaultId;
+  pendingTerms;
+  pendingTermsChangeTick;
+  openedDate;
+  openedTick;
+  securitizationRatio;
+  load(vault) {
     this.securitization = vault.securitization.toBigInt();
-    this.securitizationRatio = convertFixedU128ToBigNumber(vault.securitizationRatio.toBigInt());
+    this.securitizationRatio = convertFixedU128ToBigNumber(
+      vault.securitizationRatio.toBigInt()
+    ).toNumber();
     this.argonsLocked = vault.argonsLocked.toBigInt();
     this.argonsPendingActivation = vault.argonsPendingActivation.toBigInt();
     if (vault.argonsScheduledForRelease.size > 0) {
@@ -1290,7 +1348,6 @@ var Vault = class _Vault {
     };
     this.operatorAccountId = vault.operatorAccountId.toString();
     this.isClosed = vault.isClosed.valueOf();
-    this.vaultId = id;
     if (vault.pendingTerms.isSome) {
       const [tickApply, terms] = vault.pendingTerms.value;
       this.pendingTermsChangeTick = tickApply.toNumber();
@@ -1304,22 +1361,7 @@ var Vault = class _Vault {
         )
       };
     }
-    this.openedTick = vault.openedTick.toNumber();
-    this.openedDate = new Date(this.openedTick * tickDuration);
   }
-  securitization;
-  securitizationRatio;
-  argonsLocked;
-  argonsPendingActivation;
-  argonsScheduledForRelease = /* @__PURE__ */ new Map();
-  terms;
-  operatorAccountId;
-  isClosed;
-  vaultId;
-  pendingTerms;
-  pendingTermsChangeTick;
-  openedDate;
-  openedTick;
   availableBitcoinSpace() {
     const recoverySecuritization = this.recoverySecuritization();
     const reLockable = this.getRelockCapacity();
@@ -1328,21 +1370,21 @@ var Vault = class _Vault {
   getRelockCapacity() {
     return [...this.argonsScheduledForRelease.values()].reduce((acc, val) => acc + val, 0n);
   }
+  securitizationRatioBN() {
+    return new BigNumber2(this.securitizationRatio);
+  }
   recoverySecuritization() {
-    const reserved = new BigNumber2(1).div(this.securitizationRatio);
+    const reserved = new BigNumber2(1).div(this.securitizationRatioBN());
     return this.securitization - BigInt(reserved.multipliedBy(this.securitization.toString()).toFixed(0, ROUND_FLOOR2));
   }
   minimumSecuritization() {
     return BigInt(
-      this.securitizationRatio.multipliedBy(this.argonsLocked.toString()).decimalPlaces(0, BigNumber2.ROUND_CEIL).toString()
+      this.securitizationRatioBN().multipliedBy(this.argonsLocked.toString()).decimalPlaces(0, BigNumber2.ROUND_CEIL).toString()
     );
   }
   activatedSecuritization() {
     const activated = this.argonsLocked - this.argonsPendingActivation;
-    let maxRatio = this.securitizationRatio;
-    if (this.securitizationRatio.toNumber() > 2) {
-      maxRatio = BigNumber2(2);
-    }
+    const maxRatio = BigNumber2(Math.min(this.securitizationRatio, 2));
     return BigInt(maxRatio.multipliedBy(activated.toString()).toFixed(0, ROUND_FLOOR2));
   }
   /**
@@ -1356,48 +1398,69 @@ var Vault = class _Vault {
     const fee = this.terms.bitcoinAnnualPercentRate.multipliedBy(Number(amount)).integerValue(BigNumber2.ROUND_CEIL);
     return BigInt(fee.toString()) + this.terms.bitcoinBaseFee;
   }
-  static async get(client, vaultId) {
+  static async get(client, vaultId, tickDurationMillis) {
     const rawVault = await client.query.vaults.vaultsById(vaultId);
     if (rawVault.isNone) {
       throw new Error(`Vault with id ${vaultId} not found`);
     }
-    const tickDuration = await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
+    const tickDuration = tickDurationMillis ?? await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
     return new _Vault(vaultId, rawVault.unwrap(), tickDuration);
   }
-  static async create(client, keypair, args, config = {}) {
-    const { securitization, securitizationRatio, annualPercentRate, baseFee, bitcoinXpub, tip } = args;
-    let xpubBytes = Buffer.from(bitcoinXpub, "hex");
+  static async create(client, keypair, args, config2 = {}) {
+    const {
+      securitization,
+      securitizationRatio,
+      annualPercentRate,
+      baseFee,
+      bitcoinXpub,
+      tip,
+      doNotExceedBalance,
+      txProgressCallback
+    } = args;
+    let xpubBytes = hexToU8a(bitcoinXpub);
     if (xpubBytes.length !== 78) {
       if (bitcoinXpub.startsWith("xpub") || bitcoinXpub.startsWith("tpub") || bitcoinXpub.startsWith("zpub")) {
         const bytes = bs58check.decode(bitcoinXpub);
         if (bytes.length !== 78) {
           throw new Error("Invalid Bitcoin xpub key length, must be 78 bytes");
         }
-        xpubBytes = Buffer.from(bytes);
+        xpubBytes = bytes;
+      }
+    }
+    let vaultParams = {
+      terms: {
+        // convert to fixed u128
+        bitcoinAnnualPercentRate: toFixedNumber(annualPercentRate, 18),
+        bitcoinBaseFee: BigInt(baseFee),
+        liquidityPoolProfitSharing: toFixedNumber(args.liquidityPoolProfitSharing, 6)
+      },
+      securitizationRatio: toFixedNumber(securitizationRatio, 18),
+      securitization: BigInt(securitization),
+      bitcoinXpubkey: xpubBytes
+    };
+    let tx = new TxSubmitter(client, client.tx.vaults.create(vaultParams), keypair);
+    if (doNotExceedBalance) {
+      const finalTip = tip ?? 0n;
+      let txFee = await tx.feeEstimate(finalTip);
+      while (txFee + finalTip + vaultParams.securitization > doNotExceedBalance) {
+        vaultParams.securitization = doNotExceedBalance - txFee - finalTip;
+        tx.tx = client.tx.vaults.create(vaultParams);
+        txFee = await tx.feeEstimate(finalTip);
       }
     }
-    const tx = new TxSubmitter(
-      client,
-      client.tx.vaults.create({
-        terms: {
-          // convert to fixed u128
-          bitcoinAnnualPercentRate: toFixedNumber(annualPercentRate, 18),
-          bitcoinBaseFee: BigInt(baseFee),
-          liquidityPoolProfitSharing: toFixedNumber(args.liquidityPoolProfitSharing, 6)
-        },
-        securitizationRatio: toFixedNumber(securitizationRatio, 18),
-        securitization: BigInt(securitization),
-        bitcoinXpubkey: xpubBytes
-      }),
-      keypair
-    );
     const canAfford = await tx.canAfford({ tip, unavailableBalance: BigInt(securitization) });
     if (!canAfford.canAfford) {
       throw new Error(
         `Insufficient balance to create vault. Required: ${formatArgons(securitization)}, Available: ${formatArgons(canAfford.availableBalance)}`
       );
     }
-    const result = await tx.submit({ waitForBlock: true, tip });
+    const result = await tx.submit({
+      tip,
+      useLatestNonce: true,
+      waitForBlock: true,
+      txProgressCallback
+    });
+    await result.inBlockPromise;
     let vaultId;
     for (const event of result.events) {
       if (client.events.vaults.VaultCreated.is(event)) {
@@ -1412,8 +1475,9 @@ var Vault = class _Vault {
     if (rawVault.isNone) {
       throw new Error("Vault creation failed, vault not found");
     }
-    const tickDuration = config.tickDurationMillis ?? await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
-    return new _Vault(vaultId, rawVault.unwrap(), tickDuration);
+    const tickDuration = config2.tickDurationMillis ?? await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
+    const vault = new _Vault(vaultId, rawVault.unwrap(), tickDuration);
+    return { vault, txResult: result };
   }
 };
 
@@ -1465,7 +1529,7 @@ var VaultMonitor = class {
     const client = await this.mainchain;
     this.tickDuration = (await client.query.ticks.genesisTicker()).tickDurationMillis.toNumber();
     const blockHeader = await client.rpc.chain.getHeader();
-    const blockHash = Buffer.from(blockHeader.hash);
+    const blockHash = new Uint8Array(blockHeader.hash);
     console.log(
       `${justPrint ? "Run" : "Started"} at block ${blockHeader.number} - ${blockHeader.hash.toHuman()}`
     );
@@ -1501,7 +1565,7 @@ var VaultMonitor = class {
         id: vaultId,
         btcSpace: `${formatArgons(vault.availableBitcoinSpace())} (${formatArgons(vault.argonsPendingActivation)} pending)`,
         btcDeal: `${formatArgons(vault.terms.bitcoinBaseFee)} + ${formatPercent(vault.terms.bitcoinAnnualPercentRate)}`,
-        securitization: `${formatArgons(vault.securitization)} at ${vault.securitizationRatio.toFormat(1)}x`,
+        securitization: `${formatArgons(vault.securitization)} at ${vault.securitizationRatio}x`,
         securActivated: `${formatArgons(vault.activatedSecuritizationPerSlot())}/slot`,
         liquidPoolDeal: `${formatPercent(vault.terms.liquidityPoolProfitSharing)} sharing`,
         operator: `${this.accountset.namedAccounts.has(vault.operatorAccountId) ? ` (${this.accountset.namedAccounts.get(vault.operatorAccountId)})` : vault.operatorAccountId}`,
@@ -1590,143 +1654,6 @@ var VaultMonitor = class {
   }
 };
 
-// src/CohortBidderHistory.ts
-var CohortBidderHistory = class _CohortBidderHistory {
-  constructor(cohortStartingFrameId, subaccounts) {
-    this.cohortStartingFrameId = cohortStartingFrameId;
-    this.subaccounts = subaccounts;
-    this.maxSeatsInPlay = this.subaccounts.length;
-    this.subaccounts.forEach((x) => {
-      this.myAddresses.add(x.address);
-    });
-  }
-  bidHistory = [];
-  stats = {
-    // number of seats won
-    seatsWon: 0,
-    // sum of argons bid in successful bids
-    totalArgonsBid: 0n,
-    // total number of bids placed (includes 1 per seat)
-    bidsAttempted: 0,
-    // fees including the tip
-    fees: 0n,
-    // Max bid per seat
-    maxBidPerSeat: 0n,
-    // The cost in argonots of each seat
-    argonotsPerSeat: 0n,
-    // The argonot price in USD for cost basis
-    argonotUsdPrice: 0,
-    // The cohort expected argons per block
-    cohortArgonsPerBlock: 0n,
-    // The last block that bids are synced to
-    lastBlockNumber: 0
-  };
-  lastBids = [];
-  myAddresses = /* @__PURE__ */ new Set();
-  maxSeatsInPlay = 0;
-  async init(client) {
-    if (!this.stats.argonotsPerSeat) {
-      const startingStats = await _CohortBidderHistory.getStartingData(client);
-      Object.assign(this.stats, startingStats);
-    }
-  }
-  maybeReducingSeats(maxSeats, reason, historyEntry) {
-    if (this.maxSeatsInPlay > maxSeats) {
-      historyEntry.maxSeatsReductionReason = reason;
-    }
-    this.maxSeatsInPlay = maxSeats;
-    historyEntry.maxSeatsInPlay = maxSeats;
-  }
-  trackChange(next, blockNumber, tick, isLastEntry = false) {
-    let winningBids = 0;
-    let totalArgonsBid = 0n;
-    const nextEntrants = [];
-    for (const x of next) {
-      const bid = x.bid.toBigInt();
-      const address = x.accountId.toHuman();
-      nextEntrants.push({ address, bid });
-      if (this.myAddresses.has(address)) {
-        winningBids++;
-        totalArgonsBid += bid;
-      }
-    }
-    this.stats.seatsWon = winningBids;
-    this.stats.totalArgonsBid = totalArgonsBid;
-    this.stats.lastBlockNumber = Math.max(blockNumber, this.stats.lastBlockNumber);
-    const historyEntry = {
-      cohortStartingFrameId: this.cohortStartingFrameId,
-      blockNumber,
-      tick,
-      bidChanges: [],
-      winningSeats: winningBids,
-      maxSeatsInPlay: this.maxSeatsInPlay
-    };
-    const hasDiffs = JsonExt.stringify(nextEntrants) !== JsonExt.stringify(this.lastBids);
-    if (!isLastEntry || hasDiffs) {
-      this.bidHistory.unshift(historyEntry);
-    }
-    if (hasDiffs) {
-      nextEntrants.forEach(({ address, bid }, i) => {
-        const prevBidIndex = this.lastBids.findIndex((y) => y.address === address);
-        const entry = {
-          address,
-          bidAmount: bid,
-          bidPosition: i,
-          prevPosition: prevBidIndex === -1 ? null : prevBidIndex
-        };
-        if (prevBidIndex !== -1) {
-          const prevBidAmount = this.lastBids[prevBidIndex].bid;
-          if (prevBidAmount !== bid) {
-            entry.prevBidAmount = prevBidAmount;
-          }
-        }
-        historyEntry.bidChanges.push(entry);
-      });
-      this.lastBids.forEach(({ address, bid }, i) => {
-        const nextBid = nextEntrants.some((y) => y.address === address);
-        if (!nextBid) {
-          historyEntry.bidChanges.push({
-            address,
-            bidAmount: bid,
-            bidPosition: null,
-            prevPosition: i
-          });
-        }
-      });
-      this.lastBids = nextEntrants;
-    }
-    return historyEntry;
-  }
-  onBidResult(historyEntry, param) {
-    const { txFeePlusTip, bidPerSeat, bidsAttempted, successfulBids, blockNumber, bidError } = param;
-    this.stats.fees += txFeePlusTip;
-    this.stats.bidsAttempted += bidsAttempted;
-    if (bidPerSeat > this.stats.maxBidPerSeat) {
-      this.stats.maxBidPerSeat = bidPerSeat;
-    }
-    if (blockNumber !== void 0) {
-      this.stats.lastBlockNumber = Math.max(blockNumber, this.stats.lastBlockNumber);
-    }
-    if (historyEntry.myBidsPlaced) {
-      historyEntry.myBidsPlaced.failureReason = bidError;
-      historyEntry.myBidsPlaced.successfulBids = successfulBids;
-      historyEntry.myBidsPlaced.txFeePlusTip = txFeePlusTip;
-    }
-  }
-  static async getStartingData(api) {
-    const argonotPrice = await api.query.priceIndex.current();
-    let argonotUsdPrice = 0;
-    if (argonotPrice.isSome) {
-      argonotUsdPrice = convertFixedU128ToBigNumber(
-        argonotPrice.unwrap().argonotUsdPrice.toBigInt()
-      ).toNumber();
-    }
-    const argonotsPerSeat = await api.query.miningSlot.argonotsPerMiningSeat().then((x) => x.toBigInt());
-    const cohortArgonsPerBlock = await api.query.blockRewards.argonsPerBlock().then((x) => x.toBigInt());
-    return { argonotsPerSeat, argonotUsdPrice, cohortArgonsPerBlock };
-  }
-};
-
 // src/CohortBidder.ts
 var CohortBidder = class {
   constructor(accountset, cohortStartingFrameId, subaccounts, options) {
@@ -1734,7 +1661,6 @@ var CohortBidder = class {
     this.cohortStartingFrameId = cohortStartingFrameId;
     this.subaccounts = subaccounts;
     this.options = options;
-    this.history = new CohortBidderHistory(cohortStartingFrameId, subaccounts);
     this.subaccounts.forEach((x) => {
       this.myAddresses.add(x.address);
     });
@@ -1742,23 +1668,52 @@ var CohortBidder = class {
   get client() {
     return this.accountset.client;
   }
-  get stats() {
-    return this.history.stats;
-  }
-  get bidHistory() {
-    return this.history.bidHistory;
-  }
+  txFees = 0n;
+  winningBids = [];
   unsubscribe;
   pendingRequest;
   retryTimeout;
   isStopped = false;
   needsRebid = false;
   lastBidTime = 0;
-  history;
   millisPerTick;
+  minIncrement = 10000n;
+  nextCohortSize;
+  lastBidBlockNumber = 0;
   myAddresses = /* @__PURE__ */ new Set();
+  async start() {
+    console.log(`Starting cohort ${this.cohortStartingFrameId} bidder`, {
+      maxBid: formatArgons(this.options.maxBid),
+      minBid: formatArgons(this.options.minBid),
+      bidIncrement: formatArgons(this.options.bidIncrement),
+      maxBudget: formatArgons(this.options.maxBudget),
+      bidDelay: this.options.bidDelay,
+      subaccounts: this.subaccounts
+    });
+    const client = await this.client;
+    this.minIncrement = client.consts.miningSlot.bidIncrements.toBigInt();
+    this.nextCohortSize = await client.query.miningSlot.nextCohortSize().then((x) => x.toNumber());
+    if (this.subaccounts.length > this.nextCohortSize) {
+      console.info(
+        `Cohort size ${this.nextCohortSize} is less than provided subaccounts ${this.subaccounts.length}.`
+      );
+      this.subaccounts.length = this.nextCohortSize;
+    }
+    this.millisPerTick = await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
+    this.unsubscribe = await client.queryMulti(
+      [
+        client.query.miningSlot.bidsForNextSlotCohort,
+        client.query.miningSlot.nextFrameId
+      ],
+      async ([bids, nextFrameId]) => {
+        if (nextFrameId.toNumber() === this.cohortStartingFrameId) {
+          await this.checkWinningBids(bids);
+        }
+      }
+    );
+  }
   async stop() {
-    if (this.isStopped) return this.stats;
+    if (this.isStopped) return this.winningBids;
     this.isStopped = true;
     console.log("Stopping bidder for cohort", this.cohortStartingFrameId);
     clearTimeout(this.retryTimeout);
@@ -1783,79 +1738,47 @@ var CohortBidder = class {
     }
     void await this.pendingRequest;
     let header = await client.rpc.chain.getHeader();
+    let api = await client.at(header.hash);
     while (true) {
-      const api2 = await client.at(header.hash);
-      const cohortStartingFrameId = await api2.query.miningSlot.nextFrameId();
+      const cohortStartingFrameId = await api.query.miningSlot.nextFrameId();
       if (cohortStartingFrameId.toNumber() === this.cohortStartingFrameId) {
         break;
       }
       header = await client.rpc.chain.getHeader(header.parentHash);
+      api = await client.at(header.hash);
     }
-    const api = await client.at(header.hash);
-    const tick = await api.query.ticks.currentTick().then((x) => x.toNumber());
     const bids = await api.query.miningSlot.bidsForNextSlotCohort();
-    this.history.trackChange(bids, header.number.toNumber(), tick, true);
+    this.updateSeatsWon(bids);
     console.log("Bidder stopped", {
       cohortStartingFrameId: this.cohortStartingFrameId,
       blockNumber: header.number.toNumber(),
-      tick,
-      bids: bids.map((x) => ({
-        address: x.accountId.toHuman(),
-        bid: x.bid.toBigInt()
-      }))
+      bids: this.winningBids
     });
-    return this.stats;
-  }
-  async start() {
-    console.log(`Starting cohort ${this.cohortStartingFrameId} bidder`, {
-      maxBid: formatArgons(this.options.maxBid),
-      minBid: formatArgons(this.options.minBid),
-      bidIncrement: formatArgons(this.options.bidIncrement),
-      maxBudget: formatArgons(this.options.maxBudget),
-      bidDelay: this.options.bidDelay,
-      subaccounts: this.subaccounts
-    });
-    const client = await this.client;
-    await this.history.init(client);
-    this.millisPerTick ??= await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
-    this.unsubscribe = await client.queryMulti(
-      [
-        client.query.miningSlot.bidsForNextSlotCohort,
-        client.query.miningSlot.nextFrameId
-      ],
-      async ([bids, nextFrameId]) => {
-        if (nextFrameId.toNumber() === this.cohortStartingFrameId) {
-          await this.checkWinningBids(bids);
-        }
-      }
-    );
+    return this.winningBids;
   }
   async checkWinningBids(bids) {
     if (this.isStopped) return;
     clearTimeout(this.retryTimeout);
+    this.updateSeatsWon(bids);
+    const winningBids = this.winningBids.length;
+    this.needsRebid = winningBids < this.subaccounts.length;
     const client = await this.client;
     const bestBlock = await client.rpc.chain.getBlockHash();
     const api = await client.at(bestBlock);
     const blockNumber = await api.query.system.number().then((x) => x.toNumber());
-    if (this.bidHistory[0]?.blockNumber >= blockNumber) {
-      return;
-    }
-    const tick = await api.query.ticks.currentTick().then((x) => x.toNumber());
-    const historyEntry = this.history.trackChange(bids, blockNumber, tick);
+    if (this.lastBidBlockNumber >= blockNumber) return;
     if (this.pendingRequest) return;
     const ticksSinceLastBid = Math.floor((Date.now() - this.lastBidTime) / this.millisPerTick);
-    if (ticksSinceLastBid < this.options.bidDelay) {
+    if (ticksSinceLastBid < this.options.bidDelay && this.needsRebid) {
       this.retryTimeout = setTimeout(() => void this.checkCurrentSeats(), this.millisPerTick);
       return;
     }
+    if (!this.needsRebid) return;
     console.log(
       "Checking bids for cohort",
       this.cohortStartingFrameId,
       this.subaccounts.map((x) => x.index)
     );
-    const winningBids = historyEntry.winningSeats;
-    this.needsRebid = winningBids < this.subaccounts.length;
-    if (!this.needsRebid) return;
     const winningAddresses = new Set(bids.map((x) => x.accountId.toHuman()));
     let lowestBid = -this.options.bidIncrement;
     if (bids.length) {
@@ -1866,7 +1789,6 @@ var CohortBidder = class {
         }
       }
     }
-    const MIN_INCREMENT = 10000n;
     let nextBid = lowestBid + this.options.bidIncrement;
     if (nextBid < this.options.minBid) {
       nextBid = this.options.minBid;
@@ -1895,10 +1817,9 @@ var CohortBidder = class {
       console.log(
         `Can't bid ${formatArgons(nextBid)}. Current lowest bid is ${formatArgons(lowestBid)}.`
       );
-      this.history.maybeReducingSeats(winningBids, "MaxBidTooLow" /* MaxBidTooLow */, historyEntry);
       return;
     }
-    if (nextBid - lowestBid < MIN_INCREMENT) {
+    if (nextBid - lowestBid < Number(this.minIncrement)) {
       console.log(
         `Can't make any more bids for ${this.cohortStartingFrameId} with given constraints.`,
         {
@@ -1907,14 +1828,11 @@ var CohortBidder = class {
           maxBid: formatArgons(this.options.maxBid)
         }
       );
-      this.history.maybeReducingSeats(winningBids, "MaxBidTooLow" /* MaxBidTooLow */, historyEntry);
       return;
     }
     const seatsInBudget = nextBid === 0n ? this.subaccounts.length : Number(budgetForSeats / nextBid);
     let accountsToUse = [...this.subaccounts];
     if (accountsToUse.length > seatsInBudget) {
-      const reason = availableBalanceForBids - feePlusTip < nextBid * BigInt(seatsInBudget) ? "InsufficientFunds" /* InsufficientFunds */ : "MaxBudgetTooLow" /* MaxBudgetTooLow */;
-      this.history.maybeReducingSeats(seatsInBudget, reason, historyEntry);
       accountsToUse.sort((a, b) => {
         const isWinningA = winningAddresses.has(a.address);
         const isWinningB = winningAddresses.has(b.address);
@@ -1927,19 +1845,11 @@ var CohortBidder = class {
       accountsToUse.length = seatsInBudget;
     }
     if (accountsToUse.length > winningBids) {
-      historyEntry.myBidsPlaced = {
-        bids: accountsToUse.length,
-        bidPerSeat: nextBid,
-        txFeePlusTip: feePlusTip,
-        successfulBids: 0
-      };
-      this.pendingRequest = this.bid(nextBid, accountsToUse, historyEntry);
-    } else if (historyEntry.bidChanges.length === 0) {
-      this.history.bidHistory.shift();
+      this.pendingRequest = this.bid(nextBid, accountsToUse);
     }
     this.needsRebid = false;
   }
-  async bid(bidPerSeat, subaccounts, historyEntry) {
+  async bid(bidPerSeat, subaccounts) {
     const prevLastBidTime = this.lastBidTime;
     try {
       this.lastBidTime = Date.now();
@@ -1960,14 +1870,10 @@ var CohortBidder = class {
         blockNumber = await api.query.system.number().then((x) => x.toNumber());
       }
       const successfulBids = txResult.batchInterruptedIndex ?? subaccounts.length;
-      this.history.onBidResult(historyEntry, {
-        blockNumber,
-        successfulBids,
-        bidPerSeat,
-        txFeePlusTip: txResult.finalFee ?? 0n,
-        bidsAttempted: subaccounts.length,
-        bidError
-      });
+      this.txFees += txResult.finalFee ?? 0n;
+      if (blockNumber !== void 0) {
+        this.lastBidBlockNumber = Math.max(blockNumber, this.lastBidBlockNumber);
+      }
       console.log("Done creating bids for cohort", {
         successfulBids,
         bidPerSeat,
@@ -1987,6 +1893,16 @@ var CohortBidder = class {
       await this.checkCurrentSeats();
     }
   }
+  updateSeatsWon(next) {
+    this.winningBids.length = 0;
+    for (const x of next) {
+      const bid = x.bid.toBigInt();
+      const address = x.accountId.toHuman();
+      if (this.myAddresses.has(address)) {
+        this.winningBids.push({ address, bid });
+      }
+    }
+  }
   async checkCurrentSeats() {
     const client = await this.client;
     const bids = await client.query.miningSlot.bidsForNextSlotCohort();
@@ -2059,7 +1975,7 @@ var BidPool = class {
   }
   async loadAt(blockHash) {
     const client = await this.client;
-    blockHash ??= Buffer.from((await client.rpc.chain.getHeader()).hash);
+    blockHash ??= new Uint8Array((await client.rpc.chain.getHeader()).hash);
     const api = await client.at(blockHash);
     const rawVaultIds = await api.query.vaults.vaultsById.keys();
     const vaultIds = rawVaultIds.map((x) => x.args[0].toNumber());
@@ -2328,6 +2244,7 @@ Raising Funds (Frame ${this.nextFrameId + 1}):`);
 };
 
 // src/BitcoinLocks.ts
+import { hexToU8a as hexToU8a2, u8aToHex as u8aToHex2 } from "@polkadot/util";
 var SATS_PER_BTC = 100000000n;
 var BitcoinLocks = class _BitcoinLocks {
   constructor(client) {
@@ -2367,6 +2284,7 @@ var BitcoinLocks = class _BitcoinLocks {
     const bitcoinNetwork = await client.query.bitcoinUtxos.bitcoinNetwork();
     return {
       releaseExpirationBlocks: client.consts.bitcoinLocks.lockReleaseCosignDeadlineBlocks.toNumber(),
+      pendingConfirmationExpirationBlocks: client.consts.bitcoinUtxos.maxPendingConfirmationBlocks.toNumber(),
       tickDurationMillis: await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber()),
       bitcoinNetwork
     };
@@ -2387,7 +2305,7 @@ var BitcoinLocks = class _BitcoinLocks {
   async getUtxoRef(utxoId, atHeight) {
     let client = await this.client;
     if (atHeight !== void 0) {
-      const blockHash = await client.query.system.blockHash(atHeight);
+      const blockHash = await client.rpc.chain.getBlockHash(atHeight);
       client = await client.at(blockHash);
     }
     const refRaw = await client.query.bitcoinUtxos.utxoIdToRef(utxoId);
@@ -2395,15 +2313,15 @@ var BitcoinLocks = class _BitcoinLocks {
       return;
     }
     const ref = refRaw.unwrap();
-    const txid = Buffer.from(ref.txid).toString("hex");
-    const btcTxid = Buffer.from(ref.txid.reverse()).toString("hex");
+    const txid = u8aToHex2(ref.txid);
+    const bitcoinTxid = u8aToHex2(ref.txid.reverse());
     const vout = ref.outputIndex.toNumber();
-    return { txid: `0x${txid}`, vout, bitcoinTxid: `0x${btcTxid}` };
+    return { txid, vout, bitcoinTxid };
   }
   async getReleaseRequest(utxoId, atHeight) {
     let client = await this.client;
     if (atHeight !== void 0) {
-      const blockHash = await client.query.system.blockHash(atHeight);
+      const blockHash = await client.rpc.chain.getBlockHash(atHeight);
       client = await client.at(blockHash);
     }
     const locksPendingRelease = await client.query.bitcoinLocks.locksPendingReleaseByUtxoId();
@@ -2421,17 +2339,17 @@ var BitcoinLocks = class _BitcoinLocks {
     return void 0;
   }
   async submitVaultSignature(args) {
-    const { utxoId, vaultSignature, argonKeyring } = args;
+    const { utxoId, vaultSignature, argonKeyring, txProgressCallback } = args;
     const client = await this.client;
-    if (!vaultSignature || vaultSignature.byteLength < 71 || vaultSignature.byteLength > 73) {
+    if (!vaultSignature || vaultSignature.byteLength < 70 || vaultSignature.byteLength > 73) {
       throw new Error(
-        `Invalid vault signature length: ${vaultSignature.byteLength}. Must be 71-73 bytes.`
+        `Invalid vault signature length: ${vaultSignature.byteLength}. Must be 70-73 bytes.`
       );
     }
-    const signature = `0x${vaultSignature.toString("hex")}`;
+    const signature = u8aToHex2(vaultSignature);
     const tx = client.tx.bitcoinLocks.cosignRelease(utxoId, signature);
     const submitter = new TxSubmitter(client, tx, argonKeyring);
-    return await submitter.submit({ waitForBlock: true });
+    return await submitter.submit({ txProgressCallback });
   }
   async getBitcoinLock(utxoId) {
     const client = await this.client;
@@ -2452,7 +2370,7 @@ var BitcoinLocks = class _BitcoinLocks {
     const ownerPubkey = utxo.ownerPubkey.toHex();
     const [fingerprint, cosign_hd_index, claim_hd_index] = utxo.vaultXpubSources;
     const vaultXpubSources = {
-      parentFingerprint: Buffer.from(fingerprint),
+      parentFingerprint: new Uint8Array(fingerprint),
       cosignHdIndex: cosign_hd_index.toNumber(),
       claimHdIndex: claim_hd_index.toNumber()
     };
@@ -2534,7 +2452,7 @@ var BitcoinLocks = class _BitcoinLocks {
         await new Promise((resolve) => setTimeout(resolve, 1e3));
         continue;
       }
-      const hash = await client.query.system.blockHash(atHeight).then((x) => x.toHex());
+      const hash = await client.rpc.chain.getBlockHash(atHeight).then((x) => x.toHex());
       if (hash === "0x0000000000000000000000000000000000000000000000000000000000000000") {
         console.warn(`Block hash not found for height ${atHeight}. Retrying...`);
         await new Promise((resolve) => setTimeout(resolve, 1e3));
@@ -2556,7 +2474,7 @@ var BitcoinLocks = class _BitcoinLocks {
       if (client.events.bitcoinLocks.BitcoinUtxoCosigned.is(event.event)) {
         const { utxoId: id, signature } = event.event.data;
         if (id.toNumber() === utxoId) {
-          return Buffer.from(signature);
+          return new Uint8Array(signature);
         }
       }
     }
@@ -2602,11 +2520,16 @@ var BitcoinLocks = class _BitcoinLocks {
     return { tx, securityFee, txFee };
   }
   async initializeLock(args) {
-    const { argonKeyring, tip = 0n } = args;
+    const { argonKeyring, tip = 0n, txProgressCallback } = args;
     const client = await this.client;
     const { tx, securityFee } = await this.createInitializeLockTx(args);
     const submitter = new TxSubmitter(client, tx, argonKeyring);
-    const txResult = await submitter.submit({ waitForBlock: true, logResults: true, tip });
+    const txResult = await submitter.submit({
+      waitForBlock: true,
+      logResults: true,
+      tip,
+      txProgressCallback
+    });
     const blockHash = await txResult.inBlockPromise;
     const blockHeight = await client.at(blockHash).then((x) => x.query.system.number()).then((x) => x.toNumber());
     const utxoId = await this.getUtxoIdFromEvents(txResult.events) ?? 0;
@@ -2629,7 +2552,8 @@ var BitcoinLocks = class _BitcoinLocks {
       lock,
       releaseRequest: { bitcoinNetworkFee, toScriptPubkey },
       argonKeyring,
-      tip
+      tip,
+      txProgressCallback
     } = args;
     if (!toScriptPubkey.startsWith("0x")) {
       throw new Error("toScriptPubkey must be a hex string starting with 0x");
@@ -2652,7 +2576,12 @@ var BitcoinLocks = class _BitcoinLocks {
         `Insufficient funds to release lock. Available: ${formatArgons(canAfford.availableBalance)}, Required: ${formatArgons(redemptionPrice)}`
       );
     }
-    const txResult = await submitter.submit({ waitForBlock: true, logResults: true, tip });
+    const txResult = await submitter.submit({
+      waitForBlock: true,
+      logResults: true,
+      tip,
+      txProgressCallback
+    });
     const blockHash = await txResult.inBlockPromise;
     const blockHeight = await client.at(blockHash).then((x) => x.query.system.number()).then((x) => x.toNumber());
     return {
@@ -2691,7 +2620,7 @@ var BitcoinLocks = class _BitcoinLocks {
     };
   }
   async ratchet(args) {
-    const { lock, argonKeyring, tip = 0n, vault } = args;
+    const { lock, argonKeyring, tip = 0n, vault, txProgressCallback } = args;
     const client = await this.client;
     const ratchetPrice = await this.getRatchetPrice(lock, vault);
     const txSubmitter = new TxSubmitter(
@@ -2712,7 +2641,8 @@ var BitcoinLocks = class _BitcoinLocks {
     }
     const submission = await txSubmitter.submit({
       waitForBlock: true,
-      tip
+      tip,
+      txProgressCallback
     });
     const ratchetEvent = submission.events.find(
       (x) => client.events.bitcoinLocks.BitcoinLockRatcheted.is(x)
@@ -2744,7 +2674,7 @@ var BitcoinLocks = class _BitcoinLocks {
     const vaults = new VaultMonitor(accountset, {
       bitcoinSpaceAvailable: argonAmount
     });
-    const bitcoinXpubBuffer = Buffer.from(bitcoinXpub.replace(/^0x(.+)/, "$1"), "hex");
+    const bitcoinXpubBuffer = hexToU8a2(bitcoinXpub);
     return new Promise(async (resolve, reject) => {
       vaults.events.on("bitcoin-space-above", async (vaultId, amount) => {
         const vault = vaults.vaultsById[vaultId];
@@ -2801,9 +2731,32 @@ function createKeyringPair(opts) {
 }
 
 // src/index.ts
-export * from "@polkadot/types";
-export * from "@polkadot/types/interfaces";
-export * from "@polkadot/types-codec/types";
+import { u8aToHex as u8aToHex3, hexToU8a as hexToU8a3, u8aEq } from "@polkadot/util";
+import { GenericEvent as GenericEvent2, GenericBlock, GenericAddress } from "@polkadot/types/generic";
+import {
+  BTreeMap,
+  Bytes,
+  Compact,
+  Enum,
+  Null,
+  Option as Option2,
+  Result,
+  Bool,
+  Tuple,
+  Range,
+  Struct,
+  Text,
+  U256,
+  U8aFixed,
+  Vec,
+  bool,
+  i128,
+  u128,
+  u16,
+  u32,
+  u64,
+  u8
+} from "@polkadot/types-codec";
 async function waitForLoad() {
   await cryptoWaitReady();
 }
@@ -2819,7 +2772,10 @@ async function getClient(host) {
 
 export {
   WageProtector,
+  setConfig,
+  getConfig,
   TxSubmitter,
+  TxResult,
   MICROGONS_PER_ARGON,
   formatArgons,
   formatPercent,
@@ -2849,7 +2805,6 @@ export {
   MiningBids,
   Vault,
   VaultMonitor,
-  CohortBidderHistory,
   CohortBidder,
   BidPool,
   SATS_PER_BTC,
@@ -2860,6 +2815,34 @@ export {
   decodeAddress,
   mnemonicGenerate,
   waitForLoad,
-  getClient
+  getClient,
+  u8aToHex3 as u8aToHex,
+  hexToU8a3 as hexToU8a,
+  u8aEq,
+  GenericEvent2 as GenericEvent,
+  GenericBlock,
+  GenericAddress,
+  BTreeMap,
+  Bytes,
+  Compact,
+  Enum,
+  Null,
+  Option2 as Option,
+  Result,
+  Bool,
+  Tuple,
+  Range,
+  Struct,
+  Text,
+  U256,
+  U8aFixed,
+  Vec,
+  bool,
+  i128,
+  u128,
+  u16,
+  u32,
+  u64,
+  u8
 };
-//# sourceMappingURL=chunk-CGXT6XF7.js.map
+//# sourceMappingURL=chunk-P3OMJABP.js.map