@hinkal/common 0.0.113 → 0.0.115

package/common14.mjs

@@ -0,0 +1,32 @@
+import { chainIds as i } from "./common28.mjs";
+import "./common157.mjs";
+import "./common164.mjs";
+import "./common168.mjs";
+import "ethers";
+import "circomlibjs";
+import "./common51.mjs";
+import "axios";
+import "./common50.mjs";
+import "./common139.mjs";
+import "./common191.mjs";
+import "./common117.mjs";
+import "./common72.mjs";
+import "./common121.mjs";
+import "./common35.mjs";
+import { RELAYER_URLS as m, STAGING_RELAYER_URLS as p, PLAYGROUND_RELAYER_URLS as n } from "./common32.mjs";
+import { deploymentMode as o, DEPLOYMENT_MODE as e } from "./common33.mjs";
+import "./common129.mjs";
+import "./common42.mjs";
+import "./common31.mjs";
+import "./common77.mjs";
+import "libsodium-wrappers";
+import "./common30.mjs";
+import "./common36.mjs";
+import "./common41.mjs";
+const V = (r) => {
+  let t;
+  return o === e.DEVELOPMENT ? t = m : o === e.STAGING ? t = p : o === e.PLAYGROUND ? t = n : t = m, r === i.polygon ? t.polygon : r === i.arbMainnet ? t.arbMainnet : r === i.ethMainnet ? t.ethMainnet : r === i.bnbMainnet ? t.bnbMainnet : r === i.avalanche ? t.avalanche : r === i.optimism ? t.optimism : r === i.base ? t.base : r === i.blast ? t.blast : t.localhost;
+};
+export {
+  V as getRelayerURL
+};

package/common140.mjs

@@ -0,0 +1,9 @@
+const i = async (e, s, ...n) => {
+  if (!e.filters?.[s])
+    throw new Error("Contract Event not found");
+  return await e.queryFilter(e.filters?.[s](...n), 39561411);
+}, o = async (e, s) => (await i(e, "NewTransaction")).map((t) => t.args[1] === s && BigInt(t.args[2]) >= 0n ? new Date(t.args[0] * 1e3) : /* @__PURE__ */ new Date(0)).filter((t) => t.getTime() !== 0);
+export {
+  o as getDepositEvents,
+  i as retrieveEvents
+};

package/common141.mjs

@@ -0,0 +1,10 @@
+import "./common157.mjs";
+import { EventType as e } from "./common160.mjs";
+import "./common164.mjs";
+import "./common168.mjs";
+const p = () => {
+  document.dispatchEvent(new Event(e.BalanceChange));
+};
+export {
+  p as balanceChangedHandler
+};

package/common142.mjs

