@kapa123456789/sdk 0.0.41 → 0.0.42

package/services/Hinkal.mjs

@@ -0,0 +1,143 @@
+import { networkRegistry as e } from "../common/src/constants/chains.constants.mjs";
+import { LoginMessageMode as t } from "../common/src/types/hinkal.types.mjs";
+import { Hinkal as n } from "../common/src/data-structures/Hinkal/Hinkal.mjs";
+//#region libs/shared/sdk/src/services/Hinkal.ts
+var r = class {
+	hinkalCommon;
+	constructor(e) {
+		this.hinkalCommon = new n(e);
+	}
+	getProviderAdapter(e) {
+		return this.hinkalCommon.getProviderAdapter(e);
+	}
+	initProviderAdapter(e, t) {
+		return this.hinkalCommon.initProviderAdapter(e, t);
+	}
+	initUserKeys(e = t.PROTOCOL) {
+		return this.hinkalCommon.initUserKeys(e);
+	}
+	initUserKeysWithSignature(e) {
+		return this.hinkalCommon.initUserKeysWithSignature(e);
+	}
+	initUserKeysFromSeedPhrases(e) {
+		return this.hinkalCommon.initUserKeysFromSeedPhrases(e);
+	}
+	resetProviderAdapters() {
+		return this.hinkalCommon.resetProviderAdapters();
+	}
+	disconnectFromConnector() {
+		return this.hinkalCommon.disconnectFromConnector();
+	}
+	signMessage(e) {
+		return this.hinkalCommon.signMessage(e);
+	}
+	signTypedData(e, t, n) {
+		return this.hinkalCommon.signTypedData(e, t, n);
+	}
+	getSupportedChains() {
+		return this.hinkalCommon.getSupportedChains();
+	}
+	isSelectedNetworkSupported(e) {
+		return this.hinkalCommon.isSelectedNetworkSupported(e);
+	}
+	switchNetwork(t) {
+		let n = e[t];
+		if (!n) throw Error(`Network with chainId ${t} not supported`);
+		return this.hinkalCommon.switchNetwork(n);
+	}
+	resetMerkle(e) {
+		return this.hinkalCommon.resetMerkle(e);
+	}
+	resetMerkleTreesIfNecessary(e) {
+		return this.hinkalCommon.resetMerkleTreesIfNecessary(e);
+	}
+	get privateBalancesWithUSD() {
+		return this.hinkalCommon.privateBalancesWithUSD;
+	}
+	onPrivateBalancesWithUSDChange(e) {
+		return this.hinkalCommon.onPrivateBalancesWithUSDChange(e);
+	}
+	getTotalBalance(e, t = !1, n = !1) {
+		return this.hinkalCommon.getTotalBalance(e, void 0, void 0, t, n);
+	}
+	getStuckShieldedBalances(e, t = !1, n = !1) {
+		return this.hinkalCommon.getStuckShieldedBalances(e, void 0, void 0, t, n);
+	}
+	monitorConnectedAddress(e) {
+		return this.hinkalCommon.monitorConnectedAddress(e);
+	}
+	getSupportedPassportLinks() {
+		return this.hinkalCommon.getSupportedPassportLinks();
+	}
+	checkAccessToken(e, t) {
+		return this.hinkalCommon.checkAccessToken(e, t);
+	}
+	waitForTransaction(e, t, n) {
+		return this.hinkalCommon.waitForTransaction(e, t, n);
+	}
+	getSolanaPublicKey() {
+		return this.hinkalCommon.getSolanaPublicKey();
+	}
+	getEthereumAddress() {
+		return this.hinkalCommon.getEthereumAddress();
+	}
+	getEthereumAddressByChain(e) {
+		return this.hinkalCommon.getEthereumAddressByChain(e);
+	}
+	getRecipientInfo() {
+		return this.hinkalCommon.getRecipientInfo();
+	}
+	getShieldedPublicKey() {
+		return this.hinkalCommon.userKeys.getShieldedPublicKey();
+	}
+	prooflessDeposit(e, t, n) {
+		return this.hinkalCommon.prooflessDeposit(e, t, n);
+	}
+	deposit(e, t, n, r) {
+		return this.hinkalCommon.deposit(e, t, n, r);
+	}
+	depositSolana(e, t) {
+		return this.hinkalCommon.depositSolana(e, t);
+	}
+	depositForOther(e, t, n, r, i) {
+		return this.hinkalCommon.depositForOther(e, t, n, r, i);
+	}
+	depositSolanaForOther(e, t, n) {
+		return this.hinkalCommon.depositSolanaForOther(e, t, n);
+	}
+	depositAndWithdraw(e, t, n, r, i, a) {
+		return this.hinkalCommon.depositAndWithdraw(e, t, n, r, i, void 0, void 0, void 0, a);
+	}
+	depositAndBridge(e, t, n, r, i) {
+		return this.hinkalCommon.depositAndBridge(e, t, n, r, void 0, void 0, void 0, i);
+	}
+	claimUtxo(e, t, n) {
+		return this.hinkalCommon.claimUtxo(e, t, n);
+	}
+	transfer(e, t, n, r, i) {
+		return this.hinkalCommon.transfer(e, t, n, r, i);
+	}
+	withdraw(e, t, n, r, i, a) {
+		return this.hinkalCommon.withdraw(e, t, n, r, i, a);
+	}
+	withdrawStuckUtxos(e, t) {
+		return this.hinkalCommon.withdrawStuckUtxos(e, t);
+	}
+	swap(e, t, n, r, i, a) {
+		return this.hinkalCommon.swap(e, t, n, r, i, a);
+	}
+	actionPrivateWallet(e, t, n, r, i, a, o, s, c) {
+		return this.hinkalCommon.actionPrivateWallet(e, t, n, r, i, a, o, s, c);
+	}
+	proxySwap(e, t, n, r, i, a, o, s) {
+		return this.hinkalCommon.proxySwap(e, t, n, r, i, a, o, s);
+	}
+	proxyToPrivate(e, t, n, r, i, a) {
+		return this.hinkalCommon.proxyToPrivate(e, t, n, r, i, a);
+	}
+	proxySend(e, t, n, r, i, a) {
+		return this.hinkalCommon.proxySend(e, t, n, r, i, a);
+	}
+};
+//#endregion
+export { r as Hinkal };

