@argonprotocol/mainchain 1.3.11 → 1.3.13

package/lib/index.js

@@ -81,158 +81,6 @@ var WageProtector = class _WageProtector {
   }
 };
 
-// src/TxSubmitter.ts
-function logExtrinsicResult(result) {
-  const json = result.status.toJSON();
-  const status = Object.keys(json)[0];
-  console.debug('Transaction update: "%s"', status, json[status]);
-}
-var TxSubmitter = class {
-  constructor(client, tx, pair) {
-    this.client = client;
-    this.tx = tx;
-    this.pair = pair;
-  }
-  async feeEstimate(tip) {
-    const { partialFee } = await this.tx.paymentInfo(this.pair, { tip });
-    return partialFee.toBigInt();
-  }
-  async canAfford(options = {}) {
-    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: userBalance, txFee: fees };
-  }
-  async submit(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;
-    const txString = [];
-    let api = formatCall(toHuman);
-    const args = [];
-    if (api === "proxy.proxy") {
-      toHuman = toHuman.args.call;
-      txString.push("Proxy");
-      api = formatCall(toHuman);
-    }
-    if (api.startsWith("utility.batch")) {
-      const calls = toHuman.args.calls.map(formatCall).join(", ");
-      txString.push(`Batch[${calls}]`);
-    } else {
-      txString.push(api);
-      args.push(toHuman.args);
-    }
-    args.unshift(txString.join("->"));
-    if (useLatestNonce && !apiOptions.nonce) {
-      apiOptions.nonce = await this.client.rpc.system.accountNextIndex(this.pair.address);
-    }
-    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;
-  }
-};
-function formatCall(call) {
-  return `${call.section}.${call.method}`;
-}
-var TxResult = class {
-  constructor(client, shouldLog = false) {
-    this.client = client;
-    this.shouldLog = shouldLog;
-    this.inBlockPromise = new Promise((resolve, reject) => {
-      this.inBlockResolve = resolve;
-      this.inBlockReject = reject;
-    });
-    this.finalizedPromise = new Promise((resolve, reject) => {
-      this.finalizedResolve = resolve;
-      this.finalizedReject = reject;
-    });
-    this.inBlockPromise.catch(() => null);
-    this.finalizedPromise.catch(() => null);
-  }
-  inBlockPromise;
-  finalizedPromise;
-  status;
-  events = [];
-  /**
-   * The index of the batch that was interrupted, if any.
-   */
-  batchInterruptedIndex;
-  includedInBlock;
-  /**
-   * The final fee paid for the transaction, including the fee tip.
-   */
-  finalFee;
-  /**
-   * The fee tip paid for the transaction.
-   */
-  finalFeeTip;
-  txProgressCallback;
-  inBlockResolve;
-  inBlockReject;
-  finalizedResolve;
-  finalizedReject;
-  onResult(result) {
-    this.status = result.status;
-    if (this.shouldLog) {
-      logExtrinsicResult(result);
-    }
-    const { events, status, dispatchError, isFinalized } = result;
-    if (status.isInBlock) {
-      this.includedInBlock = new Uint8Array(status.asInBlock);
-      let encounteredError = dispatchError;
-      let batchErrorIndex;
-      for (const event of events) {
-        this.events.push(event.event);
-        if (this.client.events.utility.BatchInterrupted.is(event.event)) {
-          batchErrorIndex = event.event.data[0].toNumber();
-          this.batchInterruptedIndex = batchErrorIndex;
-          encounteredError = event.event.data[1];
-        }
-        if (this.client.events.transactionPayment.TransactionFeePaid.is(event.event)) {
-          const [_who, actualFee, tip] = event.event.data;
-          this.finalFee = actualFee.toBigInt();
-          this.finalFeeTip = tip.toBigInt();
-        }
-      }
-      if (encounteredError) {
-        const error = dispatchErrorToExtrinsicError(this.client, encounteredError, batchErrorIndex);
-        this.reject(error);
-      } else {
-        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);
-    this.finalizedReject(error);
-  }
-};
-
 // src/utils.ts
 import BigNumber, * as BN from "bignumber.js";
 var { ROUND_FLOOR } = BN;
@@ -280,12 +128,13 @@ function dispatchErrorToString(client, error) {
   }
   return message;
 }