@@ -0,0 +1,97 @@
+import { utils as w } from "ethers";
+import { networkRegistry as p, getNonLocalhostChainId as A, chainIds as C } from "./common28.mjs";
+import "./common157.mjs";
+import { ContractType as d } from "./common158.mjs";
+import "./common164.mjs";
+import "./common168.mjs";
+import { getAmountInWei as g } from "./common137.mjs";
+import { zeroAddress as I } from "./common34.mjs";
+import "circomlibjs";
+import "./common51.mjs";
+import { transactionErrorCodes as l } from "./common81.mjs";
+import "axios";
+import "./common50.mjs";
+import "./common139.mjs";
+import "./common191.mjs";
+import "./common117.mjs";
+import "./common72.mjs";
+import "./common121.mjs";
+import "./common35.mjs";
+import { logError as h } from "./common84.mjs";
+import "./common129.mjs";
+import "./common42.mjs";
+import "./common31.mjs";
+import "./common77.mjs";
+import "libsodium-wrappers";
+import "./common33.mjs";
+import "./common30.mjs";
+import "./common36.mjs";
+import "./common41.mjs";
+const f = (r) => A(r) === C.blast, y = async (r, s, o, e) => {
+  const a = (await Promise.all(
+    [100, 500, 3e3, 1e4].map(async (t) => ({
+      poolAddress: await s.getPool(o, e, t),
+      fee: t
+    }))
+  )).filter(({ poolAddress: t }) => t !== I), n = await Promise.all(
+    a.map(async (t) => ({
+      poolAddress: t.poolAddress,
+      fee: t.fee,
+      token1Balance: (await r.balanceOf(t.poolAddress)).toBigInt()
+    }))
+  ), c = n.map((t) => t.token1Balance).reduce((t, m) => m >= t ? m : t, 0n);
+  if (c === 0n)
+    throw new Error(l.UNISWAP_NOT_ENOUGH_LIQUIDITY);
+  return n.find((t) => t.token1Balance === c);
+}, E = async (r, s, o, e, a) => {
+  try {
+    if (!p[r.getCurrentChainId()].quoterV2Address)
+      throw Error("No Quoter Contract Provided");
+    return (await r.getContractWithFetcher(
+      d.UniswapV3QuoterContract,
+      p[r.getCurrentChainId()].quoterV2Address
+    ).callStatic.quoteExactInputSingle({
+      tokenIn: s.wrappedErc20TokenAddress ?? s.erc20TokenAddress,
+      tokenOut: o.wrappedErc20TokenAddress ?? o.erc20TokenAddress,
+      fee: e,
+      amountIn: a,
+      sqrtPriceLimitX96: 0
+    })).amountOut.toBigInt();
+  } catch (n) {
+    throw h(n), n;
+  }
+}, P = async (r, s, o) => {
+  try {
+    const e = r.getCurrentChainId(), a = r.getContractWithFetcher(
+      d.UniswapV3FactoryContract,
+      p[e].uniswapV3FactoryAddress
+    ), n = r.getContractWithFetcher(
+      d.ERC20Contract,
+      o.wrappedErc20TokenAddress ?? o.erc20TokenAddress
+    ), { fee: i } = await y(
+      n,
+      a,
+      s.wrappedErc20TokenAddress ?? s.erc20TokenAddress,
+      o.wrappedErc20TokenAddress ?? o.erc20TokenAddress
+    );
+    return i;
+  } catch (e) {
+    throw console.log("Error in getUniswapFee", e), e;
+  }
+}, $ = async (r, s, o, e) => {
+  try {
+    const a = r.getCurrentChainId();
+    if (!f(a) && (o.isVolatile || e.isVolatile))
+      throw new Error("Volatile tokens are not supported by uniswap");
+    const n = await P(r, o, e), i = w.defaultAbiCoder.encode(["uint24"], [n]), c = g(o, s);
+    return { tokenPrice: await E(r, o, e, n, c), poolFee: i };
+  } catch (a) {
+    throw console.log({ error: a }), Error(l.NO_UNISWAP_PRICE);
+  }
+};
+export {
+  P as getUniswapFee,
+  $ as getUniswapPrice,
+  E as getUniswapPriceHelper,
+  y as searchPoolAndFee
+};

package/common143.mjs

@@ -0,0 +1,65 @@
+import { callOdosAPI as m } from "./common216.mjs";
+import { localhostNetwork as n, networkRegistry as d } from "./common28.mjs";
+import "./common157.mjs";
+import "./common164.mjs";
+import "./common168.mjs";
+import { getAmountInWei as a } from "./common137.mjs";
+import "ethers";
+import { zeroAddress as c } from "./common34.mjs";
+import "circomlibjs";
+import "./common51.mjs";
+import { transactionErrorCodes as u } from "./common81.mjs";
+import "axios";
+import "./common50.mjs";
+import "./common139.mjs";
+import "./common191.mjs";
+import "./common117.mjs";
+import "./common72.mjs";
+import "./common121.mjs";
+import "./common35.mjs";
+import "./common33.mjs";
+import "./common129.mjs";
+import "./common42.mjs";
+import "./common31.mjs";
+import "./common77.mjs";
+import "libsodium-wrappers";
+import "./common30.mjs";
+import "./common36.mjs";
+import "./common41.mjs";
+const q = async (r, t, e, i) => {
+  try {
+    const o = {
+      chainId: r.getCurrentChainId() !== 31337 ? r.getCurrentChainId() : n,
+      inputTokens: [
+        {
+          tokenAddress: t?.wrappedErc20TokenAddress ?? t.erc20TokenAddress,
+          amount: a(t, i).toString()
+        }
+      ],
+      outputTokens: [
+        {
+          tokenAddress: e?.wrappedErc20TokenAddress ?? e.erc20TokenAddress,
+          proportion: 1
+        }
+      ],
+      userAddr: d[r.getCurrentChainId()].contractData.odosExternalActionInstanceAddress || c,
+      slippageLimitPercent: 10,
+      disableRFQs: !0
+      // sometimes swap fails because of RFQs
+    }, { odosResponse: s, status: p } = await m(
+      r.getCurrentChainId(),
+      o
+    );
+    if (p !== "success")
+      throw Error("Odos API Fetch Error");
+    return {
+      outSwapAmountValue: BigInt(s.outputTokens[0].amount),
+      odosDataValue: s.transaction.data
+    };
+  } catch (o) {
+    throw console.log({ error: o }), Error(u.NO_ODOS_PRICE);
+  }
+};
+export {
+  q as getOdosPrice
+};