package/services/index.cjs

@@ -0,0 +1 @@
+require(`./Hinkal.cjs`);

package/services/index.mjs

@@ -0,0 +1 @@
+import "./Hinkal.mjs";

package/types/IHinkal.d.ts

@@ -0,0 +1,51 @@
+import { PrivateBalancesState, BridgeRecipient, ERC20Token, ExternalActionId, FeeStructure, LoginMessageMode, StealthAddressStructure, SubAccount, TokenBalance, TokenChanges } from '../common/src/types';
+import { ethers, TypedDataDomain, TypedDataField } from 'ethers';
+import { Utxo } from '../common/src/data-structures/utxo/Utxo';
+import { PublicKey } from '@solana/web3.js';
+import { IProviderAdapter } from './IProviderAdapter';
+export interface IHinkal<ConnectorType = unknown> {
+    getProviderAdapter(chainId?: number): IProviderAdapter;
+    initProviderAdapter(connector: ConnectorType, providerAdapter: IProviderAdapter<ConnectorType>): Promise<void>;
+    initUserKeys(mode?: LoginMessageMode): Promise<void>;
+    initUserKeysWithSignature(signature: string): void;
+    initUserKeysFromSeedPhrases(seedPhrases: string[]): Promise<void>;
+    resetProviderAdapters(): Promise<void>;
+    disconnectFromConnector(): Promise<void>;
+    signMessage(message: string): Promise<string>;
+    signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
+    getSupportedChains(): number[];
+    isSelectedNetworkSupported(chainId: number): boolean;
+    switchNetwork(chainId: number): Promise<unknown>;
+    resetMerkle(chainIdsToReset?: number[]): Promise<void>;
+    resetMerkleTreesIfNecessary(chainIdsToCheck?: number[]): Promise<void>;
+    privateBalancesWithUSD: PrivateBalancesState;
+    /** Returns unsubscribe. Multiple listeners supported. */
+    onPrivateBalancesWithUSDChange(callback: (state: PrivateBalancesState) => void): () => void;
+    getTotalBalance(chainId: number, resetCacheBefore?: boolean, updateTokensListBefore?: boolean): Promise<TokenBalance[]>;
+    getStuckShieldedBalances(chainId: number, resetCacheBefore?: boolean, updateTokensListBefore?: boolean): Promise<TokenBalance[]>;
+    monitorConnectedAddress(chainId: number): Promise<void>;
+    getSupportedPassportLinks(): string[];
+    checkAccessToken(chainId: number, accessKeyOverride?: string): Promise<boolean>;
+    waitForTransaction(chainId: number, transactionHash: string, confirmations?: number): Promise<boolean>;
+    getSolanaPublicKey(): PublicKey;
+    getEthereumAddress(): Promise<string>;
+    getEthereumAddressByChain(chainId: number): Promise<string>;
+    getRecipientInfo(): string;
+    getShieldedPublicKey(): string;
+    prooflessDeposit(erc20Tokens: ERC20Token[], amountChanges: bigint[], stealthAddressStructures?: StealthAddressStructure[]): Promise<string>;
+    deposit(erc20Tokens: ERC20Token[], amountChanges: bigint[], preEstimateGas?: boolean, returnTxData?: boolean): Promise<ethers.TransactionResponse | ethers.TransactionRequest>;
+    depositSolana(amount: bigint, token: ERC20Token): Promise<string>;
+    depositForOther(erc20Tokens: ERC20Token[], amountChanges: bigint[], recipientInfo: string, preEstimateGas?: boolean, returnTxData?: boolean): Promise<ethers.TransactionResponse | ethers.TransactionRequest>;
+    depositSolanaForOther(amount: bigint, token: ERC20Token, recipientInfo: string): Promise<string>;
+    depositAndWithdraw(erc20Token: ERC20Token, recipientAmounts: bigint[], recipientAddresses: string[], txCompletionTime?: number, feeStructureOverride?: FeeStructure, preEstimateGas?: boolean): Promise<string>;
+    depositAndBridge(erc20Token: ERC20Token, recipientBridges: BridgeRecipient[], txCompletionTime?: number, feeStructureOverride?: FeeStructure, preEstimateGas?: boolean): Promise<string>;
+    claimUtxo(erc20Token: ERC20Token, utxo: Utxo, feeStructureOverride?: FeeStructure): Promise<string>;
+    transfer(erc20Tokens: ERC20Token[], amountChanges: bigint[], recipientAddress: string, feeToken?: string, feeStructureOverride?: FeeStructure): Promise<string>;
+    withdraw(erc20Tokens: ERC20Token[], deltaAmounts: bigint[], recipientAddress: string, isRelayerOff: boolean, feeToken?: string, feeStructureOverride?: FeeStructure): Promise<ethers.TransactionResponse | string>;
+    withdrawStuckUtxos(erc20Token: ERC20Token, recipientAddress: string): Promise<string[]>;
+    swap(erc20Tokens: ERC20Token[], deltaAmounts: bigint[], externalActionId: ExternalActionId, swapData: string, feeToken?: string, feeStructureOverride?: FeeStructure): Promise<string>;
+    actionPrivateWallet(chainId: number, erc20Tokens: ERC20Token[], deltaAmounts: bigint[], onChainCreation: boolean[], ops: string[], emporiumTokenChanges: TokenChanges<bigint>[], subAccount?: SubAccount, feeToken?: string, feeStructureOverride?: FeeStructure): Promise<string>;
+    proxySwap(erc20Tokens: ERC20Token[], deltaAmounts: bigint[], externalActionId: ExternalActionId, swapData: string, isTheSameChainSwap: boolean, subAccount: SubAccount, feeToken?: string, feeStructureOverride?: FeeStructure): Promise<string>;
+    proxyToPrivate(erc20Tokens: ERC20Token[], deltaAmountsBase: bigint[], subAccount: SubAccount, recipientInfo: string, feeToken?: string, feeStructureOverride?: FeeStructure): Promise<string>;
+    proxySend(erc20Tokens: ERC20Token[], amounts: bigint[], subAccount: SubAccount, recipientAddress: string, feeToken?: string, feeStructureOverride?: FeeStructure): Promise<string>;
+}

