@hinkal/common 0.2.9 → 0.2.11

package/functions/utils/index.d.mts

@@ -0,0 +1,21 @@
+export * from './amounts.utils';
+export * from './cacheFunctions';
+export * from './create-provider';
+export * from './external-action.utils';
+export * from './erc20tokenFunctions';
+export * from './requireEnv';
+export * from './resolve-sync.utils';
+export * from './convertIntegrationProviderToExternalActionId';
+export * from '../pre-transaction';
+export * from './evmNetworkFunctions';
+export * from './axelar.utils';
+export * from './userAgent';
+export * from './getDataFromTransaction';
+export * from './reloadPage';
+export * from './string.utils';
+export * from './nickname.utils';
+export * from './caseInsensitive.utils';
+export * from './time.utils';
+export * from './volatile-patcher.utils';
+export * from './cacheDevice.utils';
+export * from './process.utils';

package/functions/utils/memoize.utils.d.mts

@@ -0,0 +1 @@
+export declare const memoizeFunc: <T extends any[], R>(fn: (...args: T) => R) => (...args: T) => R;

package/functions/utils/nickname.utils.d.mts

@@ -0,0 +1 @@
+export declare const isNicknameValid: (input: string) => boolean;

package/functions/utils/process.utils.d.mts

@@ -0,0 +1,7 @@
+/** pause execution for a number of miliseconds */
+export declare const wait: (miliseconds: number) => Promise<unknown>;
+/** only call function once with a given number of milliseconds
+ * Ex: let debounceMyFunc = debounce(myFunc, 1000);
+ * debounceMyFunc(); debounceMyFunc();
+ */
+export declare function debounce(func: (...args: any[]) => void, debounceForMs: number): (...args: any[]) => void;

package/functions/utils/reloadPage.d.mts

@@ -0,0 +1 @@
+export declare const reloadPage: () => void;

package/functions/utils/requireEnv.d.mts

@@ -0,0 +1 @@
+export declare const requireEnv: (environmentVariableName: string) => string;

package/functions/utils/resolve-sync.utils.d.mts

@@ -0,0 +1,6 @@
+export declare const resolveSync: (promiseFns: (() => Promise<any>)[]) => Promise<void>;
+export declare const getSequence: (fromBlockNumber: number, lastBlockNumber: number, maxPageSize: number | undefined) => {
+    from: number;
+    to: number;
+}[];
+export declare const promisify: (callback: () => Promise<any>, timeout?: number) => Promise<unknown>;

package/functions/utils/serialize.utils.d.mts

@@ -0,0 +1 @@
+export declare const CustomJSONStringify: (args: any) => string;

package/functions/utils/string.utils.d.mts

@@ -0,0 +1,8 @@
+/** Capitalize the first letter of each word
+ * "This is an example" => "This Is An Example"
+ */
+export declare function toTitleCase(str: string): string;
+/** Capitalize the first letter of a string */
+export declare function capitalizeFirstLetter(str: string): string;
+/** Returns true if a value is null, undefined, or an empty object, array (length 0), or string (e.g. '') */
+export declare function isNullOrEmpty(obj: unknown): boolean;

package/functions/utils/time.utils.d.mts

@@ -0,0 +1 @@
+export declare const waitLittle: (time?: number) => Promise<unknown>;

package/functions/utils/userAgent.d.mts

@@ -0,0 +1,2 @@
+export declare const browserSupported: () => boolean;
+export declare const walletSupported: (provider: any) => boolean;

package/functions/utils/volatile-patcher.utils.d.mts

@@ -0,0 +1 @@
+export declare const patchRegistry: (chainId: number) => Promise<void>;

package/functions/web3/etherFunctions.d.mts

@@ -0,0 +1,20 @@
+import { ERC20Token } from '../../types/token.types';
+export declare const ethToWei: (amount: string) => bigint;
+export declare const randomBigInt: (numberfOfBytes: number) => bigint;
+export declare const getAmountInToken: (token: ERC20Token, amount: bigint) => string;
+export declare const getAmountInWei: (token: ERC20Token, amount: string) => bigint;
+/**
+ * Convert a decimal number into bigint through string method and return a bigint and number of decimal places.
+ * @param decimal
+ * @returns a tuple of [ theBigInt, numberOfDecimalPlaces]
+ */
+export declare const toBigIntWithDecimals: (decimal: number) => [bigint, number];
+/** Return getAmountInWei or 0 if error */
+export declare const getAmountInWeiOrZero: (token: ERC20Token, amount: string) => bigint;
+export declare const getAmountWithPrecision: (balance: bigint, token: ERC20Token, precision: number) => string;
+export declare const calculateDollarValue: (token: ERC20Token, tokenAmount: bigint, tokenPriceDollar: number, precision: number) => {
+    totalValueDollarsBigInt: bigint;
+    precision: number;
+};
+/** Returns same as getAmountWithPrecision but '0' if empty */
+export declare const getAmountWithPrecisionOrZero: (token: ERC20Token | undefined, amount: bigint | undefined) => string;