package/common144.mjs

@@ -0,0 +1,61 @@
+import { callOneInchAPI as p } from "./common4.mjs";
+import "./common28.mjs";
+import "./common157.mjs";
+import { ContractType as a } from "./common158.mjs";
+import "./common164.mjs";
+import "./common168.mjs";
+import { getAmountInWei as c } from "./common137.mjs";
+import "ethers";
+import { zeroAddress as e, oneInchZeroAddress as s } from "./common34.mjs";
+import "circomlibjs";
+import "./common51.mjs";
+import { transactionErrorCodes as d } from "./common81.mjs";
+import "axios";
+import "./common50.mjs";
+import "./common139.mjs";
+import "./common191.mjs";
+import "./common117.mjs";
+import "./common72.mjs";
+import "./common121.mjs";
+import "./common35.mjs";
+import "./common33.mjs";
+import "./common129.mjs";
+import "./common42.mjs";
+import "./common31.mjs";
+import "./common77.mjs";
+import "libsodium-wrappers";
+import "./common30.mjs";
+import "./common36.mjs";
+import "./common41.mjs";
+const W = async (i, t, m, n) => {
+  try {
+    const o = {
+      fromTokenAddress: t.erc20TokenAddress !== e ? t.erc20TokenAddress : s,
+      toTokenAddress: m.erc20TokenAddress !== e ? m.erc20TokenAddress : s,
+      fromAddress: e,
+      // we user zero address here because this paramater is not relevant to us, only destReceiver is
+      destReceiver: i.getContractMetadata(a.OneInchExternalActionContract).address,
+      amount: c(t, n),
+      slippage: 10,
+      disableEstimate: !0,
+      // disable gas estimation, we don't need it
+      // disable partial filling:
+      // if slippage tolerance isn't satisfied 1inch will try to swap less amount of input tokens
+      // and returning leftover tokens to fromAddress
+      // this is not what we want
+      allowPartialFill: !1
+    }, r = await p(i.getCurrentChainId(), o);
+    if (!r || !r.tx)
+      throw Error("OneInch API price fetch error");
+    return {
+      outSwapAmountValue: BigInt(r.toAmount),
+      oneInchDataValue: r.tx.data
+      // calldata to use
+    };
+  } catch (o) {
+    throw console.log({ error: o }), Error(d.NO_ONEINCH_PRICE);
+  }
+};
+export {
+  W as getOneInchPrice
+};

package/common145.mjs