package/types/IProviderAdapter.d.ts

@@ -0,0 +1 @@
+export type { IProviderAdapter } from '../common/src/data-structures/provider-adapter/IProviderAdapter';

package/types/balances.types.d.ts

@@ -0,0 +1,4 @@
+import { PrivateBalanceUpdateEventType as CommonPrivateBalanceUpdateEventType } from '../common/src/types';
+export { PrivateBalanceUpdateType } from '../common/src/types';
+export type { PrivateBalancesState, TokenBalance } from '../common/src/types';
+export type PrivateBalanceUpdateEventType = Omit<CommonPrivateBalanceUpdateEventType, 'balanceChangeState'>;

package/types/external-action.types.d.ts

@@ -0,0 +1 @@
+export { ExternalActionId, type ExternalActionData } from '../common/src/types';

package/types/fee.types.d.ts

@@ -0,0 +1 @@
+export type { FeeStructure } from '../common/src/types/hinkal.types';

package/types/privateTypes.d.ts

@@ -0,0 +1,5 @@
+import { IHinkal } from './IHinkal';
+import { IHinkal as IHinkalCommon } from '../common/src/data-structures/Hinkal/IHinkal';
+export type IHinkalSDK<ConnectorType = unknown> = IHinkal<ConnectorType> & {
+    hinkalCommon: IHinkalCommon<ConnectorType>;
+};

