@argent/x-shared 1.34.6 → 1.35.0

package/dist/transactionVersion-CACUj2ch.mjs

@@ -0,0 +1,793 @@
+import { z as t } from "zod";
+import { a7 as E, ar as L, t as u, a8 as V, al as rt, p as st, c as w, v as D, q as r } from "./webToken.model-Cl4dvcmj.mjs";
+import { uint256 as S, num as d, hash as P, constants as T } from "starknet";
+import { isString as ct, isEmpty as lt } from "lodash-es";
+import "@scure/base";
+import "react";
+import "object-hash";
+import "swr";
+const me = "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7", de = "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d", ge = "0x1a736d6ed154502257f02b1ccdf4d9d1089f80811cd6acad48e6b6a9d1f2003", fe = "0x036078334509b514626504edc9fb252328d1a240e4e948bef8d0c08dff45927f", he = "0x737ee2f87ce571a58c6c8da558ec18a07ceb64a6172d5ec46171fbc80077a48", be = "0x6e150953b26271a740bf2b6e9bca17cc52c68d765f761295de51ceb8526ee72", ye = "0x4d07e40e93398ed3c76981e72dd1fd22557a78ce36c0515f679e27f0bb5bc5f";
+var ut = {};
+function l(e, n) {
+  typeof n == "boolean" && (n = { forever: n }), this._originalTimeouts = JSON.parse(JSON.stringify(e)), this._timeouts = e, this._options = n || {}, this._maxRetryTime = n && n.maxRetryTime || 1 / 0, this._fn = null, this._errors = [], this._attempts = 1, this._operationTimeout = null, this._operationTimeoutCb = null, this._timeout = null, this._operationStart = null, this._timer = null, this._options.forever && (this._cachedTimeouts = this._timeouts.slice(0));
+}
+var pt = l;
+l.prototype.reset = function() {
+  this._attempts = 1, this._timeouts = this._originalTimeouts.slice(0);
+};
+l.prototype.stop = function() {
+  this._timeout && clearTimeout(this._timeout), this._timer && clearTimeout(this._timer), this._timeouts = [], this._cachedTimeouts = null;
+};
+l.prototype.retry = function(e) {
+  if (this._timeout && clearTimeout(this._timeout), !e)
+    return !1;
+  var n = (/* @__PURE__ */ new Date()).getTime();
+  if (e && n - this._operationStart >= this._maxRetryTime)
+    return this._errors.push(e), this._errors.unshift(new Error("RetryOperation timeout occurred")), !1;
+  this._errors.push(e);
+  var a = this._timeouts.shift();
+  if (a === void 0)
+    if (this._cachedTimeouts)
+      this._errors.splice(0, this._errors.length - 1), a = this._cachedTimeouts.slice(-1);
+    else
+      return !1;
+  var o = this;
+  return this._timer = setTimeout(function() {
+    o._attempts++, o._operationTimeoutCb && (o._timeout = setTimeout(function() {
+      o._operationTimeoutCb(o._attempts);
+    }, o._operationTimeout), o._options.unref && o._timeout.unref()), o._fn(o._attempts);
+  }, a), this._options.unref && this._timer.unref(), !0;
+};
+l.prototype.attempt = function(e, n) {
+  this._fn = e, n && (n.timeout && (this._operationTimeout = n.timeout), n.cb && (this._operationTimeoutCb = n.cb));
+  var a = this;
+  this._operationTimeoutCb && (this._timeout = setTimeout(function() {
+    a._operationTimeoutCb();
+  }, a._operationTimeout)), this._operationStart = (/* @__PURE__ */ new Date()).getTime(), this._fn(this._attempts);
+};
+l.prototype.try = function(e) {
+  this.attempt(e);
+};
+l.prototype.start = function(e) {
+  this.attempt(e);
+};
+l.prototype.start = l.prototype.try;
+l.prototype.errors = function() {
+  return this._errors;
+};
+l.prototype.attempts = function() {
+  return this._attempts;
+};
+l.prototype.mainError = function() {
+  if (this._errors.length === 0)
+    return null;
+  for (var e = {}, n = null, a = 0, o = 0; o < this._errors.length; o++) {
+    var s = this._errors[o], c = s.message, i = (e[c] || 0) + 1;
+    e[c] = i, i >= a && (n = s, a = i);
+  }
+  return n;
+};
+(function(e) {
+  var n = pt;
+  e.operation = function(a) {
+    var o = e.timeouts(a);
+    return new n(o, {
+      forever: a && (a.forever || a.retries === 1 / 0),
+      unref: a && a.unref,
+      maxRetryTime: a && a.maxRetryTime
+    });
+  }, e.timeouts = function(a) {
+    if (a instanceof Array)
+      return [].concat(a);
+    var o = {
+      retries: 10,
+      factor: 2,
+      minTimeout: 1 * 1e3,
+      maxTimeout: 1 / 0,
+      randomize: !1
+    };
+    for (var s in a)
+      o[s] = a[s];
+    if (o.minTimeout > o.maxTimeout)
+      throw new Error("minTimeout is greater than maxTimeout");
+    for (var c = [], i = 0; i < o.retries; i++)
+      c.push(this.createTimeout(i, o));
+    return a && a.forever && !c.length && c.push(this.createTimeout(i, o)), c.sort(function(p, h) {
+      return p - h;
+    }), c;
+  }, e.createTimeout = function(a, o) {
+    var s = o.randomize ? Math.random() + 1 : 1, c = Math.round(s * Math.max(o.minTimeout, 1) * Math.pow(o.factor, a));
+    return c = Math.min(c, o.maxTimeout), c;
+  }, e.wrap = function(a, o, s) {
+    if (o instanceof Array && (s = o, o = null), !s) {
+      s = [];
+      for (var c in a)
+        typeof a[c] == "function" && s.push(c);
+    }
+    for (var i = 0; i < s.length; i++) {
+      var p = s[i], h = a[p];
+      a[p] = (function(ot) {
+        var b = e.operation(o), y = Array.prototype.slice.call(arguments, 1), it = y.pop();
+        y.push(function(j) {
+          b.retry(j) || (j && (arguments[0] = b.mainError()), it.apply(this, arguments));
+        }), b.attempt(function() {
+          ot.apply(a, y);
+        });
+      }).bind(a, h), a[p].options = o;
+    }
+  };
+})(ut);
+var A;
+(function(e) {
+  e.NO_TOKEN_API_URL = "NO_TOKEN_API_URL is not defined", e.NO_TOKEN_PRICE_API_URL = "NO_TOKEN_PRICE_API_URL is not defined", e.TOKENS_DEFI_DECOMPOSITION_URL = "TOKENS_DEFI_DECOMPOSITION_URL is not defined", e.TOKENS_AIRDROPS_API_URL = "TOKENS_AIRDROPS_API_URL is not defined", e.TOKEN_PARSING_ERROR = "Unable to parse token data response", e.TOKEN_PRICE_PARSING_ERROR = "Unable to parse token price response", e.TOKEN_DEFI_DECOMPOSITION_PARSING_ERROR = "Unable to parse token defi decomposition response", e.TOKEN_PRICE_NOT_FOUND = "Token price not found", e.TOKEN_NOT_FOUND = "Token not found", e.TOKEN_DETAILS_NOT_FOUND = "Token details not found", e.FEE_TOKEN_NOT_FOUND = "Fee token not found", e.UNABLE_TO_CALCULATE_CURRENCY_VALUE = "Unable to calculate currency value", e.UNSAFE_DECIMALS = "Unsafe decimals in token";
+})(A || (A = {}));
+class _e extends E {
+  constructor(n) {
+    super(n, A), this.name = "TokenError";
+  }
+}
+const U = L.extend({
+  accruedFees: t.string(),
+  currentPrice: t.string(),
+  maxPrice: t.string(),
+  minPrice: t.string(),
+  principal: t.string()
+}), B = t.object({
+  address: u.optional(),
+  currencyValue: t.string().default("0")
+}), H = B.extend({
+  poolFeePercentage: t.string(),
+  tickSpacingPercentage: t.string().optional(),
+  tokenId: t.string().optional(),
+  unitCurrencyValueToken0: t.string().optional(),
+  unitCurrencyValueToken1: t.string().optional(),
+  token0: U,
+  token1: U
+}), Se = t.array(H), Te = t.object({
+  name: t.string().optional(),
+  healthRatio: t.string().optional(),
+  accountAddress: u.optional()
+}), M = B.extend({
+  totalBalances: t.record(t.string()),
+  collateral: t.boolean(),
+  debt: t.boolean(),
+  lending: t.boolean(),
+  apy: t.string().optional(),
+  group: t.string().optional(),
+  unitCurrencyValue: t.string().optional(),
+  positionToken: V.or(t.undefined()),
+  token: L.optional(),
+  accountAddress: u.optional(),
+  accountAddressGroup: t.string().optional()
+}), Ae = t.array(M), mt = H.or(M), dt = t.record(t.object({
+  name: t.string().optional(),
+  healthRatio: t.string().optional(),
+  accountAddress: u.optional()
+})), gt = t.object({
+  type: rt,
+  manageUrl: t.string().url().optional(),
+  name: t.string(),
+  positions: t.array(mt),
+  // other types will be added when available from be
+  positionsTotalValue: t.string(),
+  brandColor: t.string().optional(),
+  groups: dt.optional(),
+  accountAddress: u
+}), ft = t.array(gt), ve = t.object({
+  dappId: t.string(),
+  products: ft
+}), ht = t.object({
+  name: t.string().optional(),
+  tokenAddress: u,
+  token: V.optional(),
+  amount: t.string().optional(),
+  claimUrl: t.string().optional(),
+  claimStart: t.number(),
+  claimEnd: t.number().optional()
+}), Ie = t.array(ht), bt = (e, n = 18) => st(e.replace(",", "."), Number(n)), yt = t.string().trim().refine((e) => e !== "", {
+  message: "Amount is required"
+}).refine((e) => {
+  try {
+    const n = bt(e).value;
+    if (n < 0n)
+      throw new Error("Amount must be positive");
+    if (n === 0n)
+      throw new Error("Amount can not be zero");
+    if (n > S.UINT_256_MAX)
+      throw new Error("Amount is too big");
+  } catch {
+    throw new Error("Amount should be a number");
+  }
+  return !0;
+}, { message: "Invalid amount" }), Ee = (e) => !!yt.parse(e), _t = t.object({
+  data: t.object({
+    code: t.string().optional(),
+    // "STARKNAME_NOT_FOUND",
+    name: t.string().optional(),
+    // "AddressError"
+    message: t.string()
+    // "foo.stark not found"
+  })
+}), Ne = (e) => {
+  const n = _t.safeParse(e);
+  if (n.success)
+    return n.data.data.message;
+}, St = 3, K = process.env.FEE_OVERHEAD ? parseFloat(process.env.FEE_OVERHEAD) : St, Tt = 1.5, f = 10, At = ({ estimatedFee: e, overheadMultiplier: n = K }) => {
+  const o = d.toBigInt(e) * BigInt(n * f) / BigInt(f);
+  return d.toHex(o);
+}, ke = ({ suggestedMaxFee: e, overheadMultiplier: n = K, starknetJsOverheadMultiplier: a = Tt }) => {
+  const s = d.toBigInt(e) * BigInt(f) / BigInt(a * f);
+  return At({ estimatedFee: s, overheadMultiplier: n });
+};
+var v;
+(function(e) {
+  e.SIMULATE_AND_REVIEW_FAILED = "Missing simulation";
+})(v || (v = {}));
+class je extends E {
+  constructor(n) {
+    super(n, v), this.name = "EstimateError";
+  }
+}
+const we = t.object({
+  type: t.enum(["DECLARE", "DEPLOY", "DEPLOY_ACCOUNT", "INVOKE"]).default("INVOKE"),
+  calls: t.array(w).or(w).optional(),
+  calldata: t.array(t.string()).optional(),
+  classHash: D.optional(),
+  salt: D.optional(),
+  signature: t.array(t.string()).optional()
+}), vt = t.object({
+  amount: t.bigint(),
+  pricePerUnit: t.bigint()
+}).or(t.object({ maxFee: t.bigint() })), O = t.object({
+  feeTokenAddress: u,
+  amount: t.bigint(),
+  pricePerUnit: t.bigint(),
+  max: vt.optional(),
+  dataGasConsumed: t.bigint().optional(),
+  dataGasPrice: t.bigint().optional()
+}), It = t.object({
+  deployment: O.optional(),
+  transactions: O
+}), Et = t.union([
+  t.literal("critical"),
+  t.literal("high"),
+  t.literal("caution"),
+  t.literal("info")
+]), Nt = t.string(), kt = t.object({
+  name: t.string(),
+  url: t.string(),
+  position: t.number()
+}), _ = t.object({
+  address: t.string(),
+  name: t.string(),
+  symbol: t.string().optional(),
+  decimals: t.number().optional(),
+  unknown: t.boolean(),
+  iconUrl: t.string().optional(),
+  type: t.string()
+}), C = t.discriminatedUnion("type", [
+  t.object({
+    type: t.literal("amount"),
+    label: t.string(),
+    token: _,
+    amount: t.string(),
+    usd: t.string(),
+    editable: t.boolean()
+  }),
+  t.object({
+    type: t.literal("address"),
+    label: t.string(),
+    address: t.string(),
+    addressName: t.string().optional(),
+    // tbd whether it's isVerified or verified
+    verified: t.boolean().optional()
+  }),
+  t.object({
+    type: t.literal("timestamp"),
+    label: t.string(),
+    value: t.string()
+  }),
+  t.object({
+    type: t.literal("token_address"),
+    label: t.string(),
+    token: _
+  }),
+  t.object({
+    type: t.literal("calldata"),
+    label: t.string(),
+    entrypoint: t.string(),
+    calldata: t.array(t.string())
+  }),
+  t.object({
+    type: t.literal("text"),
+    label: t.string(),
+    text: t.string()
+  }),
+  t.object({
+    type: t.literal("nft"),
+    label: t.string(),
+    token: _
+  })
+]), z = t.object({
+  name: t.string(),
+  properties: t.array(C),
+  defaultProperties: t.array(C).optional()
+}), jt = t.union([
+  t.literal("verified"),
+  t.literal("neutral"),
+  t.literal("partial"),
+  t.literal("warn")
+]), wt = t.object({
+  unknown_token: t.unknown().optional(),
+  date_of_addition: t.string().optional(),
+  contract_address: u.optional(),
+  reason: t.string().optional(),
+  value: t.string().or(t.number()).optional()
+}), W = t.object({
+  reason: Nt,
+  details: wt.optional(),
+  severity: Et
+}), Dt = t.object({
+  assessment: jt,
+  warnings: t.array(W).optional(),
+  assessmentReasons: t.array(t.string()).optional(),
+  assessmentDetails: t.object({
+    contract_address: t.string()
+  }).optional(),
+  action: z
+}), q = t.object({
+  name: t.string(),
+  description: t.string(),
+  logoUrl: t.string(),
+  iconUrl: t.string(),
+  argentVerified: t.boolean(),
+  links: t.array(kt)
+}), G = t.object({
+  assessment: t.union([
+    t.literal("verified"),
+    t.literal("neutral"),
+    t.literal("partial"),
+    t.literal("warn")
+  ]),
+  warnings: t.array(W).optional(),
+  assessmentDetails: t.object({
+    contract_address: t.string()
+  }).optional(),
+  targetedDapp: q.optional(),
+  reviews: t.array(Dt)
+}).optional(), X = t.object({
+  banner: t.string().nullable().optional(),
+  preview: t.string().nullable().optional(),
+  full: t.string().nullable().optional(),
+  original: t.string().nullable().optional()
+}), Pt = t.object({
+  twitter: t.string().optional(),
+  external: t.string().optional(),
+  discord: t.string().optional()
+}), N = t.object({
+  address: r,
+  decimals: t.number().optional(),
+  symbol: t.string().optional(),
+  name: t.string(),
+  description: t.string().optional(),
+  type: t.string().optional(),
+  usdValue: t.string().optional(),
+  iconUrl: t.string().optional(),
+  unknown: t.boolean().optional(),
+  imageUrls: X.optional(),
+  links: Pt.optional()
+}), Ut = t.object({
+  tokenAddress: r,
+  owner: r,
+  spender: r,
+  value: t.string().optional(),
+  approvalForAll: t.boolean(),
+  details: N.optional()
+}), Ot = t.object({
+  tokenAddress: r,
+  from: r,
+  to: r,
+  tokenId: t.string().optional(),
+  value: t.string().optional(),
+  details: N.optional()
+}), m = t.union([t.string(), t.number(), t.bigint()]).transform((e) => parseInt(e.toString(), 10)), x = {
+  overallFee: m,
+  gasPrice: m,
+  gasUsage: m,
+  dataGasPrice: m.optional(),
+  dataGasConsumed: m.optional()
+}, Ct = t.object({
+  ...x,
+  unit: t.string().transform((e) => e.toUpperCase()).pipe(t.literal("WEI")),
+  maxFee: m
+}).or(t.object({
+  ...x,
+  unit: t.string().transform((e) => e.toUpperCase()).pipe(t.literal("FRI")),
+  maxAmount: m,
+  maxPricePerUnit: m
+})), xt = t.object({
+  type: t.string(),
+  label: t.string(),
+  tokenId: t.string().optional(),
+  value: t.string().optional(),
+  usdValue: t.string().optional(),
+  token: N,
+  sent: t.boolean().optional(),
+  tokenIdDetails: t.object({
+    name: t.string().optional(),
+    description: t.string().optional(),
+    imageUrls: X.optional()
+  }).optional()
+}), Ft = t.object({
+  approvals: t.array(Ut).optional(),
+  transfers: t.array(Ot).optional(),
+  calculatedNonce: t.string().optional(),
+  feeEstimation: Ct,
+  summary: t.array(xt).optional()
+}), Rt = t.object({
+  label: t.string().optional(),
+  code: t.number().optional(),
+  message: t.string().optional(),
+  error: t.string().optional()
+}), J = t.object({
+  reviewOfTransaction: G,
+  simulation: Ft,
+  simulationError: t.undefined()
+}), Y = t.object({
+  reviewOfTransaction: G,
+  simulation: t.undefined(),
+  simulationError: Rt
+}), Q = J.or(Y), De = t.object({
+  transactions: t.array(Q)
+}), Pe = t.object({
+  transactions: t.array(Q),
+  enrichedFeeEstimation: It.optional(),
+  isBackendDown: t.boolean().default(!1).optional()
+});
+function Ue(e) {
+  return J.safeParse(e).success;
+}
+function Oe(e) {
+  return Y.safeParse(e).success;
+}
+const $ = t.object({
+  network: t.string(),
+  hash: t.string(),
+  status: t.string(),
+  blockNumber: t.number().optional(),
+  transactionIndex: t.number()
+}), g = t.object({
+  type: t.enum(["token", "nft"]),
+  tokenAddress: r,
+  amount: t.string().optional(),
+  fiatAmount: t.object({
+    currency: t.string(),
+    currencyAmount: t.number()
+  }).optional().nullable()
+}), k = t.enum(["ethereum", "starknet", "zksync", "zksync2"]), Lt = t.object({
+  type: t.enum(["payment", "gasFee"]),
+  leg: t.enum(["credit", "debit"]),
+  asset: g,
+  counterParty: r.optional(),
+  counterPartyNetwork: k.optional()
+}), Vt = t.object({
+  address: r,
+  network: k,
+  type: t.enum(["wallet", "token"])
+}), Bt = t.object({
+  chainId: t.enum(["TESTNET", "MAINNET", "SEPOLIA"]),
+  ethereumNetwork: t.enum(["mainnet", "sepolia"])
+}), Ht = t.enum([
+  "approval",
+  "changePubKey",
+  "dappInteraction",
+  "deploy",
+  "gift",
+  "multicall",
+  "payment",
+  "security",
+  "trade"
+]), Z = t.enum([
+  "triggerEscapeGuardian",
+  "triggerEscapeSigner",
+  "escapeGuardian",
+  "escapeSigner",
+  "guardianChanged",
+  "guardianBackupChanged",
+  "signerChanged",
+  "cancelEscape",
+  "accountUpgraded",
+  "multisigConfigurationUpdated"
+]), Mt = t.object({
+  name: t.string(),
+  parameters: t.array(t.unknown()).optional()
+}), Kt = t.object({
+  guid: t.string().optional(),
+  signerType: t.string().optional(),
+  // StarknetKey, Secp256k1, Secp256r1, Eip191, Webauthn
+  signer: t.object({
+    publicKey: t.string().optional()
+  }).optional()
+}), zt = t.object({
+  activeAt: t.string().optional(),
+  newGuardian: t.string().optional(),
+  newImplementation: t.string().optional(),
+  newVersion: t.string().optional(),
+  signerGuid: t.string().optional(),
+  signers: t.array(Kt).optional()
+}), F = t.discriminatedUnion("type", [
+  t.object({
+    type: t.literal("deploy"),
+    deployer: r,
+    contractAddress: r
+  }),
+  t.object({
+    type: t.literal("approval"),
+    spender: r,
+    asset: g,
+    approvalType: t.string()
+  }),
+  t.object({
+    type: t.literal("payment"),
+    counterparty: r,
+    leg: t.string(),
+    asset: g,
+    counterpartyNetwork: k.optional()
+  }),
+  t.object({
+    type: t.literal("trade"),
+    srcAsset: g,
+    destAsset: g
+  }),
+  t.object({
+    type: t.literal("security"),
+    action: Z,
+    context: zt.optional()
+  }),
+  t.object({
+    type: t.literal("dappInteraction"),
+    dappAddress: r,
+    function: Mt.optional().nullable()
+    // This object is often null. It happens when we were unable to get the ABI or failed decoding the function call
+  })
+]), Wt = t.union([
+  F,
+  t.object({
+    type: t.literal("multicall"),
+    calls: t.array(t.object({
+      details: F
+    }))
+  })
+]), qt = t.object({
+  dappId: t.string(),
+  name: t.string().optional().nullable()
+}), tt = t.object({
+  sent: t.boolean(),
+  asset: t.discriminatedUnion("type", [
+    t.object({
+      type: t.literal("nft"),
+      tokenAddress: r,
+      tokenId: t.coerce.number().optional(),
+      amount: t.string().optional(),
+      collectionName: t.string().optional(),
+      collectionPreviewImage: t.string().optional().nullable(),
+      nftName: t.string().optional().nullable(),
+      nftPreviewImage: t.string().optional().nullable()
+    }),
+    t.object({
+      type: t.literal("token"),
+      tokenAddress: r,
+      amount: t.string().optional(),
+      fiatAmount: t.object({
+        currency: t.string(),
+        currencyAmount: t.coerce.string()
+      }).optional().nullable()
+    })
+  ])
+}), Gt = t.object({
+  type: t.string(),
+  // "gas" for example
+  to: r,
+  actualFee: t.object({
+    type: t.string(),
+    tokenAddress: r,
+    amount: t.string().optional(),
+    fiatAmount: t.object({
+      currency: t.string(),
+      currencyAmount: t.number()
+    }).optional().nullable()
+  })
+}), et = t.enum(["pending", "success", "failure"]), nt = t.object({
+  compositeId: t.string(),
+  id: t.string().uuid(),
+  status: et,
+  wallet: r,
+  txSender: r,
+  source: t.string(),
+  type: Ht,
+  group: t.enum(["finance", "security"]),
+  submitted: t.number(),
+  lastModified: t.number(),
+  transaction: $,
+  transfers: t.array(Lt),
+  // to be clarified
+  fees: t.array(Gt).optional(),
+  relatedAddresses: t.array(Vt).nullable(),
+  network: t.string(),
+  networkDetails: Bt.optional(),
+  details: Wt,
+  transferSummary: t.array(tt).optional(),
+  dapp: qt.optional(),
+  actions: t.array(z).optional(),
+  title: t.string().optional(),
+  multisigDetails: t.object({
+    signers: t.array(r)
+  }).optional()
+}), Xt = t.object({
+  title: t.string().optional(),
+  shortTitle: t.string().optional(),
+  subtitle: t.string().optional(),
+  /** let's not import the keys from x-ui here */
+  icon: t.string().optional()
+}), Jt = "native", Yt = "rejected", Qt = "cancelled", $t = "queued", Ce = nt.pick({
+  status: !0,
+  actions: !0,
+  submitted: !0,
+  lastModified: !0,
+  transferSummary: !0,
+  fees: !0,
+  multisigDetails: !0
+}).extend({
+  status: t.union([
+    et,
+    t.enum([
+      Yt,
+      Qt,
+      $t
+    ])
+  ]),
+  type: t.literal(Jt),
+  transaction: $.pick({
+    hash: !0
+  }),
+  dapp: q.optional(),
+  meta: Xt.optional()
+}), Zt = t.array(nt), xe = t.object({
+  activities: Zt,
+  page: t.number(),
+  pageSize: t.number(),
+  totalElements: t.number(),
+  totalPages: t.number()
+});
+function Fe(e) {
+  return Z.safeParse(e).success;
+}
+const at = (e) => tt.safeParse(e).success, Re = (e) => at(e) && e.asset.type === "token", Le = (e) => at(e) && e.asset.type === "nft", R = {
+  Transfer: P.getSelectorFromName("Transfer"),
+  // 0x99cd8bde557814842a3121e8ddfd433a539b8c9f14bf31ebf108d12e6196e9
+  Approval: P.getSelectorFromName("Approval")
+  // 0x134692b230b9e1ffa39098904722134159652b09c5bc41d88d6698779d228ff
+}, te = (e, n, a) => {
+  for (const o of e) {
+    const { events: s, internal_calls: c } = o;
+    for (const i of s)
+      for (const p of i.keys)
+        p === R.Approval && n.push({
+          tokenAddress: u.parse(o.contract_address),
+          owner: i.data[0],
+          spender: i.data[1],
+          value: S.uint256ToBN({ low: i.data[2], high: i.data[3] }).toString()
+        }), p === R.Transfer && a.push({
+          tokenAddress: u.parse(o.contract_address),
+          from: i.data[0],
+          to: i.data[1],
+          value: S.uint256ToBN({ low: i.data[2], high: i.data[3] }).toString()
+        });
+    c && te(c, n, a);
+  }
+  return { approvals: n, transfers: a };
+}, ee = /(0x[a-fA-F0-9]+)\s*\('(.*?)'\)/, Ve = (e) => {
+  if (!ct(e))
+    return;
+  const n = e.match(ee);
+  if (n && !lt(n[2]))
+    return n[2];
+};
+var I;
+(function(e) {
+  e.SIMULATE_AND_REVIEW_FAILED = "Something went wrong fetching review", e.NO_CALLS_FOUND = "No calls found", e.ONCHAIN_FEE_ESTIMATION_FAILED = "Failed to estimate fees onchain";
+})(I || (I = {}));
+class Be extends E {
+  constructor(n) {
+    super(n, I), this.name = "ReviewError";
+  }
+}
+const He = t.object({
+  reason: t.string(),
+  severity: t.string().optional(),
+  title: t.string(),
+  description: t.string().optional()
+}), ne = Object.values(T.TRANSACTION_VERSION), Me = t.string().default("0x3").refine((e) => {
+  const n = d.toBigInt(e);
+  return ne.map((a) => d.toBigInt(a)).includes(n);
+}).transform((e) => d.toHex(e));
+function Ke(e) {
+  if (e === T.TRANSACTION_VERSION.V3 || e === T.TRANSACTION_VERSION.F3)
+    throw Error("Only txv1 is supported");
+}
+export {
+  Yt as $,
+  Ee as A,
+  _t as B,
+  Ne as C,
+  ke as D,
+  me as E,
+  K as F,
+  v as G,
+  we as H,
+  R as I,
+  te as J,
+  Ve as K,
+  He as L,
+  Me as M,
+  Ke as N,
+  at as O,
+  tt as P,
+  Jt as Q,
+  Be as R,
+  ye as S,
+  _e as T,
+  Ce as U,
+  Lt as V,
+  Wt as W,
+  qt as X,
+  Gt as Y,
+  nt as Z,
+  Xt as _,
+  de as a,
+  Qt as a0,
+  $t as a1,
+  Zt as a2,
+  xe as a3,
+  Fe as a4,
+  Re as a5,
+  Le as a6,
+  O as a7,
+  It as a8,
+  C as a9,
+  z as aa,
+  jt as ab,
+  wt as ac,
+  W as ad,
+  Dt as ae,
+  q as af,
+  Pe as ag,
+  Ue as ah,
+  Et as ai,
+  Nt as aj,
+  je as b,
+  At as c,
+  ge as d,
+  fe as e,
+  Ct as f,
+  he as g,
+  be as h,
+  Oe as i,
+  A as j,
+  H as k,
+  Se as l,
+  Te as m,
+  M as n,
+  Ae as o,
+  mt as p,
+  dt as q,
+  ut as r,
+  De as s,
+  gt as t,
+  ft as u,
+  ve as v,
+  ht as w,
+  Ie as x,
+  bt as y,
+  yt as z
+};