@@ -0,0 +1,95 @@
+import { UserFriendlyErrorCodes as g, transactionErrorCodes as u } from "./common81.mjs";
+import "ethers";
+import { getErrorMessage as l } from "./common82.mjs";
+import "axios";
+import "./common28.mjs";
+import "./common157.mjs";
+import "./common164.mjs";
+import "./common168.mjs";
+import "circomlibjs";
+import "./common51.mjs";
+import "./common50.mjs";
+import "./common139.mjs";
+import "./common191.mjs";
+import "./common117.mjs";
+import "./common72.mjs";
+import "./common121.mjs";
+import "./common35.mjs";
+import "./common33.mjs";
+import "./common129.mjs";
+import "./common42.mjs";
+import "./common31.mjs";
+import "./common77.mjs";
+import "libsodium-wrappers";
+import "./common30.mjs";
+import "./common36.mjs";
+import "./common41.mjs";
+const T = 5e4, w = 1, P = 11, d = 15, m = async (e, i) => {
+  try {
+    const t = await e.getFeeData(), a = i === 0 ? P : d, r = t.gasPrice?.mul(a).div(10) ?? void 0;
+    return console.log("getGasPrice , ", r?.toBigInt(), { gasPremiumType: i }), r;
+  } catch (t) {
+    console.log("getGasPrice error: ", { err: t });
+    return;
+  }
+}, E = (e, i, t) => new Promise((a, r) => {
+  const s = setTimeout(() => {
+    r(new Error(u.TRANSACTION_TIMEOUT));
+  }, t);
+  e.wait(i).then((o) => {
+    clearTimeout(s), a(o);
+  }).catch((o) => {
+    clearTimeout(s), r(o);
+  });
+}), p = async ({
+  contractFunction: e,
+  args: i,
+  gasPrice: t,
+  gasLimit: a,
+  nonce: r,
+  confirmations: s,
+  waitTime: o
+}) => {
+  const n = await e(...i, {
+    type: 0,
+    gasLimit: a,
+    gasPrice: t,
+    nonce: r
+  });
+  return console.log("runTransaction: ", n?.hash), await E(
+    n,
+    s ?? w,
+    o ?? T
+  );
+}, K = async ({
+  provider: e,
+  contractFunction: i,
+  args: t,
+  gasLimit: a,
+  nonce: r,
+  confirmations: s
+}) => {
+  try {
+    const o = await m(
+      e,
+      0
+      /* Initial */
+    );
+    return await p({ contractFunction: i, args: t, gasPrice: o, gasLimit: a, nonce: r, confirmations: s });
+  } catch (o) {
+    const n = l(o);
+    if (n === g.MAX_FEE_GAS_ERROR || n === u.TRANSACTION_TIMEOUT) {
+      console.log("Timeout Hit: Increase gas");
+      const c = await m(
+        e,
+        1
+        /* Secondary */
+      );
+      return await p({ contractFunction: i, args: t, gasPrice: c, gasLimit: a, nonce: r, confirmations: s });
+    }
+    throw o;
+  }
+};
+export {
+  K as runContractFunction
+};

package/common146.mjs

