@argonprotocol/testing 1.4.11-dev.f3bdc948 → 1.4.12-dev.2afa6e4a

package/lib/index.cjs

@@ -53,6 +53,7 @@ __export(index_exports, {
   signGatewayPermit: () => signGatewayPermit,
   startNetwork: () => startNetwork,
   stringifyExt: () => stringifyExt,
+  submitTx: () => submitTx,
   sudo: () => sudo,
   syncEthereumVerifierUntilAnchorCovers: () => syncEthereumVerifierUntilAnchorCovers,
   teardown: () => teardown,
@@ -62,13 +63,13 @@ __export(index_exports, {
   waitForFinalizedBeaconExecutionAtOrAbove: () => waitForFinalizedBeaconExecutionAtOrAbove
 });
 module.exports = __toCommonJS(index_exports);
-var import_mainchain8 = require("@argonprotocol/mainchain");
+var import_mainchain9 = require("@argonprotocol/mainchain");
 
 // src/TestNotary.ts
 var import_nanoid = require("nanoid");
 var import_pg = __toESM(require("pg"), 1);
 var child_process2 = __toESM(require("child_process"), 1);
-var import_mainchain = require("@argonprotocol/mainchain");
+var import_mainchain2 = require("@argonprotocol/mainchain");
 var fs = __toESM(require("fs"), 1);
 var readline = __toESM(require("readline"), 1);
 
@@ -170,6 +171,48 @@ function disconnectOnTeardown(closeable) {
 // src/TestNotary.ts
 var process3 = __toESM(require("process"), 1);
 var Path2 = __toESM(require("path"), 1);
+
+// src/submitTx.ts
+var import_mainchain = require("@argonprotocol/mainchain");
+function submitTx(client, tx, signer) {
+  return new Promise((resolve3, reject) => {
+    let unsubscribe;
+    let completed = false;
+    const finish = (callback) => {
+      completed = true;
+      unsubscribe?.();
+      callback();
+    };
+    tx.signAndSend(signer, (result) => {
+      if (completed) return;
+      if (result.status.isDropped || result.status.isInvalid || result.status.isUsurped) {
+        finish(() => reject(new Error(`Transaction ${result.status.type.toLowerCase()}`)));
+        return;
+      }
+      if (!result.status.isInBlock) return;
+      void (0, import_mainchain.checkForExtrinsicSuccess)(result.events, client).then(
+        () => {
+          const feePaid = result.events.find(
+            ({ event }) => client.events.transactionPayment.TransactionFeePaid.is(event)
+          );
+          finish(
+            () => resolve3({
+              blockHash: result.status.asInBlock.toHex(),
+              events: result.events.map(({ event }) => event),
+              finalFee: feePaid && client.events.transactionPayment.TransactionFeePaid.is(feePaid.event) ? feePaid.event.data.actualFee.toBigInt() : void 0
+            })
+          );
+        },
+        (error) => finish(() => reject(error))
+      );
+    }).then((stop) => {
+      unsubscribe = stop;
+      if (completed) unsubscribe();
+    }).catch((error) => finish(() => reject(error)));
+  });
+}
+
+// src/TestNotary.ts
 var { Client: PgClient } = import_pg.default;
 var nanoid = (0, import_nanoid.customAlphabet)("0123456789abcdefghijklmnopqrstuvwxyz", 4);
 function createUid() {
@@ -203,8 +246,8 @@ var TestNotary = class {
    */
   async start(options) {
     const { pathToNotaryBin, uuid, mainchainUrl } = options;
-    this.operator = new import_mainchain.Keyring({ type: "sr25519" }).createFromUri("//Bob");
-    this.registeredPublicKey = new import_mainchain.Keyring({ type: "ed25519" }).createFromUri(
+    this.operator = new import_mainchain2.Keyring({ type: "sr25519" }).createFromUri("//Bob");
+    this.registeredPublicKey = new import_mainchain2.Keyring({ type: "ed25519" }).createFromUri(
       "//Ferdie//notary"
     ).publicKey;
     let notaryPath = pathToNotaryBin ?? Path2.join(projectRoot(), "target/debug/argon-notary");
@@ -302,7 +345,7 @@ var TestNotary = class {
   }
   async register(client) {
     const address = new URL(this.address);
-    const result = await new import_mainchain.TxSubmitter(
+    await submitTx(
       client,
       client.tx.notaries.propose({
         public: this.registeredPublicKey,
@@ -310,8 +353,7 @@ var TestNotary = class {
         name: "Test Notary"
       }),
       this.operator
-    ).submit();
-    await result.waitForInFirstBlock;
+    );
   }
   async teardown() {
     this.#childProcess?.kill();
@@ -349,7 +391,7 @@ var readline2 = __toESM(require("readline"), 1);
 var import_detect_port = require("detect-port");
 var import_nanoid2 = require("nanoid");
 var lockfile = __toESM(require("proper-lockfile"), 1);
-var import_mainchain2 = require("@argonprotocol/mainchain");
+var import_mainchain3 = require("@argonprotocol/mainchain");
 var nanoid2 = (0, import_nanoid2.customAlphabet)("0123456789abcdefghijklmnopqrstuvwxyz", 4);
 var lockPath = Path3.join(process.cwd(), ".port-lock");
 var TestMainchain = class {
@@ -476,7 +518,7 @@ var TestMainchain = class {
     let lastError;
     for (let attempt = 0; attempt < 20; attempt += 1) {
       try {
-        const client = await (0, import_mainchain2.getClient)(this.address);
+        const client = await (0, import_mainchain3.getClient)(this.address);
         disconnectOnTeardown(client);
         return client;
       } catch (error) {
@@ -625,7 +667,7 @@ var BitcoinRpcClient = class {
 
 // src/TestOracle.ts
 var child_process3 = __toESM(require("child_process"), 1);
-var import_mainchain3 = require("@argonprotocol/mainchain");
+var import_mainchain4 = require("@argonprotocol/mainchain");
 var fs3 = __toESM(require("fs"), 1);
 var readline3 = __toESM(require("readline"), 1);
 var process4 = __toESM(require("process"), 1);
@@ -643,7 +685,7 @@ var TestOracle = class _TestOracle {
   async start(service, options) {
     const { pathToBin, mainchainUrl, bitcoinRpcUrl } = options;
     const operatorSuri = service == "bitcoin" ? _TestOracle.BitcoinOperator : _TestOracle.PriceIndexOperator;
-    this.operator = new import_mainchain3.Keyring({ type: "sr25519" }).createFromUri(operatorSuri);
+    this.operator = new import_mainchain4.Keyring({ type: "sr25519" }).createFromUri(operatorSuri);
     const binPath = pathToBin ?? Path4.join(projectRoot(), "target/debug/argon-oracle");
     if (!fs3.existsSync(binPath)) {
       throw new Error(`Oracle binary not found at ${binPath}`);
@@ -684,7 +726,7 @@ var os = __toESM(require("os"), 1);
 var Path5 = __toESM(require("path"), 1);
 var import_node_child_process2 = require("child_process");
 var import_detect_port2 = require("detect-port");
-var import_mainchain4 = require("@argonprotocol/mainchain");
+var import_mainchain5 = require("@argonprotocol/mainchain");
 var import_accounts = require("viem/accounts");
 var import_viem = require("viem");
 var {
@@ -694,7 +736,7 @@ var {
   mintingGatewayArtifact,
   proxyAdminArtifact,
   transparentUpgradeableProxyArtifact
-} = import_mainchain4.EvmContracts;
+} = import_mainchain5.EvmContracts;
 var DEFAULT_KURTOSIS_BIN = "kurtosis";
 var DEFAULT_ETHEREUM_PACKAGE = "github.com/ethpandaops/ethereum-package";
 var DEFAULT_EL_PORT_START = 32e3;
@@ -1171,7 +1213,7 @@ async function startNetwork(testName, options) {
 }
 
 // src/EthereumE2eUtils.ts
-var import_mainchain5 = require("@argonprotocol/mainchain");
+var import_mainchain6 = require("@argonprotocol/mainchain");
 var import_viem2 = require("viem");
 async function signGatewayPermit(args) {
   const signature = (0, import_viem2.parseSignature)(
@@ -1289,14 +1331,14 @@ async function syncEthereumVerifierUntilAnchorCovers(mainchainClient, relayer, b
   let lastAnchorBlockNumber;
   while (Date.now() - startedAt < timeoutMs) {
     try {
-      const anchor = await (0, import_mainchain5.getLatestArgonFinalizedExecutionHeader)(mainchainClient);
+      const anchor = await (0, import_mainchain6.getLatestArgonFinalizedExecutionHeader)(mainchainClient);
       lastAnchorBlockNumber = anchor.blockNumber;
       if (anchor.blockNumber >= minimumExecutionBlockNumber) {
         return;
       }
     } catch {
     }
-    const txs = await (0, import_mainchain5.getNextEthereumBeaconSyncTxs)(mainchainClient, beaconApiUrl);
+    const txs = await (0, import_mainchain6.getNextEthereumBeaconSyncTxs)(mainchainClient, beaconApiUrl);
     if (txs.length === 0) {
       await delay2(500);
       continue;
@@ -1304,8 +1346,7 @@ async function syncEthereumVerifierUntilAnchorCovers(mainchainClient, relayer, b
     let shouldRetry = false;
     for (const tx of txs) {
       try {
-        const result = await new import_mainchain5.TxSubmitter(mainchainClient, tx, relayer).submit();
-        await result.waitForInFirstBlock;
+        await submitTx(mainchainClient, tx, relayer);
         lastRetryableError = void 0;
       } catch (error) {
         if (isRetryableEthereumVerifierSyncError(error)) {
@@ -1325,35 +1366,35 @@ async function syncEthereumVerifierUntilAnchorCovers(mainchainClient, relayer, b
   );
 }
 function toArgonKeccakSignature(signature) {
-  const bytes = (0, import_mainchain5.hexToU8a)(signature);
+  const bytes = (0, import_mainchain6.hexToU8a)(signature);
   if (bytes.length !== 65) {
     throw new Error(`Expected 65-byte ECDSA signature, received ${bytes.length} bytes`);
   }
   if (bytes[64] >= 27) {
     bytes[64] -= 27;
   }
-  return (0, import_mainchain5.u8aToHex)(bytes);
+  return (0, import_mainchain6.u8aToHex)(bytes);
 }
 function toEvmRecoverableSignature(signature) {
-  const bytes = (0, import_mainchain5.hexToU8a)(signature);
+  const bytes = (0, import_mainchain6.hexToU8a)(signature);
   if (bytes.length !== 65) {
     throw new Error(`Expected 65-byte ECDSA signature, received ${bytes.length} bytes`);
   }
   if (bytes[64] <= 1) {
     bytes[64] += 27;
   }
-  return (0, import_mainchain5.u8aToHex)(bytes);
+  return (0, import_mainchain6.u8aToHex)(bytes);
 }
 function isRetryableEthereumVerifierSyncError(error) {
   const message = error instanceof Error ? error.message : String(error);
-  return (0, import_mainchain5.isOutdatedTransactionError)(error) || message.includes("ethereumVerifier.InvalidHeaderMerkleProof");
+  return (0, import_mainchain6.isOutdatedTransactionError)(error) || message.includes("ethereumVerifier.InvalidHeaderMerkleProof");
 }
 async function delay2(ms) {
   await new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 
 // src/EthereumGatewayQueue.ts
-var import_mainchain6 = require("@argonprotocol/mainchain");
+var import_mainchain7 = require("@argonprotocol/mainchain");
 var import_viem3 = require("viem");
 var {
   encodeMintingGatewayGlobalIssuanceCouncilRotateTarget,
@@ -1366,7 +1407,7 @@ var {
   hashMintingGatewayRotateGlobalIssuanceCouncilApproval,
   mintingGatewayAbi,
   MINTING_GATEWAY_UPDATE_KINDS
-} = import_mainchain6.EvmContracts;
+} = import_mainchain7.EvmContracts;
 async function getReadyEthereumGatewayUpdates(client, gatewayClient, options = {}) {
   const destinationChain = options.destinationChain ?? "Ethereum";
   const maxQueueEntries = options.maxQueueEntries ?? 100;
@@ -1639,10 +1680,10 @@ function toHexValue(value) {
 }
 
 // src/TestEthereumProofActors.ts
-var import_mainchain7 = require("@argonprotocol/mainchain");
+var import_mainchain8 = require("@argonprotocol/mainchain");
 var import_accounts2 = require("viem/accounts");
 var import_viem4 = require("viem");
-var { argonTokenAbi, mintingGatewayAbi: mintingGatewayAbi2, MINTING_GATEWAY_RUNTIME_TO_ERC20_SCALE } = import_mainchain7.EvmContracts;
+var { argonTokenAbi, mintingGatewayAbi: mintingGatewayAbi2, MINTING_GATEWAY_RUNTIME_TO_ERC20_SCALE } = import_mainchain8.EvmContracts;
 var MINIMAL_BOOTSTRAP_FINALIZED_SLOT = 64n;
 var EthereumProofE2eHarness = class _EthereumProofE2eHarness {
   constructor(ethereum, endpoints, mainchain, mainchainClient, deployerPrivateKey, proofRelayerUri) {
@@ -1674,9 +1715,9 @@ var EthereumProofE2eHarness = class _EthereumProofE2eHarness {
       chain: this.chain,
       transport: (0, import_viem4.http)(endpoints.executionRpcUrl)
     });
-    this.proofRelayer = new import_mainchain7.Keyring({ type: "sr25519" }).createFromUri(proofRelayerUri);
+    this.proofRelayer = new import_mainchain8.Keyring({ type: "sr25519" }).createFromUri(proofRelayerUri);
   }
-  sudoSigner = new import_mainchain7.Keyring({ type: "sr25519" }).createFromUri("//Alice");
+  sudoSigner = new import_mainchain8.Keyring({ type: "sr25519" }).createFromUri("//Alice");
   deployer;
   chain;
   publicClient;
@@ -1708,15 +1749,10 @@ var EthereumProofE2eHarness = class _EthereumProofE2eHarness {
     );
   }
   async submit(tx, signer) {
-    const result = await new import_mainchain7.TxSubmitter(this.mainchainClient, tx, signer).submit();
-    await result.waitForInFirstBlock;
-    return result;
+    return submitTx(this.mainchainClient, tx, signer);
   }
   async sudoSubmit(tx) {
-    const result = await this.submit(
-      this.mainchainClient.tx.sudo.sudo(tx),
-      this.sudoSigner
-    );
+    const result = await this.submit(this.mainchainClient.tx.sudo.sudo(tx.method), this.sudoSigner);
     const sudoEvent = result.events.find((event) => this.mainchainClient.events.sudo.Sudid.is(event));
     if (!sudoEvent || !this.mainchainClient.events.sudo.Sudid.is(sudoEvent)) {
       throw new Error("sudo did not emit sudo.Sudid");
@@ -1724,7 +1760,7 @@ var EthereumProofE2eHarness = class _EthereumProofE2eHarness {
     const sudoResult = sudoEvent.data[0];
     if (sudoResult.isErr) {
       throw new Error(
-        `sudo failed: ${(0, import_mainchain7.dispatchErrorToString)(this.mainchainClient, sudoResult.asErr)}`
+        `sudo failed: ${(0, import_mainchain8.dispatchErrorToString)(this.mainchainClient, sudoResult.asErr)}`
       );
     }
     return result;
@@ -1738,7 +1774,7 @@ var EthereumProofE2eHarness = class _EthereumProofE2eHarness {
     );
   }
   async proveGatewayActivity(gatewayAddress, throughExecutionBlockNumber) {
-    const payload = await (0, import_mainchain7.buildGatewayActivityProofPayload)(this.mainchainClient, {
+    const payload = await (0, import_mainchain8.buildGatewayActivityProofPayload)(this.mainchainClient, {
       executionRpcUrl: this.endpoints.executionRpcUrl,
       gatewayAddress,
       throughExecutionBlockNumber
@@ -1795,7 +1831,7 @@ var EthereumProofE2eHarness = class _EthereumProofE2eHarness {
       }
     }
     calls.push(
-      await (0, import_mainchain7.getEthereumBeaconSyncBootstrapTx)(this.mainchainClient, this.endpoints.beaconApiUrl)
+      await (0, import_mainchain8.getEthereumBeaconSyncBootstrapTx)(this.mainchainClient, this.endpoints.beaconApiUrl)
     );
     const result = await this.sudoSubmit(this.mainchainClient.tx.utility.batchAll(calls));
     return { result };
@@ -1918,7 +1954,7 @@ var TestMintingGateway = class _TestMintingGateway {
         args: [
           batch.currentCouncil,
           batch.updates,
-          (0, import_viem4.toHex)((0, import_mainchain7.decodeAddress)(operatorAddress), { size: 32 })
+          (0, import_viem4.toHex)((0, import_mainchain8.decodeAddress)(operatorAddress), { size: 32 })
         ]
       })
     });
@@ -1973,7 +2009,7 @@ var TestMintingGateway = class _TestMintingGateway {
       address: this.gatewayAddress,
       abi: mintingGatewayAbi2,
       functionName: "finalizedTransferOutOfArgonIds",
-      args: [import_mainchain7.EvmContracts.hashMintingGatewayTransferOutOfArgonRequest(transferRequest)]
+      args: [import_mainchain8.EvmContracts.hashMintingGatewayTransferOutOfArgonRequest(transferRequest)]
     });
   }
   async argonBalance(address) {
@@ -1998,7 +2034,7 @@ var TestMintingGateway = class _TestMintingGateway {
 var TestMintingAuthorityActor = class {
   constructor(harness, args) {
     this.harness = harness;
-    this.operator = new import_mainchain7.Keyring({ type: "sr25519" }).createFromUri(args.operatorUri);
+    this.operator = new import_mainchain8.Keyring({ type: "sr25519" }).createFromUri(args.operatorUri);
     this.councilSigner = (0, import_accounts2.privateKeyToAccount)(args.councilPrivateKey);
     this.authoritySigner = (0, import_accounts2.privateKeyToAccount)(args.authorityPrivateKey);
   }
@@ -2012,15 +2048,21 @@ var TestMintingAuthorityActor = class {
   async prepareOperator(args) {
     await this.harness.forceSetBalance(this.operator.address, args.freeBalance);
     await this.harness.forceSetOwnership(this.operator.address, args.ownershipBalance);
-    const vault = await import_mainchain7.Vault.create(this.harness.mainchainClient, this.operator, {
-      securitization: 1000000000n,
-      securitizationRatio: 1,
-      annualPercentRate: 0.05,
-      baseFee: 0n,
-      bitcoinXpub: args.bitcoinXpub,
-      treasuryProfitSharing: 0
-    });
-    await vault.getVault();
+    await this.harness.submit(
+      this.harness.mainchainClient.tx.vaults.create({
+        terms: {
+          bitcoinAnnualPercentRate: (0, import_mainchain8.toFixedNumber)(0.05, import_mainchain8.FIXED_U128_DECIMALS),
+          bitcoinBaseFee: 0n,
+          treasuryProfitSharing: (0, import_mainchain8.toFixedNumber)(0, import_mainchain8.PERMILL_DECIMALS),
+          treasuryBonusProfitSharing: (0, import_mainchain8.toFixedNumber)(0, import_mainchain8.PERMILL_DECIMALS)
+        },
+        securitizationRatio: (0, import_mainchain8.toFixedNumber)(1, import_mainchain8.FIXED_U128_DECIMALS),
+        securitization: 1000000000n,
+        bitcoinXpubkey: (0, import_mainchain8.hexToU8a)(args.bitcoinXpubBytesHex),
+        delegateAccountId: null
+      }),
+      this.operator
+    );
     await this.harness.sudoSubmit(
       this.harness.mainchainClient.tx.priceIndex.setOperator(this.operator.address)
     );
@@ -2028,11 +2070,11 @@ var TestMintingAuthorityActor = class {
     await this.harness.submit(
       this.harness.mainchainClient.tx.priceIndex.submit(
         {
-          btcUsdPrice: (0, import_mainchain7.toFixedNumber)(6e4, 18),
-          argonotUsdPrice: (0, import_mainchain7.toFixedNumber)(1, 18),
-          argonUsdPrice: (0, import_mainchain7.toFixedNumber)(1, 18),
-          argonUsdTargetPrice: (0, import_mainchain7.toFixedNumber)(1, 18),
-          argonTimeWeightedAverageLiquidity: (0, import_mainchain7.toFixedNumber)(1e6, 18),
+          btcUsdPrice: (0, import_mainchain8.toFixedNumber)(6e4, 18),
+          argonotUsdPrice: (0, import_mainchain8.toFixedNumber)(1, 18),
+          argonUsdPrice: (0, import_mainchain8.toFixedNumber)(1, 18),
+          argonUsdTargetPrice: (0, import_mainchain8.toFixedNumber)(1, 18),
+          argonTimeWeightedAverageLiquidity: (0, import_mainchain8.toFixedNumber)(1e6, 18),
           tick: currentTick.toBigInt()
         },
         null
@@ -2126,8 +2168,8 @@ var TestMintingAuthorityActor = class {
     await this.harness.submit(
       this.harness.mainchainClient.tx.crosschainTransfer.approveQueueEntries(
         "Ethereum",
-        new import_mainchain7.Vec(this.harness.mainchainClient.registry, import_mainchain7.U8aFixed.with(520), [
-          new import_mainchain7.U8aFixed(
+        new import_mainchain8.Vec(this.harness.mainchainClient.registry, import_mainchain8.U8aFixed.with(520), [
+          new import_mainchain8.U8aFixed(
             this.harness.mainchainClient.registry,
             toArgonKeccakSignature(councilApprovalSignature),
             520
@@ -2173,7 +2215,7 @@ var TestMintingAuthorityActor = class {
       mintingAuthorityTip: transfer.mintingAuthorityTip.toBigInt()
     };
     const micronotCollateral = transfer.amount.toBigInt();
-    const collateralizationHash = import_mainchain7.EvmContracts.hashMintingGatewayMintingAuthorization(
+    const collateralizationHash = import_mainchain8.EvmContracts.hashMintingGatewayMintingAuthorization(
       { chainId: BigInt(this.harness.chain.id), gatewayAddress: gateway.gatewayAddress },
       {
         request: transferRequest,
@@ -2245,16 +2287,15 @@ function stringifyExt(obj) {
   );
 }
 function sudo() {
-  return new import_mainchain8.Keyring({ type: "sr25519" }).createFromUri("//Alice");
+  return new import_mainchain9.Keyring({ type: "sr25519" }).createFromUri("//Alice");
 }
 async function activateNotary(sudo2, client, notary) {
   await notary.register(client);
-  const txResult = await new import_mainchain8.TxSubmitter(
+  await submitTx(
     client,
     client.tx.sudo.sudo(client.tx.notaries.activate(notary.operator.publicKey)),
     sudo2
-  ).submit();
-  await txResult.waitForInFirstBlock;
+  );
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -2281,6 +2322,7 @@ async function activateNotary(sudo2, client, notary) {
   signGatewayPermit,
   startNetwork,
   stringifyExt,
+  submitTx,
   sudo,
   syncEthereumVerifierUntilAnchorCovers,
   teardown,