package/types/token.types.d.ts

@@ -0,0 +1 @@
+export type { ERC20Token, NFT } from '../common/src/types';

package/copyPackageJson.d.ts

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

package/copyPackageJson.js

@@ -1,82 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { execSync } from 'child_process';
-
-// Function to increment the version number
-const incrementVersion = (version) => {
-  const versionParts = version.split('.').map(Number); // Split version into [major, minor, patch]
-  if (versionParts.length === 3) {
-    versionParts[2] += 1; // Increment the patch version
-    return versionParts.join('.'); // Return the updated version as a string
-  } else {
-    throw new Error('Invalid version format in package.json');
-  }
-};
-
-const destPath = '../../../dist/libs/shared/sdk';
-
-const emptyWorkerAssets = () => {
-  const workersAssetsPath = path.join(path.join(__dirname, destPath), 'assets');
-  const files = fs.readdirSync(workersAssetsPath);
-  files.forEach((file) => {
-    const filePath = path.join(workersAssetsPath, file);
-    fs.unlinkSync(filePath);
-  });
-};
-
-const copyWorkers = () => {
-  const prebuildWorkerPath = '../../../dist/libs/shared/workers-prebuild';
-  const destWorkerPath = destPath + '/common/src/webworker';
-
-  const preBuildWorkersCjs = path.join(path.join(__dirname, prebuildWorkerPath), 'viteWorkerURL.constant.sdk.js');
-  const cjsWorkers = path.join(path.join(__dirname, destWorkerPath), 'viteWorkerURL.constant.cjs');
-  fs.copyFileSync(preBuildWorkersCjs, cjsWorkers);
-
-  const preBuildWorkersMjs = path.join(path.join(__dirname, prebuildWorkerPath), 'viteWorkerURL.constant.es.js');
-  const mjsWorkers = path.join(path.join(__dirname, destWorkerPath), 'viteWorkerURL.constant.mjs');
-  fs.copyFileSync(preBuildWorkersMjs, mjsWorkers);
-  emptyWorkerAssets();
-  console.log('Copy Prebuilded workers finished');
-};
-
-export const copyPackage = () => {
-  const pkgSrc = path.resolve(__dirname, 'package.json');
-  const pkgDest = path.resolve(path.join(__dirname, destPath), 'package.json');
-  console.log({ pkgSrc, pkgDest });
-
-  // Read and parse the package.json file
-  const packageJson = JSON.parse(fs.readFileSync(pkgSrc, 'utf-8'));
-
-  // Increment the version in the source folder's package.json
-  packageJson.version = incrementVersion(packageJson.version);
-  console.log({ version: packageJson.version });
-
-  // Write the updated package.json back to the source folder
-  fs.writeFileSync(pkgSrc, JSON.stringify(packageJson, null, 2), 'utf-8');
-
-  // Modify the "type" field or any other field in package.json
-  // packageJson.type = 'module'; // Example: changing type field to 'module'
-
-  // Ensure the destination directory exists and write the modified package.json to the destination
-  fs.mkdirSync(path.dirname(pkgDest), { recursive: true });
-  fs.writeFileSync(pkgDest, JSON.stringify(packageJson, null, 2), 'utf-8');
-
-  // Copy Readme
-  fs.copyFileSync(path.resolve(__dirname, 'README.md'), path.join(__dirname, `${destPath}/README.md`));
-  console.log('Modified and copied package.json to build folder');
-
-  // Copying Workers
-  copyWorkers();
-
-  // Navigate to the destination directory
-  /*
-  try {
-    console.log('Publishing package to npm...');
-    // Execute `npm publish` in the destination directory
-    execSync('npm publish --access=public', { cwd: path.join(__dirname, destPath), stdio: 'inherit' });
-    console.log('Package successfully published to npm.');
-  } catch (error) {
-    console.error('Failed to publish package:', error.message);
-  }
-  */
-};