@@ -0,0 +1,129 @@
+import { chainIds as J } from "./common28.mjs";
+import "./common157.mjs";
+import "./common164.mjs";
+import "./common168.mjs";
+import { HinkalStakeMode as c } from "./common169.mjs";
+import { randomBigInt as V } from "./common137.mjs";
+import { Utxo as j } from "./common71.mjs";
+import "axios";
+import "ethers";
+import "./common51.mjs";
+import "./common50.mjs";
+import { zeroAddress as q } from "./common34.mjs";
+import "./common139.mjs";
+import { performTaskWithWorker as s } from "./common208.mjs";
+import { WorkerVariant as l } from "./common209.mjs";
+import { ZKProofWorkerActionType as S } from "./common236.mjs";
+import { calcAmountChanges as F, calcEncryptedOutputs as Q, buildOutCommitments as X, calcPublicSignalCount as Y, createCallDataHash as $, calcStealthAddressStructure as U } from "./common148.mjs";
+import { generateCircomData as x } from "./common237.mjs";
+import { generateZkProof as oo } from "./common149.mjs";
+import "circomlibjs";
+import "./common117.mjs";
+import "./common72.mjs";
+import "./common121.mjs";
+import "./common35.mjs";
+import "./common33.mjs";
+import "./common129.mjs";
+import "./common42.mjs";
+import "./common31.mjs";
+import "./common77.mjs";
+import "libsodium-wrappers";
+import "./common30.mjs";
+import "./common36.mjs";
+import "./common41.mjs";
+const Lo = async (f, g, e, a, h, u, k, C, I, T = q, R = J.localhost, r = e.map(() => !1), y = e.map(() => 0n), b = void 0, m) => {
+  const N = f.getRootHash(), P = g.getRootHash(), D = e.map((o) => o.map((i) => i.getConstructableParams())), _ = h.getSignature(), { accessTokenSiblings: B, accessTokenSiblingSides: E } = await s({
+    type: l.ZKProof,
+    payload: {
+      type: S.CALC_ACCESS_TOKEN_SIBLING_AND_SIDES,
+      data: {
+        userSignature: _,
+        merkleTreeAccessTokenSerialized: g.toJSON()
+      }
+    }
+  }), { inCommitmentSiblings: K, inCommitmentSiblingSides: L } = await s({
+    type: l.ZKProof,
+    payload: {
+      type: S.CALC_COMMITMENTS_SIBLING_AND_SIDES,
+      data: { inputUtxosSerialized: D, userSignature: _, merkleTreeSerialized: f.toJSON() }
+    }
+  }), O = F(e, a), d = Q(
+    a,
+    (m && m.mode !== c.Deposit) ?? !1
+  ), p = h.getShieldedPrivateKey(), H = j.findCorrectRandomization(V(31), p), Z = await s({
+    type: l.ZKProof,
+    payload: {
+      type: S.BUILD_IN_NULLIFIERS,
+      data: { inputUtxosSerialized: D, onChainCreation: r }
+    }
+  }), t = {
+    rootHashHinkal: N,
+    shieldedPrivateKey: p,
+    erc20TokenAddresses: e.map((o) => o[0].erc20TokenAddress),
+    inAmounts: e.map((o) => o.map((i) => i.amount.toString())),
+    inTimeStamps: e.map((o) => o.map((i) => i.timeStamp)),
+    inRandomizations: e.map((o) => o.map((i) => i.randomization)),
+    inNullifiers: Z,
+    inCommitmentSiblings: K,
+    inCommitmentSiblingSides: L,
+    outAmounts: a.map((o) => o.map((i) => i.amount.toString())),
+    outTimeStamp: BigInt(a[0][0].timeStamp),
+    outPublicKeys: a.map((o) => o.map((i) => i.getStealthAddress())),
+    extraRandomization: H,
+    amountChanges: O,
+    outCommitments: X(a, r),
+    rootHashAccessToken: P,
+    accessTokenSiblings: B,
+    accessTokenSiblingSides: E,
+    calldataHash: 0n
+  };
+  m || (t.onChainCreation = r);
+  const n = e.map((o) => o[0].tokenId ?? 0), z = n.reduce((o, i) => o + i, 0) > 0 ? n.length : 0;
+  z > 0 && (t.tokenIds = n);
+  const A = Y(
+    u,
+    t.erc20TokenAddresses,
+    t.amountChanges,
+    t.inNullifiers,
+    t.outCommitments,
+    z
+  );
+  t.calldataHash = $(
+    A,
+    T,
+    C,
+    k,
+    I,
+    d,
+    y,
+    b
+  ), m && (m.mode === c.Deposit && (t.mode = 0), m.mode === c.Stake && (t.mode = 1), m.mode === c.Unstake && (t.mode = 2), t.stakedTokenRecipient = m.stakedTokenRecipient, t.stakeBlinding = m.stakeBlinding, t.depositorAddress = m.depositorAddress);
+  const { zkCallData: w, publicSignals: W } = await oo(R, u, t);
+  console.log("publicSignals", W);
+  const v = U(H, p), M = await x(
+    N,
+    P,
+    e,
+    a,
+    d,
+    y,
+    A,
+    k,
+    C,
+    I,
+    T,
+    t.calldataHash,
+    n,
+    v,
+    r,
+    b
+  ), G = {
+    tokenNumber: e.length,
+    nullifierAmount: e[0].length,
+    outputAmount: a[0].length
+  };
+  return { zkCallData: w, circomData: M, dimData: G, encryptedOutputs: d };
+};
+export {
+  Lo as constructZkProof
+};

package/common147.mjs