package/functions/web3/events/balanceChangedHandler.d.mts

@@ -0,0 +1 @@
+export declare const balanceChangedHandler: () => void;

package/functions/web3/events/getInputUtxoAndBalance.d.mts

@@ -0,0 +1,24 @@
+import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
+import { UserKeys } from '../../../data-structures/crypto-keys/keys';
+import { Utxo } from '../../../data-structures/utxo/Utxo';
+import { EncryptedOutputWithSign } from '../../../types/commitments.types';
+interface IGetInputUtxos {
+    hinkal: IHinkal;
+    erc20TokenAddress?: string;
+    minInput?: number;
+    sliceIfMore6?: boolean;
+    tokenId?: number;
+}
+export declare const getInputUtxosFromEncryptedOutputs: (hinkal: IHinkal, encryptedOutputs: EncryptedOutputWithSign[], userKeys: UserKeys, erc20TokenAddress?: string, tokenId?: number) => Promise<Utxo[]>;
+/**
+ *
+ * @param hinkal instance of the hinkal class
+ * @param erc20TokenAddress erc20 token address
+ * @param minInput min number of input UTXOs
+ * @param sliceIfMore6 max upper bound on input UTXOs controller
+ * @returns UTXOs for particular erc20 token address
+ */
+export declare const getInputUtxoAndBalance: ({ hinkal, erc20TokenAddress, minInput, sliceIfMore6, tokenId, }: IGetInputUtxos) => Promise<{
+    inputUtxos: Utxo[];
+}>;
+export {};