package/eslint.config.mjs

@@ -1,17 +0,0 @@
-import baseConfig from '../../../eslint.config.mjs';
-
-export default [
-  {
-    // Not in tsconfig.lib.json; type-aware ESLint needs them ignored or a separate tsconfig.
-    ignores: [
-      'libs/shared/sdk/vite.config.ts',
-      'libs/shared/sdk/vite.config.workers.ts',
-      'libs/shared/sdk/vite.config.workers.node.ts',
-    ],
-  },
-  ...baseConfig,
-  {
-    files: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'],
-    rules: {},
-  },
-];

package/handleCDNWorkers.d.ts

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

package/handleCDNWorkers.js

@@ -1,88 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { execSync } from 'child_process';
-import { config } from 'dotenv';
-config();
-
-// Function to increment the version number
-const incrementVersion = (version) => {
-  const versionParts = version.split('.').map(Number); // Split version into [major, minor, patch]
-  if (versionParts.length === 3) {
-    versionParts[2] += 1; // Increment the patch version
-    return versionParts.join('.'); // Return the updated version as a string
-  } else {
-    throw new Error('Invalid version format in package.json');
-  }
-};
-
-const requireEnv = (name) => {
-  if (!process.env[name]) throw new Error(`${name} environment variable missing`);
-  return process.env[name];
-};
-
-const CDN_URL = requireEnv('CDN_URL');
-const gcsBucket = requireEnv('GCS_BUCKET');
-const mjsFileToRewrite = 'viteWorkerURL.constant.es.js';
-const cjsFileToRewrite = 'viteWorkerURL.constant.sdk.js';
-
-if (!CDN_URL || !gcsBucket) throw new Error('Necessary Environment variable missing');
-
-const fileWithCDNWorkersContent = `
-  const domain = '${CDN_URL}';
-
-  // Returns a blob:// URL which points
-  // to a javascript file which will call
-  // importScripts with the given URL
-  async function getWorkerURL(url) {
-    const contentRes = await fetch(url);
-    const content = await contentRes.text()
-
-    return URL.createObjectURL(new Blob([content], { type: "application/javascript" }));
-  }
-
-  var e = /* @__PURE__ */ ((r) => (r.ZKProof = "ZKProof", r.SnarkJS = "SnarkJS", r.UTXO = "UTXO", r))(e || {});
-
-  const n = async () => ({
-    [e.ZKProof]: await getWorkerURL(domain + '____folder____' + 'zkProofWorkerLauncher.js'),
-    [e.SnarkJS]: await getWorkerURL(domain + '____folder____' + 'snarkjsWorkerLauncher.js'),
-    [e.UTXO]: await getWorkerURL(domain + '____folder____' + 'utxoWorkerLauncher.js'),
-  });
-  export { n as getWorkerViteURL };
-`;
-
-export const proccessCDN = () => {
-  const pkgSrc = path.resolve(__dirname, 'package.json');
-  const destDir = path.resolve(__dirname, '../../../dist/libs/shared/workers-prebuild'); // Adjust if your build output directory is different
-  // Read and parse the package.json file
-  const packageJson = JSON.parse(fs.readFileSync(pkgSrc, 'utf-8'));
-
-  // Increment the version in the source folder's package.json
-  const version = incrementVersion(packageJson.version);
-
-  const assets = fs.readdirSync(path.resolve(destDir, './assets'));
-  console.log(version, assets);
-  const folder = `/workers/${version}/`;
-
-  fs.mkdirSync(path.join(destDir, `workers`));
-  fs.mkdirSync(path.join(path.resolve(destDir, './workers'), `${version}`));
-
-  // e.g. of filename utxoWorkerLauncher-BEutOJO3.js, so utxoWorkerLauncher-BEutOJO3.js -> utxoWorkerLauncher.js
-  const filesDestinations = assets.map((file) => `${folder}${file.split('.')[0].split('-')[0]}.js`);
-
-  assets.forEach((file, index) => {
-    fs.copyFileSync(path.resolve(destDir, `./assets/${file}`), path.resolve(destDir, `.${filesDestinations[index]}`));
-  });
-
-  execSync(`gcloud storage cp -r ${path.resolve(destDir, './workers')}/* gs://${gcsBucket}/`, {
-    cwd: path.dirname(destDir),
-    stdio: 'inherit',
-  });
-
-  const mjsFileContent = fileWithCDNWorkersContent.replaceAll('____folder____', `/${version}/`);
-  const cjsFileContent = fileWithCDNWorkersContent
-    .replaceAll('____folder____', `/${version}/`)
-    .replace('export { n as getWorkerViteURL };', 'exports.getWorkerViteURL = n;');
-
-  fs.writeFileSync(path.resolve(destDir, mjsFileToRewrite), mjsFileContent);
-  fs.writeFileSync(path.resolve(destDir, cjsFileToRewrite), cjsFileContent);
-};