@@ -0,0 +1,105 @@
+import { Utxo as $ } from "./common71.mjs";
+import { zeroAddress as V } from "./common34.mjs";
+import { chainIds as j } from "./common28.mjs";
+import { ZKProofWorkerActionType as d } from "./common236.mjs";
+import { performTaskWithWorker as p } from "./common208.mjs";
+import { WorkerVariant as S } from "./common209.mjs";
+import { calcAmountChanges as q, calcEncryptedOutputs as F, buildOutCommitments as Q, calcPublicSignalCount as X, createCallDataHash as Y, calcStealthAddressStructure as x } from "./common148.mjs";
+import { randomBigInt as U } from "./common137.mjs";
+import { encodeEmporiumMetadata as tt } from "./common154.mjs";
+import { ExternalActionId as at } from "./common159.mjs";
+import { defaultHookData as et } from "./common157.mjs";
+import { generateCircomData as ot } from "./common237.mjs";
+import { generateZkProof as rt } from "./common149.mjs";
+const It = async (f, g, a, e, n, _, b, H, z, A = V, v = j.localhost, m = a.map(() => !1), h = a.map(() => 0n), i, mt, nt) => {
+  const u = f.getRootHash(), k = g.getRootHash(), I = a.map((t) => t.map((r) => r.getConstructableParams())), C = n.getSignature(), { accessTokenSiblings: L, accessTokenSiblingSides: O } = await p({
+    type: S.ZKProof,
+    payload: {
+      type: d.CALC_ACCESS_TOKEN_SIBLING_AND_SIDES,
+      data: {
+        userSignature: C,
+        merkleTreeAccessTokenSerialized: g.toJSON()
+      }
+    }
+  }), { inCommitmentSiblings: W, inCommitmentSiblingSides: K } = await p({
+    type: S.ZKProof,
+    payload: {
+      type: d.CALC_COMMITMENTS_SIBLING_AND_SIDES,
+      data: { inputUtxosSerialized: I, userSignature: C, merkleTreeSerialized: f.toJSON() }
+    }
+  }), M = q(a, e), l = F(e, !1), s = n.getShieldedPrivateKey(), y = $.findCorrectRandomization(U(31), s), R = await p({
+    type: S.ZKProof,
+    payload: {
+      type: d.BUILD_IN_NULLIFIERS,
+      data: { inputUtxosSerialized: I, onChainCreation: m }
+    }
+  }), c = a.map((t) => t[0].tokenId ?? 0), o = {
+    rootHashHinkal: u,
+    erc20TokenAddresses: a.map((t) => t[0].erc20TokenAddress),
+    tokenIds: c,
+    inNullifiers: R,
+    outTimeStamp: BigInt(e[0][0].timeStamp),
+    extraRandomization: y,
+    amountChanges: M,
+    outCommitments: Q(e, m).map((t) => t[0]),
+    rootHashAccessToken: k,
+    calldataHash: 0n,
+    shieldedPrivateKey: s,
+    hinkalWalletNonce: i ?? 0n,
+    accessTokenSiblings: L,
+    accessTokenSiblingSides: O,
+    onChainCreation: m,
+    outAmounts: e.map((t) => t[0].amount),
+    outPublicKeys: e.map((t) => t[0].getStealthAddress()),
+    inAmounts: a.map((t) => t.map((r) => r.amount.toString())),
+    inTimeStamps: a.map((t) => t.map((r) => r.timeStamp)),
+    inRandomizations: a.map((t) => t.map((r) => r.randomization)),
+    inCommitmentSiblings: W,
+    inCommitmentSiblingSides: K
+  }, w = i ? n.getWalletSalt(i) : void 0;
+  let N = H, T = at.Emporium, D = tt(z, w);
+  const E = `swapperMW${_}x${b}`, P = X(
+    E,
+    o.erc20TokenAddresses,
+    o.amountChanges,
+    o.inNullifiers,
+    o.outCommitments,
+    c.length
+  );
+  o.calldataHash = Y(
+    P,
+    A,
+    N,
+    T,
+    D,
+    l,
+    h,
+    void 0
+  );
+  const { zkCallData: B } = await rt(v, E, o), Z = x(y, s), G = await ot(
+    u,
+    k,
+    a,
+    e,
+    l,
+    h,
+    P,
+    T,
+    N,
+    D,
+    A,
+    o.calldataHash,
+    c,
+    Z,
+    m,
+    et
+  ), J = {
+    tokenNumber: a.length,
+    nullifierAmount: a[0].length,
+    outputAmount: e[0].length
+  };
+  return { zkCallData: B, circomData: G, dimData: J, encryptedOutputs: l };
+};
+export {
+  It as constructEmporiumProof
+};