package/functions/web3/events/getShieldedBalance.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const A=require("async-mutex"),q=require("../../../constants/token-data/ERC20Registry.cjs"),I=require("../../utils/erc20tokenFunctions.cjs"),p=require("../../utils/caseInsensitive.utils.cjs"),k=require("../../utils/volatile-patcher.utils.cjs"),U=require("../../../data-structures/utxo/Utxo.cjs"),w=require("../../../data-structures/custom-token-registry/CustomTokenRegistry.cjs"),x=require("../../../data-structures/volatile-helper/VolatileHelper.cjs"),P=require("../etherFunctions.cjs"),S=require("../../../error-handling/customErrors/ErrorWithAmount.cjs"),y=require("./getInputUtxoAndBalance.cjs"),b=new A.Mutex,v=async i=>{const r=await b.acquire(),{inputUtxos:a}=await y.getInputUtxoAndBalance({hinkal:i,sliceIfMore6:!1}),n=i.getCurrentChainId(),u=[...q.getERC20Registry(n),...w.customTokenRegistry.getCustomTokens(n)];await k.patchRegistry(n);const h=u.map(e=>({token:e,balance:a.reduce((t,c)=>{const s=e.isVolatile?e.sharedAddress:e.erc20TokenAddress;return p.caseInsensitiveEqual(s,c.erc20TokenAddress)?t+c.amount:t},0n),timestamp:a.filter(t=>p.caseInsensitiveEqual(t.erc20TokenAddress,e.erc20TokenAddress))[0]?.timeStamp,nfts:a.filter(t=>p.caseInsensitiveEqual(t.erc20TokenAddress,e.erc20TokenAddress)&&t.tokenId!==0).map(t=>({tokenId:t.tokenId,timestamp:t.timeStamp}))})),m=await Promise.all(h.map(async e=>{if(!e.token.isVolatile)return e;e.token?.sharedAddress||console.log("VolatileToken must have a corresponding sharedAddress");let t=0n;return e.balance>0n&&(t=await x.VolatileHelper.getVolatileTokenBalance(n,e.token.sharedAddress,e.balance)),{...e,balance:BigInt(t)}}));return r(),m},E=async(i,r,a,n=6,u=r.map(()=>0),h=!1)=>{const{userKeys:m}=i,e=[],t=[];let c=0;for(let s=0;s<r.length;s+=1)if(h===!1){const{inputUtxos:o}=await y.getInputUtxoAndBalance({hinkal:i,erc20TokenAddress:r[s],tokenId:u[s],sliceIfMore6:!1});c=Math.max(o.length,c),t.push(o)}else t.push([]);return c===2?t:(t.forEach((s,o)=>{if(s.length>n){const d=s.slice(0,n),l=d.reduce((g,f)=>g+f.amount,0n);if(a[o]<0n&&l<-a[o]){const g=I.getERC20Token(r[o],i.getCurrentChainId()),f=Number(P.getAmountWithPrecision(l,g,2)),T=`Unfortunately your transaction did not go through due to UTXOs limitations. 
- Please try again with ${g.symbol}`;throw new S.ErrorWithAmount(f,T)}e.push(d)}else if(s.length<=n){const d=[...s];let l=n-s.length;for(;l>0;)l-=1,d.push(new U.Utxo({amount:0n,erc20TokenAddress:r[o],shieldedPrivateKey:m.getShieldedPrivateKey(),tokenId:u[o]}));e.push(d)}}),e)};exports.addPaddingToUtxos=E;exports.getShieldedBalance=v;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const A=require("async-mutex"),q=require("../../../constants/token-data/ERC20Registry.cjs"),I=require("../../utils/erc20tokenFunctions.cjs"),f=require("../../utils/caseInsensitive.utils.cjs"),k=require("../../utils/volatile-patcher.utils.cjs"),w=require("../../../data-structures/utxo/Utxo.cjs"),U=require("../../../data-structures/custom-token-registry/CustomTokenRegistry.cjs"),x=require("../../../data-structures/volatile-helper/VolatileHelper.cjs"),P=require("../etherFunctions.cjs"),b=require("../../../error-handling/customErrors/ErrorWithAmount.cjs"),y=require("./getInputUtxoAndBalance.cjs"),E=new A.Mutex,S=async a=>{const i=await E.acquire();try{const{inputUtxos:r}=await y.getInputUtxoAndBalance({hinkal:a,sliceIfMore6:!1}),s=a.getCurrentChainId(),u=[...q.getERC20Registry(s),...U.customTokenRegistry.getCustomTokens(s)];await k.patchRegistry(s);const h=u.map(e=>({token:e,balance:r.reduce((t,c)=>{const n=e.isVolatile?e.sharedAddress:e.erc20TokenAddress;return f.caseInsensitiveEqual(n,c.erc20TokenAddress)?t+c.amount:t},0n),timestamp:r.filter(t=>f.caseInsensitiveEqual(t.erc20TokenAddress,e.erc20TokenAddress))[0]?.timeStamp,nfts:r.filter(t=>f.caseInsensitiveEqual(t.erc20TokenAddress,e.erc20TokenAddress)&&t.tokenId!==0).map(t=>({tokenId:t.tokenId,timestamp:t.timeStamp}))}));return await Promise.all(h.map(async e=>{if(!e.token.isVolatile)return e;e.token?.sharedAddress||console.log("VolatileToken must have a corresponding sharedAddress");let t=0n;return e.balance>0n&&(t=await x.VolatileHelper.getVolatileTokenBalance(s,e.token.sharedAddress,e.balance)),{...e,balance:BigInt(t)}}))}catch(r){console.log("Error while processing shielded balance:",r)}finally{i()}return[]},v=async(a,i,r,s=6,u=i.map(()=>0),h=!1)=>{const{userKeys:p}=a,e=[],t=[];let c=0;for(let n=0;n<i.length;n+=1)if(h===!1){const{inputUtxos:o}=await y.getInputUtxoAndBalance({hinkal:a,erc20TokenAddress:i[n],tokenId:u[n],sliceIfMore6:!1});c=Math.max(o.length,c),t.push(o)}else t.push([]);return c===2?t:(t.forEach((n,o)=>{if(n.length>s){const l=n.slice(0,s),d=l.reduce((g,m)=>g+m.amount,0n);if(r[o]<0n&&d<-r[o]){const g=I.getERC20Token(i[o],a.getCurrentChainId()),m=Number(P.getAmountWithPrecision(d,g,2)),T=`Unfortunately your transaction did not go through due to UTXOs limitations. 
+ Please try again with ${g.symbol}`;throw new b.ErrorWithAmount(m,T)}e.push(l)}else if(n.length<=s){const l=[...n];let d=s-n.length;for(;d>0;)d-=1,l.push(new w.Utxo({amount:0n,erc20TokenAddress:i[o],shieldedPrivateKey:p.getShieldedPrivateKey(),tokenId:u[o]}));e.push(l)}}),e)};exports.addPaddingToUtxos=v;exports.getShieldedBalance=S;