package/jest.config.ts

@@ -1,10 +0,0 @@
-/* eslint-disable */
-export default {
-  displayName: 'sdk',
-  testEnvironment: 'node',
-  transform: {
-    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
-  },
-  preset: '../../../jest.preset.js',
-  coverageDirectory: '.',
-};

package/project.json

@@ -1,35 +0,0 @@
-{
-  "name": "sdk",
-  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "libs/shared/sdk/src",
-  "projectType": "library",
-  "tags": [],
-  "targets": {
-    "prebuild:workers": {
-      "command": "vite build --config ./libs/shared/sdk/vite.config.workers.ts"
-    },
-    "postbuild:node-workers": {
-      "command": "vite build --config ./libs/shared/sdk/vite.config.workers.node.ts"
-    },
-    "build": {
-      "executor": "@nx/vite:build",
-      "outputs": ["{options.outputPath}"],
-      "defaultConfiguration": "production",
-      "options": {
-        "outputPath": "dist/libs/shared/sdk",
-        "skipTypeCheck": true
-      }
-    },
-    "lint": {
-      "executor": "@nx/eslint:lint",
-      "outputs": ["{options.outputFile}"]
-    },
-    "test": {
-      "executor": "@nx/jest:jest",
-      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
-      "options": {
-        "jestConfig": "libs/shared/sdk/jest.config.ts"
-      }
-    }
-  }
-}

