@argent/x-shared 1.42.1 → 1.43.1

package/dist/src/transactions/service/implementation.js

@@ -2,11 +2,11 @@ import { TransactionType as u } from "starknet";
 import g from "url-join";
 import { ReviewError as d } from "../../errors/review.js";
 import { getTxVersionFromFeeToken as E } from "../getTransactionVersion.js";
-import { getPayloadFromTransaction as F, getEstimatedFeeFromSimulationAndRespectWatermarkFee as I } from "../estimate/utils.js";
-import { urlWithQuery as C } from "../../utils/url/urlWithQuery.js";
-import { simulateAndReviewSchema as O, isTransactionSimulationError as S } from "../../features/simulation/transactionReview/schema.js";
-import { ensureArray as N } from "../../utils/arrays.js";
-class B {
+import { getPayloadFromTransaction as I, getEstimatedFeeFromSimulationAndRespectWatermarkFee as C } from "../estimate/utils.js";
+import { urlWithQuery as O } from "../../utils/url/urlWithQuery.js";
+import { simulateAndReviewSchema as S, isTransactionSimulationError as N } from "../../features/simulation/transactionReview/schema.js";
+import { ensureArray as v } from "../../utils/arrays.js";
+class x {
   constructor(a, e) {
     this.apiBase = a, this.httpService = e;
   }
@@ -26,99 +26,100 @@ class B {
     const a = g(this.apiBase, "reviewer", "warnings/reasons");
     return await this.httpService.get(a);
   }
-  async simulateAndReview(a, e, c, o, m, t) {
-    const r = e.some((i) => i.type === "DEPLOY_ACCOUNT");
+  async simulateAndReview(a, e, o, n, c, s) {
+    var m;
+    const r = e.some((t) => t.type === "DEPLOY_ACCOUNT");
     try {
       if (!("getChainId" in a))
         throw new Error("MISSING_METHOD");
-      const i = E(c), s = r ? "0x0" : await a.getNonce(), n = await a.getChainId(), l = {
+      const t = E(o), i = r ? "0x0" : await a.getNonce(), l = await a.getChainId(), w = {
         transactions: e.map((h) => ({
-          ...F({
+          ...I({
             transaction: h,
-            nonce: s,
-            version: i,
-            chainId: n,
+            nonce: i,
+            version: t,
+            chainId: l,
             isDeploymentTransaction: r,
-            appDomain: o,
+            appDomain: n,
             cairoVersion: a.cairoVersion,
             address: a.address
           }),
           type: h.type
         }))
-      }, _ = g(this.apiBase, "reviewer", "transactions", "v2", "review", "starknet"), w = t ? C(_, { delayedTransactions: "true" }) : _, p = await this.httpService.post(w, {
+      }, _ = g(this.apiBase, "reviewer", "transactions", "v2", "review", "starknet"), y = s ? O(_, { delayedTransactions: "true" }) : _, p = await this.httpService.post(y, {
         headers: {
           Accept: "application/json",
           "Content-Type": "application/json"
         },
-        body: JSON.stringify(l)
-      }, O);
-      if (p.transactions.some((h) => S(h)))
+        body: JSON.stringify(w)
+      }, S);
+      if ((m = p.transactions) == null ? void 0 : m.some((h) => N(h)))
         return p;
-      const y = I(p, c);
+      const F = C(p, o);
       return {
         ...p,
-        enrichedFeeEstimation: y
+        enrichedFeeEstimation: F
       };
-    } catch (i) {
-      return console.error(i), this.fallbackToOnchainFeeEstimation({
+    } catch (t) {
+      return console.error(t), this.fallbackToOnchainFeeEstimation({
         transactions: e,
         account: a,
         isDeploymentTransaction: r,
-        feeTokenAddress: c,
-        accountDeployTransaction: m
+        feeTokenAddress: o,
+        accountDeployTransaction: c
       });
     }
   }
   getCallsFromTx(a) {
     let e;
-    return a.calls && (e = N(a.calls)), e;
+    return a.calls && (e = v(a.calls)), e;
   }
-  async fallbackToOnchainFeeEstimation({ transactions: a, account: e, isDeploymentTransaction: c, feeTokenAddress: o, accountDeployTransaction: m }) {
+  async fallbackToOnchainFeeEstimation({ transactions: a, account: e, isDeploymentTransaction: o, feeTokenAddress: n, accountDeployTransaction: c }) {
     try {
-      const t = c ? this.getCallsFromTx(a[1]) : this.getCallsFromTx(a[0]);
-      if (!t)
+      const s = o ? this.getCallsFromTx(a[1]) : this.getCallsFromTx(a[0]);
+      if (!s)
         throw new d({
           code: "NO_CALLS_FOUND"
         });
       const r = await this.fetchFeesOnchain({
         starknetAccount: e,
-        calls: t,
-        isDeployed: !c,
-        feeTokenAddress: o,
-        accountDeployTransaction: m
+        calls: s,
+        isDeployed: !o,
+        feeTokenAddress: n,
+        accountDeployTransaction: c
       });
       return {
         transactions: [],
         enrichedFeeEstimation: r,
         isBackendDown: !0
       };
-    } catch (t) {
-      throw console.error(t), new d({
-        message: `${t}`,
+    } catch (s) {
+      throw console.error(s), new d({
+        message: `${s}`,
         code: "SIMULATE_AND_REVIEW_FAILED"
       });
     }
   }
-  async fetchFeesOnchain({ starknetAccount: a, calls: e, isDeployed: c, feeTokenAddress: o, accountDeployTransaction: m }) {
+  async fetchFeesOnchain({ starknetAccount: a, calls: e, isDeployed: o, feeTokenAddress: n, accountDeployTransaction: c }) {
     try {
-      const t = E(o), r = {
+      const s = E(n), r = {
         transactions: {
-          feeTokenAddress: o,
+          feeTokenAddress: n,
           amount: 0n,
           pricePerUnit: 0n,
           dataGasConsumed: 0n,
           dataGasPrice: 0n
         }
       };
-      if (!c && m) {
+      if (!o && c) {
         if ("estimateFeeBulk" in a) {
-          const i = [
+          const m = [
             {
               type: u.DEPLOY_ACCOUNT,
               payload: {
-                classHash: m.classHash,
-                addressSalt: m.salt,
-                constructorCalldata: m.calldata,
+                classHash: c.classHash,
+                addressSalt: c.salt,
+                constructorCalldata: c.calldata,
                 contractAddress: a.address
               }
             },
@@ -126,57 +127,57 @@ class B {
               type: u.INVOKE,
               payload: e
             }
-          ], [s, n] = await a.estimateFeeBulk(i, {
-            version: t
+          ], [t, i] = await a.estimateFeeBulk(m, {
+            version: s
           }).catch((l) => {
             throw console.error(l), l;
           });
-          if (!s.gas_consumed || !s.gas_price || !n.gas_consumed || !n.gas_price)
+          if (!t.gas_consumed || !t.gas_price || !i.gas_consumed || !i.gas_price)
             throw new d({
               code: "ONCHAIN_FEE_ESTIMATION_FAILED",
               message: "Missing gas_consumed or gas_price"
             });
           r.deployment = {
-            feeTokenAddress: o,
-            amount: s.gas_consumed,
-            pricePerUnit: s.gas_price,
-            dataGasConsumed: s.data_gas_consumed,
-            dataGasPrice: s.data_gas_price
+            feeTokenAddress: n,
+            amount: t.gas_consumed,
+            pricePerUnit: t.gas_price,
+            dataGasConsumed: t.data_gas_consumed,
+            dataGasPrice: t.data_gas_price
           }, r.transactions = {
-            feeTokenAddress: o,
-            amount: n.gas_consumed,
-            pricePerUnit: n.gas_price,
-            dataGasConsumed: n.data_gas_consumed,
-            dataGasPrice: n.data_gas_price
+            feeTokenAddress: n,
+            amount: i.gas_consumed,
+            pricePerUnit: i.gas_price,
+            dataGasConsumed: i.data_gas_consumed,
+            dataGasPrice: i.data_gas_price
           };
         }
       } else {
-        const { gas_consumed: i, gas_price: s, data_gas_consumed: n, data_gas_price: l } = await a.estimateFee(e, {
+        const { gas_consumed: m, gas_price: t, data_gas_consumed: i, data_gas_price: l } = await a.estimateFee(e, {
           skipValidate: !0,
-          version: t
+          version: s
         });
-        if (!i || !s)
+        if (!m || !t)
           throw new d({
             code: "ONCHAIN_FEE_ESTIMATION_FAILED",
             message: "Missing gas_consumed or gas_price"
           });
         r.transactions = {
-          feeTokenAddress: o,
-          amount: i,
-          pricePerUnit: s,
-          dataGasConsumed: n,
+          feeTokenAddress: n,
+          amount: m,
+          pricePerUnit: t,
+          dataGasConsumed: i,
           dataGasPrice: l
         };
       }
       return r;
-    } catch (t) {
+    } catch (s) {
       throw new d({
         code: "ONCHAIN_FEE_ESTIMATION_FAILED",
-        message: `${t}`
+        message: `${s}`
       });
     }
   }
 }
 export {
-  B as TransactionReviewServiceWeb
+  x as TransactionReviewServiceWeb
 };

package/dist/src/transactions/service/index.d.ts

@@ -1,3 +1,3 @@
 export * from './implementation';
-export * from './interface';
+export type * from './interface';
 export * from './types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@argent/x-shared",
-  "version": "1.42.1",
+  "version": "1.43.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/argentlabs/x-shared.git"