package/functions/web3/events/getShieldedBalance.d.mts

@@ -0,0 +1,18 @@
+import { TokenBalance } from '../../../types/token.types';
+import { Utxo } from '../../../data-structures/utxo/Utxo';
+import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
+/**
+ *
+ * @param UserKeys to access user's encryption keys
+ * @returns shielded balance
+ */
+export declare const getShieldedBalance: (hinkal: IHinkal) => Promise<TokenBalance[]>;
+/**
+ *
+ * @param hinkal hinkal instance to get userKeys
+ * @param erc20Addresses array of erc20 tokens
+ * @param amountChanges array of token amounts
+ * @param maxInput to pad until maxInput number
+ * @returns return padded UTXOs for every erc20 token
+ */
+export declare const addPaddingToUtxos: (hinkal: IHinkal, erc20Addresses: string[], amountChanges: bigint[], maxInput?: number, tokenIds?: number[], forceEmptyUtxos?: boolean) => Promise<Utxo[][]>;

package/functions/web3/events/getShieldedBalance.mjs

@@ -1,82 +1,90 @@
 import { Mutex as A } from "async-mutex";
 import { getERC20Registry as w } from "../../../constants/token-data/ERC20Registry.mjs";
 import { getERC20Token as k } from "../../utils/erc20tokenFunctions.mjs";
-import { caseInsensitiveEqual as g } from "../../utils/caseInsensitive.utils.mjs";
+import { caseInsensitiveEqual as u } from "../../utils/caseInsensitive.utils.mjs";
 import { patchRegistry as I } from "../../utils/volatile-patcher.utils.mjs";
 import { Utxo as U } from "../../../data-structures/utxo/Utxo.mjs";
-import { customTokenRegistry as P } from "../../../data-structures/custom-token-registry/CustomTokenRegistry.mjs";
-import { VolatileHelper as b } from "../../../data-structures/volatile-helper/VolatileHelper.mjs";
+import { customTokenRegistry as b } from "../../../data-structures/custom-token-registry/CustomTokenRegistry.mjs";
+import { VolatileHelper as P } from "../../../data-structures/volatile-helper/VolatileHelper.mjs";
 import { getAmountWithPrecision as x } from "../etherFunctions.mjs";
 import { ErrorWithAmount as S } from "../../../error-handling/customErrors/ErrorWithAmount.mjs";