package/src/functions/integrations/swapApi.ts

@@ -1,19 +0,0 @@
-import { ERC20Token, IHinkal } from '../../types';
-import { getUniswapPrice as getUniswapPriceCommon } from '@hinkal/common/functions/web3/uniswapAPI';
-import { IHinkalSDK } from '../../types/privateTypes';
-
-export { getOdosPrice } from '@hinkal/common/functions/web3/odosAPI';
-export { getOneInchPrice } from '@hinkal/common/functions/web3/oneInchAPI';
-export { getLifiPrice } from '@hinkal/common/functions/web3/lifiAPI';
-export { getOKXPrice } from '@hinkal/common/functions/web3/okxAPI';
-
-export const getUniswapPrice = async (
-  hinkal: IHinkal,
-  chainId: number,
-  inSwapAmount: string,
-  inSwapToken: ERC20Token,
-  outSwapToken: ERC20Token,
-) => {
-  const commonInstance = (hinkal as IHinkalSDK).hinkalCommon;
-  return getUniswapPriceCommon(commonInstance, chainId, inSwapAmount, inSwapToken, outSwapToken);
-};

package/src/functions/utils/getErc20Token.ts

@@ -1,13 +0,0 @@
-import { tokensInfoCall } from '@hinkal/common/API/token-calls';
-import { getERC20Token as getERC20TokenFromRegistry } from '@hinkal/common/functions/utils/erc20tokenFunctions';
-import type { ERC20Token } from '@hinkal/common/types';
-
-export const getErc20Token = async (chainId: number, address: string): Promise<ERC20Token | undefined> => {
-  const localToken = getERC20TokenFromRegistry(address, chainId);
-  if (localToken) {
-    return localToken;
-  }
-
-  const [apiToken] = await tokensInfoCall(chainId, [address]);
-  return apiToken;
-};

package/src/functions/utils/getFeeStructure.ts

@@ -1 +0,0 @@
-export { getFeeStructure } from '@hinkal/common/functions/pre-transaction/getFeeStructure';

package/src/functions/utils/preProcessing.ts

@@ -1 +0,0 @@
-export { preProcessing } from '@hinkal/common/crypto/preProcessing';

package/src/functions/utils/refreshBalance.ts

@@ -1,6 +0,0 @@
-import { balanceChangedHandler } from '@hinkal/common/functions/web3/events/balanceChangedHandler';
-import { PrivateBalanceUpdateEventType } from '../../types/balances.types';
-
-export const refreshBalance = (detail: PrivateBalanceUpdateEventType) => {
-  balanceChangedHandler(detail);
-};

package/src/providers/EthersProviderAdapter.ts

@@ -1,4 +0,0 @@
-import EthersProviderAdapter, { ethersProvierAdapter } from '@hinkal/common/providers/EthersProviderAdapter';
-
-export { ethersProvierAdapter };
-export default EthersProviderAdapter;

package/src/providers/SolanaProviderAdapter.ts

@@ -1,3 +0,0 @@
-import SolanaProviderAdapter from '@hinkal/common/providers/SolanaProviderAdapter';
-
-export default SolanaProviderAdapter;

package/src/providers/TronProviderAdapter.ts

@@ -1,3 +0,0 @@
-import TronProviderAdapter from '@hinkal/common/providers/TronProviderAdapter';
-
-export default TronProviderAdapter;

package/src/providers/WagmiProviderAdapter.ts

@@ -1,4 +0,0 @@
-import WagmiProviderAdapter, { wagmiProviderAdapter } from '@hinkal/common/providers/WagmiProviderAdapter';
-
-export { wagmiProviderAdapter };
-export default WagmiProviderAdapter;

package/src/providers/prepareEthersHinkal.ts