-var ExtrinsicError2 = class extends Error {
-  constructor(errorCode, details, batchInterruptedIndex) {
+var ExtrinsicError = class extends Error {
+  constructor(errorCode, details, batchInterruptedIndex, txFee = 0n) {
     super(errorCode);
     this.errorCode = errorCode;
     this.details = details;
     this.batchInterruptedIndex = batchInterruptedIndex;
+    this.txFee = txFee;
   }
   toString() {
     if (this.batchInterruptedIndex !== void 0) {
@@ -294,13 +143,13 @@ var ExtrinsicError2 = class extends Error {
     return `${this.errorCode} ${this.details ?? ""}`;
   }
 };
-function dispatchErrorToExtrinsicError(client, error, batchInterruptedIndex) {
+function dispatchErrorToExtrinsicError(client, error, batchInterruptedIndex, txFee) {
   if (error.isModule) {
     const decoded = client.registry.findMetaError(error.asModule);
     const { docs, name, section } = decoded;
-    return new ExtrinsicError2(`${section}.${name}`, docs.join(" "), batchInterruptedIndex);
+    return new ExtrinsicError(`${section}.${name}`, docs.join(" "), batchInterruptedIndex, txFee);
   }
-  return new ExtrinsicError2(error.toString(), void 0, batchInterruptedIndex);
+  return new ExtrinsicError(error.toString(), void 0, batchInterruptedIndex, txFee);
 }
 function checkForExtrinsicSuccess(events, client) {
   return new Promise((resolve, reject) => {
@@ -320,6 +169,243 @@ function checkForExtrinsicSuccess(events, client) {
   });
 }
 
+// src/TxResult.ts
+var TxResult = class {
+  constructor(client, extrinsic) {
+    this.client = client;
+    this.extrinsic = extrinsic;
+    this.waitForFinalizedBlock = new Promise((resolve, reject) => {
+      this.finalizedResolve = resolve;
+      this.finalizedReject = reject;
+    });
+    this.waitForInFirstBlock = new Promise((resolve, reject) => {
+      this.inBlockResolve = resolve;
+      this.inBlockReject = reject;
+    });
+    this.waitForFinalizedBlock.catch(() => null);
+    this.waitForInFirstBlock.catch(() => null);
+  }
+  #isBroadcast = false;
+  #submissionError;
+  set isBroadcast(value) {
+    this.#isBroadcast = value;
+    this.updateProgress();
+  }
+  get isBroadcast() {
+    return this.#isBroadcast;
+  }
+  set submissionError(value) {
+    if (value) {
+      this.#submissionError = value;
+      this.finalizedReject(value);
+      this.inBlockReject(value);
+      this.updateProgress();
+    }
+  }
+  get submissionError() {
+    return this.#submissionError;
+  }
+  waitForFinalizedBlock;
+  waitForInFirstBlock;
+  events = [];
+  extrinsicError;
+  extrinsicIndex;
+  txProgressCallback;
+  /**
+   * The index of the batch that was interrupted, if any.
+   */
+  batchInterruptedIndex;
+  blockHash;
+  blockNumber;
+  /**
+   * The final fee paid for the transaction, including the fee tip.
+   */
+  finalFee;
+  /**
+   * The fee tip paid for the transaction.
+   */
+  finalFeeTip;
+  txProgress = 0;
+  isFinalized = false;
+  finalizedResolve;
+  finalizedReject;
+  inBlockResolve;
+  inBlockReject;
+  async setSeenInBlock(block) {
+    const { blockHash, blockNumber, events } = block;
+    if (blockHash !== this.blockHash) {
+      this.parseEvents(events);
+      this.blockHash = blockHash;
+      this.blockNumber = blockNumber ?? await this.client.rpc.chain.getHeader(blockHash).then((h) => h.number.toNumber());
+      this.extrinsicIndex = block.extrinsicIndex;
+      this.updateProgress();
+      if (this.extrinsicError) {
+        this.inBlockReject(this.extrinsicError);
+      } else {
+        this.inBlockResolve(blockHash);
+      }
+    }
+  }
+  setFinalized() {
+    this.isFinalized = true;
+    this.updateProgress();
+    let error = this.extrinsicError ?? this.submissionError;
+    if (!error && !this.blockHash) {
+      error = new Error("Cannot finalize transaction before it is included in a block");
+    }
+    if (error) {
+      this.finalizedReject(error);
+      this.inBlockReject(error);
+    } else {
+      this.finalizedResolve(this.blockHash);
+      this.inBlockResolve(this.blockHash);
+    }
+  }
+  onSubscriptionResult(result) {
+    const { events, status, isFinalized, txIndex } = result;
+    const extrinsicEvents = events.map((x) => x.event);
+    if (status.isBroadcast) {
+      this.isBroadcast = true;
+      if (result.internalError) this.submissionError = result.internalError;
+    }
+    if (status.isInBlock) {
+      void this.setSeenInBlock({
+        blockHash: Uint8Array.from(status.asInBlock),
+        events: extrinsicEvents,
+        extrinsicIndex: txIndex
+      });
+    }
+    if (isFinalized) {
+      this.setFinalized();
+    }
+  }
+  updateProgress() {
+    if (this.isFinalized || this.submissionError) {
+      this.txProgress = 100;
+    } else if (this.blockNumber) {
+      const elapsedBlocks = this.blockNumber - this.extrinsic.submittedAtBlockNumber;
+      const FINALIZATION_BLOCKS = 5;
+      const remainingPercent = Math.max(0, FINALIZATION_BLOCKS - elapsedBlocks) * 20;
+      const percent = 100 - remainingPercent;
+      this.txProgress = Math.min(percent, 99);
+    } else if (this.extrinsic.submittedAtBlockNumber) {
+      this.txProgress = 10;
+    }
+    this.txProgressCallback?.(this.txProgress);
+  }
+  parseEvents(events) {
+    let encounteredError;
+    for (const event of events) {
+      if (this.client.events.system.ExtrinsicFailed.is(event)) {
+        const { dispatchError } = event.data;
+        encounteredError ??= dispatchError;
+      }
+      if (this.client.events.utility.BatchInterrupted.is(event)) {
+        const { index, error } = event.data;
+        this.batchInterruptedIndex = index.toNumber();
+        encounteredError = error;
+      }
+      if (this.client.events.transactionPayment.TransactionFeePaid.is(event)) {
+        const { actualFee, tip } = event.data;
+        this.finalFee = actualFee.toBigInt();
+        this.finalFeeTip = tip.toBigInt();
+      }
+    }
+    if (encounteredError) {
+      this.extrinsicError = dispatchErrorToExtrinsicError(
+        this.client,
+        encounteredError,
+        this.batchInterruptedIndex,
+        this.finalFee
+      );
+    } else {
+      this.extrinsicError = void 0;
+    }
+    this.events = events;
+  }
+};
+
+// src/TxSubmitter.ts
+var TxSubmitter = class {
+  constructor(client, tx, pair) {
+    this.client = client;
+    this.tx = tx;
+    this.pair = pair;
+  }
+  async feeEstimate(tip) {
+    const { partialFee } = await this.tx.paymentInfo(this.pair, { tip });
+    return partialFee.toBigInt();
+  }
+  async canAfford(options = {}) {
+    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: userBalance, txFee: fees };
+  }
+  async submit(options = {}) {
+    const { useLatestNonce, ...apiOptions } = options;
+    await waitForLoad();
+    const blockHeight = await this.client.rpc.chain.getHeader().then((h) => h.number.toNumber());
+    if (options.logResults) {
+      this.logRequest();
+    }
+    if (useLatestNonce && !apiOptions.nonce) {
+      apiOptions.nonce = await this.client.rpc.system.accountNextIndex(this.pair.address);
+    }
+    const signedTx = await this.tx.signAsync(this.pair, apiOptions);
+    const txHash = signedTx.hash.toHex();
+    const result = new TxResult(this.client, {
+      signedHash: txHash,
+      method: signedTx.method.toHuman(),
+      accountAddress: this.pair.address,
+      submittedTime: /* @__PURE__ */ new Date(),
+      submittedAtBlockNumber: blockHeight
+    });
+    if (options.disableAutomaticTxTracking !== true) {
+      await signedTx.send(result.onSubscriptionResult.bind(result));
+    } else {
+      try {
+        await signedTx.send();
+        result.isBroadcast = true;
+      } catch (error) {
+        result.submissionError = error;
+      }
+    }
+    return result;
+  }
+  logRequest() {
+    let toHuman = this.tx.toHuman().method;
+    const txString = [];
+    let api = formatCall(toHuman);
+    const args = [];
+    if (api === "proxy.proxy") {
+      toHuman = toHuman.args.call;
+      txString.push("Proxy");
+      api = formatCall(toHuman);
+    }
+    if (api.startsWith("utility.batch")) {
+      const calls = toHuman.args.calls.map(formatCall).join(", ");
+      txString.push(`Batch[${calls}]`);
+    } else {
+      txString.push(api);
+      args.push(toHuman.args);
+    }
+    args.unshift(txString.join("->"));
+    console.log("Submitting transaction from %s:", this.pair.address, ...args);
+  }
+};
+function formatCall(call) {
+  return `${call.section}.${call.method}`;
+}
+
 // src/keyringUtils.ts
 function keyringFromSuri(suri, cryptoType = "sr25519") {
   return new Keyring({ type: cryptoType }).createFromUri(suri);
@@ -517,29 +603,29 @@ var Vault = class _Vault {
       );
     }
     const result = await tx.submit({
-      tip,
-      useLatestNonce: true,
-      waitForBlock: true,
-      txProgressCallback
+      ...args,
+      useLatestNonce: true
     });
-    await result.inBlockPromise;
-    let vaultId;
-    for (const event of result.events) {
-      if (client.events.vaults.VaultCreated.is(event)) {
-        vaultId = event.data.vaultId.toNumber();
-        break;
+    const tickDuration = config.tickDurationMillis ?? await client.query.ticks.genesisTicker().then((x) => x.tickDurationMillis.toNumber());
+    async function getVault() {
+      await result.waitForFinalizedBlock;
+      let vaultId;
+      for (const event of result.events) {
+        if (client.events.vaults.VaultCreated.is(event)) {
+          vaultId = event.data.vaultId.toNumber();
+          break;
+        }
       }
+      if (vaultId === void 0) {
+        throw new Error("Vault creation failed, no VaultCreated event found");
+      }
+      const rawVault = await client.query.vaults.vaultsById(vaultId);
+      if (rawVault.isNone) {
+        throw new Error("Vault creation failed, vault not found");
+      }
+      return new _Vault(vaultId, rawVault.unwrap(), tickDuration);
     }
-    if (vaultId === void 0) {
-      throw new Error("Vault creation failed, no VaultCreated event found");
-    }
-    const rawVault = await client.query.vaults.vaultsById(vaultId);
-    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());
-    const vault = new _Vault(vaultId, rawVault.unwrap(), tickDuration);
-    return { vault, txResult: result };
+    return { getVault, txResult: result };
   }
 };
 
@@ -678,7 +764,7 @@ var BitcoinLocks = class {
     const signature = u8aToHex(vaultSignature);
     const tx = client.tx.bitcoinLocks.cosignRelease(utxoId, signature);
     const submitter = new TxSubmitter(client, tx, argonKeyring);
-    return await submitter.submit({ txProgressCallback });
+    return await submitter.submit(args);
   }
   async getBitcoinLock(utxoId) {
     const utxoRaw = await this.client.query.bitcoinLocks.locksByUtxoId(utxoId);
@@ -844,17 +930,11 @@ var BitcoinLocks = class {
       unavailableBalance: securityFee + (args.reducedBalanceBy ?? 0n),
       includeExistentialDeposit: true
     });
-    if (!canAfford) {
-      throw new Error(
-        `Insufficient funds to initialize lock. Available: ${formatArgons(availableBalance)}, Required: ${satoshis}`
-      );
-    }
-    return { tx, securityFee, txFee };
+    return { tx, securityFee, txFee, canAfford, availableBalance, txFeePlusTip: txFee + tip };
   }
   async getBitcoinLockFromTxResult(txResult) {
-    const client = this.client;
-    const blockHash = await txResult.inBlockPromise;
-    const blockHeight = await client.at(blockHash).then((x) => x.query.system.number()).then((x) => x.toNumber());
+    await txResult.waitForFinalizedBlock;
+    const blockHeight = txResult.blockNumber;
     const utxoId = await this.getUtxoIdFromEvents(txResult.events) ?? 0;
     if (utxoId === 0) {
       throw new Error("Bitcoin lock creation failed, no UTXO ID found in transaction events");
@@ -866,20 +946,18 @@ var BitcoinLocks = class {
     return { lock, createdAtHeight: blockHeight, txResult };
   }
   async initializeLock(args) {
-    const { argonKeyring, tip = 0n, txProgressCallback } = args;
+    const { argonKeyring } = args;
     const client = this.client;
-    const { tx, securityFee } = await this.createInitializeLockTx(args);
+    const { tx, securityFee, canAfford, txFeePlusTip } = await this.createInitializeLockTx(args);
+    if (!canAfford) {
+      throw new Error(
+        `Insufficient funds to initialize bitcoin lock. Required security fee: ${formatArgons(securityFee)}, Tx fee plus tip: ${formatArgons(txFeePlusTip)}`
+      );
+    }
     const submitter = new TxSubmitter(client, tx, argonKeyring);
-    const txResult = await submitter.submit({
-      waitForBlock: true,
-      logResults: true,
-      tip,
-      txProgressCallback
-    });
-    const { lock, createdAtHeight } = await this.getBitcoinLockFromTxResult(txResult);
+    const txResult = await submitter.submit({ logResults: true, ...args });
     return {
-      lock,
-      createdAtHeight,
+      getLock: () => this.getBitcoinLockFromTxResult(txResult),
       txResult,
       securityFee
     };
@@ -895,8 +973,7 @@ var BitcoinLocks = class {
       priceIndex,
       releaseRequest: { bitcoinNetworkFee, toScriptPubkey },
       argonKeyring,
-      tip,
-      txProgressCallback
+      tip = 0n
     } = args;
     if (!toScriptPubkey.startsWith("0x")) {
       throw new Error("toScriptPubkey must be a hex string starting with 0x");
@@ -913,21 +990,13 @@ var BitcoinLocks = class {
     });
     if (!canAfford.canAfford) {
       throw new Error(
-        `Insufficient funds to release lock. Available: ${formatArgons(canAfford.availableBalance)}, Required: ${formatArgons(redemptionPrice)}`
+        `Insufficient funds to release lock. Available: ${formatArgons(canAfford.availableBalance)}, Required: ${formatArgons(redemptionPrice + canAfford.txFee + tip)}`
       );
     }
-    const txResult = await submitter.submit({
-      waitForBlock: true,
+    return submitter.submit({
       logResults: true,
-      tip,
-      txProgressCallback
+      ...args
     });
-    const blockHash = await txResult.inBlockPromise;
-    const blockHeight = await client.at(blockHash).then((x) => x.query.system.number()).then((x) => x.toNumber());
-    return {
-      blockHash,
-      blockHeight
-    };
   }
   async releasePrice(priceIndex, lock) {
     return await this.getRedemptionRate(priceIndex, lock);
@@ -974,41 +1043,43 @@ var BitcoinLocks = class {
         )}`
       );
     }
-    const submission = await txSubmitter.submit({
-      waitForBlock: true,
-      tip,
-      txProgressCallback
-    });
-    const ratchetEvent = submission.events.find(
-      (x) => client.events.bitcoinLocks.BitcoinLockRatcheted.is(x)
-    );
-    if (!ratchetEvent) {
-      throw new Error(`Ratchet event not found in transaction events`);
-    }
-    const blockHash = await submission.inBlockPromise;
-    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,
-      liquidityPromised: liquidityPromisedRaw,
-      newPeggedPrice,
-      originalPeggedPrice
-    } = ratchetEvent.data;
-    const liquidityPromised = liquidityPromisedRaw.toBigInt();
-    let mintAmount = liquidityPromised;
-    if (liquidityPromised > originalPeggedPrice.toBigInt()) {
-      mintAmount -= originalPeggedPrice.toBigInt();
-    }
+    const txResult = await txSubmitter.submit(args);
+    const getRatchetResult = async () => {
+      const blockHash = await txResult.waitForFinalizedBlock;
+      const ratchetEvent = txResult.events.find(
+        (x) => client.events.bitcoinLocks.BitcoinLockRatcheted.is(x)
+      );
+      if (!ratchetEvent) {
+        throw new Error(`Ratchet event not found in transaction events`);
+      }
+      const api = await client.at(blockHash);
+      const bitcoinBlockHeight = await api.query.bitcoinUtxos.confirmedBitcoinBlockTip().then((x) => x.unwrap().blockHeight.toNumber());
+      const {
+        amountBurned,
+        liquidityPromised: liquidityPromisedRaw,
+        newPeggedPrice,
+        originalPeggedPrice,
+        securityFee
+      } = ratchetEvent.data;
+      const liquidityPromised = liquidityPromisedRaw.toBigInt();
+      let mintAmount = liquidityPromised;
+      if (liquidityPromised > originalPeggedPrice.toBigInt()) {
+        mintAmount -= originalPeggedPrice.toBigInt();
+      }
+      return {
+        txFee: txResult.finalFee ?? 0n,
+        blockHeight: txResult.blockNumber,
+        bitcoinBlockHeight,
+        pendingMint: mintAmount,
+        liquidityPromised,
+        newPeggedPrice: newPeggedPrice.toBigInt(),
+        burned: amountBurned.toBigInt(),
+        securityFee: securityFee.toBigInt()
+      };
+    };
     return {
-      txFee: submission.finalFee ?? 0n,
-      securityFee: ratchetPrice.ratchetingFee,
-      pendingMint: mintAmount,
-      liquidityPromised,
-      newPeggedPrice: newPeggedPrice.toBigInt(),
-      burned: amountBurned.toBigInt(),
-      blockHeight,
-      bitcoinBlockHeight
+      txResult,
+      getRatchetResult
     };
   }
 };
@@ -1073,7 +1144,7 @@ var PriceIndex = class {
 
 // src/index.ts
 import { u8aToHex as u8aToHex2, hexToU8a as hexToU8a2, u8aEq } from "@polkadot/util";
-import { GenericEvent as GenericEvent2, GenericBlock, GenericAddress } from "@polkadot/types/generic";
+import { GenericEvent, GenericBlock, GenericAddress } from "@polkadot/types/generic";
 import {
   BTreeMap,
   Bytes,
@@ -1117,11 +1188,11 @@ export {
   Bytes,
   Compact,
   Enum,
-  ExtrinsicError2 as ExtrinsicError,
+  ExtrinsicError,
   FIXED_U128_DECIMALS,
   GenericAddress,
   GenericBlock,
-  GenericEvent2 as GenericEvent,
+  GenericEvent,
   Keyring,
   MICROGONS_PER_ARGON,
   Null,