-import { getInputUtxoAndBalance as T } from "./getInputUtxoAndBalance.mjs";
+import { getInputUtxoAndBalance as y } from "./getInputUtxoAndBalance.mjs";
 const C = new A(), O = async (i) => {
-  const n = await C.acquire(), { inputUtxos: a } = await T({ hinkal: i, sliceIfMore6: !1 }), s = i.getCurrentChainId(), c = [...w(s), ...P.getCustomTokens(s)];
-  await I(s);
-  const p = c.map((e) => ({
-    token: e,
-    balance: a.reduce((t, d) => {
-      const o = e.isVolatile ? e.sharedAddress : e.erc20TokenAddress;
-      return g(o, d.erc20TokenAddress) ? t + d.amount : t;
-    }, 0n),
-    timestamp: a.filter(
-      (t) => g(t.erc20TokenAddress, e.erc20TokenAddress)
-    )[0]?.timeStamp,
-    nfts: a.filter(
-      (t) => g(t.erc20TokenAddress, e.erc20TokenAddress) && t.tokenId !== 0
-    ).map((t) => ({ tokenId: t.tokenId, timestamp: t.timeStamp }))
-  })), u = await Promise.all(
-    p.map(async (e) => {
-      if (!e.token.isVolatile)
-        return e;
-      e.token?.sharedAddress || console.log("VolatileToken must have a corresponding sharedAddress");
-      let t = 0n;
-      return e.balance > 0n && (t = await b.getVolatileTokenBalance(
-        s,
-        e.token.sharedAddress,
-        e.balance
-      )), {
-        ...e,
-        balance: BigInt(t)
-      };
-    })
-  );
-  return n(), u;
-}, X = async (i, n, a, s = 6, c = n.map(() => 0), p = !1) => {
-  const { userKeys: u } = i, e = [], t = [];
+  const a = await C.acquire();
+  try {
+    const { inputUtxos: s } = await y({ hinkal: i, sliceIfMore6: !1 }), r = i.getCurrentChainId(), m = [...w(r), ...b.getCustomTokens(r)];
+    await I(r);
+    const p = m.map((e) => ({
+      token: e,
+      balance: s.reduce((t, d) => {
+        const o = e.isVolatile ? e.sharedAddress : e.erc20TokenAddress;
+        return u(o, d.erc20TokenAddress) ? t + d.amount : t;
+      }, 0n),
+      timestamp: s.filter(
+        (t) => u(t.erc20TokenAddress, e.erc20TokenAddress)
+      )[0]?.timeStamp,
+      nfts: s.filter(
+        (t) => u(t.erc20TokenAddress, e.erc20TokenAddress) && t.tokenId !== 0
+      ).map((t) => ({ tokenId: t.tokenId, timestamp: t.timeStamp }))
+    }));
+    return await Promise.all(
+      p.map(async (e) => {
+        if (!e.token.isVolatile)
+          return e;
+        e.token?.sharedAddress || console.log("VolatileToken must have a corresponding sharedAddress");
+        let t = 0n;
+        return e.balance > 0n && (t = await P.getVolatileTokenBalance(
+          r,
+          e.token.sharedAddress,
+          e.balance
+        )), {
+          ...e,
+          balance: BigInt(t)
+        };
+      })
+    );
+  } catch (s) {
+    console.log("Error while processing shielded balance:", s);
+  } finally {
+    a();
+  }
+  return [];
+}, X = async (i, a, s, r = 6, m = a.map(() => 0), p = !1) => {
+  const { userKeys: g } = i, e = [], t = [];
   let d = 0;
-  for (let o = 0; o < n.length; o += 1)
+  for (let o = 0; o < a.length; o += 1)
     if (p === !1) {
-      const { inputUtxos: r } = await T({
+      const { inputUtxos: n } = await y({
         hinkal: i,
-        erc20TokenAddress: n[o],
-        tokenId: c[o],
+        erc20TokenAddress: a[o],
+        tokenId: m[o],
         sliceIfMore6: !1
       });
-      d = Math.max(r.length, d), t.push(r);
+      d = Math.max(n.length, d), t.push(n);
     } else
       t.push([]);
-  return d === 2 ? t : (t.forEach((o, r) => {
-    if (o.length > s) {
-      const m = o.slice(0, s), l = m.reduce((f, h) => f + h.amount, 0n);
-      if (a[r] < 0n && l < -a[r]) {
-        const f = k(n[r], i.getCurrentChainId()), h = Number(x(l, f, 2)), y = `Unfortunately your transaction did not go through due to UTXOs limitations. 
+  return d === 2 ? t : (t.forEach((o, n) => {
+    if (o.length > r) {
+      const l = o.slice(0, r), c = l.reduce((f, h) => f + h.amount, 0n);
+      if (s[n] < 0n && c < -s[n]) {
+        const f = k(a[n], i.getCurrentChainId()), h = Number(x(c, f, 2)), T = `Unfortunately your transaction did not go through due to UTXOs limitations. 
  Please try again with ${f.symbol}`;
-        throw new S(h, y);
+        throw new S(h, T);
       }
-      e.push(m);
-    } else if (o.length <= s) {
-      const m = [...o];
-      let l = s - o.length;
-      for (; l > 0; )
-        l -= 1, m.push(
+      e.push(l);
+    } else if (o.length <= r) {
+      const l = [...o];
+      let c = r - o.length;
+      for (; c > 0; )
+        c -= 1, l.push(
           new U({
             amount: 0n,
-            erc20TokenAddress: n[r],
-            shieldedPrivateKey: u.getShieldedPrivateKey(),
-            tokenId: c[r]
+            erc20TokenAddress: a[n],
+            shieldedPrivateKey: g.getShieldedPrivateKey(),
+            tokenId: m[n]
           })
         );
-      e.push(m);
+      e.push(l);
     }
   }), e);
 };

package/functions/web3/events/index.d.mts

@@ -0,0 +1,4 @@
+export * from './getInputUtxoAndBalance';
+export * from './getShieldedBalance';
+export * from './web3RetrieveEvents';
+export * from './balanceChangedHandler';

package/functions/web3/events/web3RetrieveEvents.d.mts

@@ -0,0 +1,14 @@
+import { Contract, ethers } from 'ethers';
+/**
+ * to get contract events
+ * @param eventName to retrieve specific events
+ * @param eventArgs event arguments
+ * @returns array of the specific events
+ */
+export declare const retrieveEvents: (hinkalContract: ethers.Contract, eventName: string, ...eventArgs: unknown[]) => Promise<ethers.Event[]>;
+/**
+ *
+ * @param web3Provider instance to get hinkal contract
+ * @returns array of deposit timestamps in JS new Date format
+ */
+export declare const getDepositEvents: (hinkalContract: Contract, erc20TokenAddress: string) => Promise<Date[]>;

package/functions/web3/functionCalls/accessTokenCalls.d.mts

@@ -0,0 +1,6 @@
+import { ethers } from 'ethers';
+import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
+import { AxelarMigrationInfo, SignatureData } from '../../../types';
+export declare const checkHinkalAccessToken: (hinkal: IHinkal) => Promise<any>;
+export declare const mintAccessToken: (hinkal: IHinkal, signatureData: SignatureData) => Promise<ethers.ContractTransaction>;
+export declare const mintTokenCrossChain: (hinkal: IHinkal, signatureData: SignatureData, axelarMigrationInfos: AxelarMigrationInfo[]) => Promise<ethers.ContractTransaction>;

package/functions/web3/functionCalls/approveToken.d.mts

@@ -0,0 +1,4 @@
+import { ethers } from 'ethers';
+import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
+import { ERC20Token } from '../../../types/token.types';
+export declare const approveTokenToHinkal: (hinkal: IHinkal, contractToApprove: ethers.Contract, amount: bigint, token: ERC20Token) => Promise<Uint8Array | undefined>;

package/functions/web3/functionCalls/estimateGasRelayer.d.mts

@@ -0,0 +1,4 @@
+import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
+import { CircomDataType, DimDataType } from '../../../types/circom-data.types';
+import { NewZkCallDataType } from '../../../types/snark.types';
+export declare const estimateGasRelayer: (hinkal: IHinkal, newZkCallData: NewZkCallDataType, dimData: DimDataType, circomData: CircomDataType) => Promise<bigint>;

package/functions/web3/functionCalls/getRootHash.d.mts

@@ -0,0 +1,2 @@
+import { Contract } from 'ethers';
+export declare const getRootHash: (merkleTreeContract: Contract) => Promise<bigint>;

package/functions/web3/functionCalls/relayFunctions.d.mts

@@ -0,0 +1,17 @@
+import { ethers } from 'ethers';
+export interface RelayEntryData {
+    relayAddress: string;
+    url: string;
+    priority: number;
+}
+export interface RelayEntryWithIndex extends RelayEntryData {
+    lowerIndex: number;
+}
+export declare const getRelayPercentage: (contract: ethers.Contract) => Promise<bigint>;
+export declare const chooseRandomRelay: (entries: RelayEntryData[]) => {
+    lowerIndex: number;
+    relayAddress: string;
+    url: string;
+    priority: number;
+};
+export declare const getRelay: (hinkalHelperContract: ethers.Contract) => Promise<RelayEntryWithIndex>;

package/functions/web3/functionCalls/transactCallDirect.d.mts

@@ -0,0 +1,6 @@
+import { ethers } from 'ethers';
+import { IHinkal } from '../../../data-structures/Hinkal/IHinkal';
+import { CircomDataType, DimDataType } from '../../../types/circom-data.types';
+import { ERC20Token } from '../../../types/token.types';
+import { NewZkCallDataType } from '../../../types/snark.types';
+export declare const transactCallDirect: (hinkal: IHinkal, amount: bigint, tokenToApprove: ERC20Token, newZkCallData: NewZkCallDataType, circomData: CircomDataType, dimData: DimDataType, contractApproval?: ethers.Contract, contractTransaction?: ethers.Contract, hasAccessToken?: boolean) => Promise<any>;

package/functions/web3/functionCalls/transactCallRelayer.d.mts

@@ -0,0 +1,7 @@
+import { CircomDataType, DimDataType, NewZkCallDataType, RelayerTransaction } from '../../../types';
+export interface RelayerResponseInterface {
+    status: string;
+    message: RelayerTransaction;
+    error?: string;
+}
+export declare const transactCallRelayer: (chainId: number, newZkCallData: NewZkCallDataType, dimData: DimDataType, circomData: CircomDataType, withPrivateMempool?: boolean) => Promise<RelayerTransaction>;

package/functions/web3/getContractMetadata.d.mts

@@ -0,0 +1,5 @@
+import { ContractMetadata, ContractType } from '../../types/ethereum-network.types';
+import { ethers } from 'ethers';
+export declare const getContractMetadata: (contractType: ContractType, chainId: number) => ContractMetadata;
+export declare const getContract: (contractType: ContractType, chainId: number, contractAddress?: string) => ethers.Contract;
+export declare const getContractWithFetcherByChainId: (chainId: number, contractType: ContractType, contractAddress?: undefined) => ethers.Contract;

package/functions/web3/index.d.mts

@@ -0,0 +1,6 @@
+export * from './etherFunctions';
+export * from './events';
+export * from './uniswapAPI';
+export * from './odosAPI';
+export * from './oneInchAPI';
+export * from './runContractFunction';

package/functions/web3/odosAPI.d.mts

@@ -0,0 +1,5 @@
+import { ERC20Token } from '../../types';
+export declare const getOdosPrice: (chainId: number, inSwapToken: ERC20Token, outSwapToken: ERC20Token, inSwapAmount: string) => Promise<{
+    outSwapAmountValue: bigint;
+    odosDataValue: string;
+}>;

package/functions/web3/oneInchAPI.d.mts

@@ -0,0 +1,5 @@
+import { ERC20Token } from '../../types';
+export declare const getOneInchPrice: (chainId: number, inSwapToken: ERC20Token, outSwapToken: ERC20Token, inSwapAmount: string) => Promise<{
+    outSwapAmountValue: bigint;
+    oneInchDataValue: string;
+}>;

package/functions/web3/runContractFunction.d.mts

@@ -0,0 +1,15 @@
+import { BigNumber, ethers } from 'ethers';
+interface IRunTransaction {
+    contractFunction: ethers.ContractFunction;
+    args: unknown[];
+    gasLimit?: number;
+    gasPrice?: BigNumber;
+    confirmations?: number;
+    waitTime?: number;
+    nonce?: number;
+}
+interface IRunContractFunction extends IRunTransaction {
+    provider: ethers.providers.Provider;
+}
+export declare const runContractFunction: ({ provider, contractFunction, args, gasLimit, nonce, confirmations, }: IRunContractFunction) => Promise<ethers.ContractReceipt>;
+export {};

package/functions/web3/uniswapAPI.d.mts

@@ -0,0 +1,16 @@
+import { Contract } from 'ethers';
+import { ERC20Token } from '../../types';
+import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
+interface PoolAndFee {
+    poolAddress: string;
+    fee: number;
+    token1Balance: bigint;
+}
+export declare const searchPoolAndFee: (token1Contract: Contract, factory: Contract, token0Address: string, token1Address: string) => Promise<PoolAndFee>;
+export declare const getUniswapPriceHelper: (hinkal: IHinkal, chainId: number, token0: ERC20Token, token1: ERC20Token, fee: number, inSwapAmount: bigint) => Promise<bigint>;
+export declare const getUniswapFee: (hinkal: IHinkal, chainId: number, token0: ERC20Token, token1: ERC20Token) => Promise<number>;
+export declare const getUniswapPrice: (hinkal: IHinkal, chainId: number, inSwapAmount: string, inSwapToken: ERC20Token, outSwapToken: ERC20Token) => Promise<{
+    tokenPrice: bigint;
+    poolFee: string;
+}>;
+export {};

package/index.d.mts

@@ -0,0 +1,8 @@
+export * from './API';
+export * from './constants';
+export * from './crypto';
+export * from './data-structures';
+export * from './error-handling';
+export * from './externalABIs';
+export * from './functions';
+export * from './types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hinkal/common",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "homepage": "hinkal.pro",
   "author": {
     "name": "Hinkal Protocol"
@@ -13,26 +13,57 @@
   ],
   "exports": {
     ".": {
-      "import": "./index.mjs",
-      "require": "./index.cjs"
+      "import": {
+        "types": "./index.d.mts",
+        "default": "./index.mjs"
+      },
+      "require": {
+        "types": "./index.d.ts",
+        "default": "./index.cjs"
+      }
     },
     "./providers/EthersProviderAdapter": {
-      "import": "./providers/EthersProviderAdapter.mjs",
-      "require": "./providers/EthersProviderAdapter.cjs"
+      "import": {
+        "types": "./providers/EthersProviderAdapter.d.mts",
+        "default": "./providers/EthersProviderAdapter.mjs"
+      },
+      "require": {
+        "types": "./providers/EthersProviderAdapter.d.ts",
+        "default": "./providers/EthersProviderAdapter.cjs"
+      }
     },
     "./providers/WagmiProviderAdapter": {
-      "import": "./providers/WagmiProviderAdapter.mjs",
-      "require": "./providers/WagmiProviderAdapter.cjs"
+      "import": {
+        "types": "./providers/WagmiProviderAdapter.d.mts",
+        "default": "./providers/WagmiProviderAdapter.mjs"
+      },
+      "require": {
+        "types:": "./providers/WagmiProviderAdapter.d.ts",
+        "default": "./providers/WagmiProviderAdapter.cjs"
+      }
     },
     "./providers/prepareEthersHinkal": {
-      "import": "./providers/prepareEthersHinkal.mjs",
-      "require": "./providers/prepareEthersHinkal.cjs"
+      "import": {
+        "types": "./providers/prepareEthersHinkal.d.mts",
+        "default": "./providers/prepareEthersHinkal.mjs"
+      },
+      "require": {
+        "types": "./providers/prepareEthersHinkal.d.ts",
+        "default": "./providers/prepareEthersHinkal.cjs"
+      }
     },
     "./providers/prepareWagmiHinkal": {
-      "import": "./providers/prepareWagmiHinkal.mjs",
-      "require": "./providers/prepareWagmiHinkal.cjs"
+      "import": {
+        "types": "./providers/prepareWagmiHinkal.d.mts",
+        "default": "./providers/prepareWagmiHinkal.mjs"
+      },
+      "require": {
+        "types": "./providers/prepareWagmiHinkal.d.ts",
+        "default": "./providers/prepareWagmiHinkal.cjs"
+      }
     }
   },
+  "types": "./index.d.ts",
   "scripts": {
     "prebuild": "nx prebuild:workers",
     "build": "nx build",

package/providers/EthersProviderAdapter.d.mts

@@ -0,0 +1,39 @@
+import { IProviderAdapter } from '../data-structures/provider-adapter/IProviderAdapter';
+import { ContractMetadata, ContractType, EthereumNetwork } from '../types/ethereum-network.types';
+import { ethers, Signer } from 'ethers';
+export declare class EthersProviderAdapter implements IProviderAdapter<Signer> {
+    signer: Signer | undefined;
+    chainId: number | undefined;
+    private originalProvider;
+    private fetchProvider;
+    initConnector(): void;
+    initSigner(signer: Signer): void;
+    requireSigner(): void;
+    init(chainId?: number): Promise<void>;
+    disconnectFromConnector(): Promise<void>;
+    connectToConnector(): Promise<number>;
+    waitForTransaction(transactionHash: string, confirmations: number): Promise<boolean>;
+    signMessage(message: string): Promise<string>;
+    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, ethers.TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
+    getSelectedNetwork: () => EthereumNetwork | undefined;
+    switchNetwork(): Promise<void>;
+    private createFetchProvider;
+    getAddress(): Promise<string>;
+    setChainEventListener(): void;
+    onAccountChanged(): Promise<unknown>;
+    onChainChanged(chainId?: number): Promise<unknown>;
+    release(): void;
+    private parseChainIdParam;
+    getContractMetadata(contractType: ContractType, chainId?: number): ContractMetadata;
+    getContract(contractType: ContractType, contractAddress?: undefined, chainId?: number): ethers.Contract;
+    getContractWithSigner(contract: ContractType, contractAddress?: undefined): ethers.Contract;
+    getContractWithFetcher(contract: ContractType, contractAddress?: undefined): ethers.Contract;
+    getContractWithFetcherForEthereum(contract: ContractType, contractAddress?: undefined): ethers.Contract;
+    sendTransaction(tx: ethers.providers.TransactionRequest): Promise<ethers.providers.TransactionResponse>;
+    connectAndPatchProvider(): Promise<number>;
+    isPermitterAvailable(): boolean;
+    getGasPrice(): Promise<bigint>;
+}
+export declare const ethersProvierAdapter: EthersProviderAdapter;
+declare const _default: <T = unknown>() => IProviderAdapter<T>;
+export default _default;