@@ -1,17 +0,0 @@
-import { preProcessing } from '@hinkal/common/crypto/preProcessing';
-import EthersProviderAdapter from '@hinkal/common/providers/EthersProviderAdapter';
-import { HinkalConfig } from '@hinkal/common/types/hinkal.types';
-import { type Signer } from 'ethers';
-import { Hinkal } from '../services';
-
-export const prepareEthersHinkal = async (signer: Signer, hinkalConfig?: HinkalConfig): Promise<Hinkal<unknown>> => {
-  await preProcessing();
-  const hinkal = new Hinkal(hinkalConfig);
-  const ethersProvierAdapter = EthersProviderAdapter();
-  ethersProvierAdapter.initSigner?.(signer); // type discrepency comes from different version of ethers.js
-  await hinkal.initProviderAdapter(undefined, ethersProvierAdapter);
-  await hinkal.initUserKeys();
-  await hinkal.resetMerkle();
-
-  return hinkal;
-};

package/src/providers/prepareSolanaHinkal.ts

@@ -1,23 +0,0 @@
-import { chainIds } from '@hinkal/common/constants/chains.constants';
-import { preProcessing } from '@hinkal/common/crypto/preProcessing';
-import SolanaProviderAdapter from '@hinkal/common/providers/SolanaProviderAdapter';
-import { HinkalConfig } from '@hinkal/common/types/hinkal.types';
-import { SolanaWallet } from '@hinkal/common/types/solana.types';
-import { Hinkal } from '../services';
-
-export const prepareSolanaHinkal = async (
-  connector: SolanaWallet,
-  ethereumAddress?: string,
-  hinkalConfig?: HinkalConfig,
-): Promise<Hinkal<unknown>> => {
-  await preProcessing();
-  const hinkal = new Hinkal(hinkalConfig);
-  const chainId = chainIds.solanaMainnet;
-
-  const solanaProvierAdapter = SolanaProviderAdapter(chainId, ethereumAddress);
-  await hinkal.initProviderAdapter(connector, solanaProvierAdapter);
-  await hinkal.initUserKeys();
-  await hinkal.resetMerkle();
-
-  return hinkal;
-};

package/src/providers/prepareTronHinkal.ts

@@ -1,17 +0,0 @@
-import { preProcessing } from '@hinkal/common/crypto/preProcessing';
-import TronProviderAdapter from '@hinkal/common/providers/TronProviderAdapter';
-import { HinkalConfig } from '@hinkal/common/types/hinkal.types';
-import { TronWeb } from 'tronweb';
-import { currentTronChainId } from '@hinkal/common/constants/chains.constants';
-import { Hinkal } from '../services';
-
-export const prepareTronHinkal = async (connector: TronWeb, hinkalConfig?: HinkalConfig): Promise<Hinkal<unknown>> => {
-  await preProcessing();
-  const hinkal = new Hinkal(hinkalConfig);
-  const tronProvierAdapter = TronProviderAdapter(currentTronChainId);
-  await hinkal.initProviderAdapter(connector, tronProvierAdapter);
-  await hinkal.initUserKeys();
-  await hinkal.resetMerkle();
-
-  return hinkal;
-};

package/src/providers/prepareWagmiHinkal.ts

@@ -1,16 +0,0 @@
-import { preProcessing } from '@hinkal/common/crypto/preProcessing';
-import WagmiProviderAdapter from '@hinkal/common/providers/WagmiProviderAdapter';
-import { type Config, type Connector } from 'wagmi';
-import { Hinkal } from '../services';
-
-export const prepareWagmiHinkal = async (connector: Connector, config: Config): Promise<Hinkal<unknown>> => {
-  await preProcessing();
-  const hinkal = new Hinkal();
-  const wagmiProviderAdapter = WagmiProviderAdapter();
-  wagmiProviderAdapter.initConfig?.(config);
-  await hinkal.initProviderAdapter(connector, wagmiProviderAdapter);
-  await hinkal.initUserKeys();
-  await hinkal.resetMerkle();
-
-  return hinkal;
-};