@kapa123456789/sdk 0.0.40 → 0.0.41

package/src/services/Hinkal.ts

@@ -0,0 +1,372 @@
+import { Hinkal as HinkalCommon } from '@hinkal/common/data-structures/Hinkal/Hinkal';
+import { IHinkal as IHinkalCommon } from '@hinkal/common/data-structures/Hinkal/IHinkal';
+import {
+  BridgeRecipient,
+  ERC20Token,
+  ExternalActionId,
+  FeeStructure,
+  HinkalConfig,
+  LoginMessageMode,
+  StealthAddressStructure,
+  SubAccount,
+  TokenBalance,
+  TokenChanges,
+} from '@hinkal/common/types';
+import type { PrivateBalancesState } from '@hinkal/common/types';
+import { ethers, TypedDataDomain, TypedDataField } from 'ethers';
+import { Utxo } from '@hinkal/common/data-structures/utxo/Utxo';
+import { PublicKey } from '@solana/web3.js';
+import { IHinkal, IProviderAdapter } from '../types';
+import { networkRegistry } from '@hinkal/common/constants/chains.constants';
+
+export class Hinkal<ConnectorType> implements IHinkal<ConnectorType> {
+  private readonly hinkalCommon: IHinkalCommon<ConnectorType>;
+
+  constructor(hinkalConfig?: HinkalConfig) {
+    this.hinkalCommon = new HinkalCommon(hinkalConfig);
+  }
+
+  public getProviderAdapter(chainId?: number): IProviderAdapter {
+    return this.hinkalCommon.getProviderAdapter(chainId);
+  }
+
+  public initProviderAdapter(
+    connector: ConnectorType,
+    providerAdapter: IProviderAdapter<ConnectorType>,
+  ): Promise<void> {
+    return this.hinkalCommon.initProviderAdapter(connector, providerAdapter);
+  }
+
+  public initUserKeys(mode: LoginMessageMode = LoginMessageMode.PROTOCOL): Promise<void> {
+    return this.hinkalCommon.initUserKeys(mode);
+  }
+
+  public initUserKeysWithSignature(signature: string): void {
+    return this.hinkalCommon.initUserKeysWithSignature(signature);
+  }
+
+  public initUserKeysFromSeedPhrases(seedPhrases: string[]): Promise<void> {
+    return this.hinkalCommon.initUserKeysFromSeedPhrases(seedPhrases);
+  }
+
+  public resetProviderAdapters(): Promise<void> {
+    return this.hinkalCommon.resetProviderAdapters();
+  }
+
+  public disconnectFromConnector(): Promise<void> {
+    return this.hinkalCommon.disconnectFromConnector();
+  }
+
+  public signMessage(message: string): Promise<string> {
+    return this.hinkalCommon.signMessage(message);
+  }
+
+  public signTypedData(
+    domain: TypedDataDomain,
+    types: Record<string, TypedDataField[]>,
+    value: Record<string, unknown>,
+  ): Promise<string> {
+    return this.hinkalCommon.signTypedData(domain, types, value);
+  }
+
+  public getSupportedChains(): number[] {
+    return this.hinkalCommon.getSupportedChains();
+  }
+
+  public isSelectedNetworkSupported(chainId: number): boolean {
+    return this.hinkalCommon.isSelectedNetworkSupported(chainId);
+  }
+
+  public switchNetwork(chainId: number): Promise<unknown> {
+    const network = networkRegistry[chainId];
+    if (!network) throw new Error(`Network with chainId ${chainId} not supported`);
+    return this.hinkalCommon.switchNetwork(network);
+  }
+
+  public resetMerkle(chainIdsToReset?: number[]): Promise<void> {
+    return this.hinkalCommon.resetMerkle(chainIdsToReset);
+  }
+
+  public resetMerkleTreesIfNecessary(chainIdsToCheck?: number[]): Promise<void> {
+    return this.hinkalCommon.resetMerkleTreesIfNecessary(chainIdsToCheck);
+  }
+
+  public get privateBalancesWithUSD(): PrivateBalancesState {
+    return this.hinkalCommon.privateBalancesWithUSD;
+  }
+
+  public onPrivateBalancesWithUSDChange(callback: (state: PrivateBalancesState) => void): () => void {
+    return this.hinkalCommon.onPrivateBalancesWithUSDChange(callback);
+  }
+
+  public getTotalBalance(
+    chainId: number,
+    resetCacheBefore = false,
+    updateTokensListBefore = false,
+  ): Promise<TokenBalance[]> {
+    return this.hinkalCommon.getTotalBalance(chainId, undefined, undefined, resetCacheBefore, updateTokensListBefore);
+  }
+
+  public getStuckShieldedBalances(
+    chainId: number,
+    resetCacheBefore = false,
+    updateTokensListBefore = false,
+  ): Promise<TokenBalance[]> {
+    return this.hinkalCommon.getStuckShieldedBalances(
+      chainId,
+      undefined,
+      undefined,
+      resetCacheBefore,
+      updateTokensListBefore,
+    );
+  }
+
+  public monitorConnectedAddress(chainId: number): Promise<void> {
+    return this.hinkalCommon.monitorConnectedAddress(chainId);
+  }
+
+  public getSupportedPassportLinks(): string[] {
+    return this.hinkalCommon.getSupportedPassportLinks();
+  }
+
+  public checkAccessToken(chainId: number, accessKeyOverride?: string): Promise<boolean> {
+    return this.hinkalCommon.checkAccessToken(chainId, accessKeyOverride);
+  }
+
+  public waitForTransaction(chainId: number, transactionHash: string, confirmations?: number): Promise<boolean> {
+    return this.hinkalCommon.waitForTransaction(chainId, transactionHash, confirmations);
+  }
+
+  // --- Address functions ---
+  public getSolanaPublicKey(): PublicKey {
+    return this.hinkalCommon.getSolanaPublicKey();
+  }
+
+  public getEthereumAddress(): Promise<string> {
+    return this.hinkalCommon.getEthereumAddress();
+  }
+
+  public getEthereumAddressByChain(chainId: number): Promise<string> {
+    return this.hinkalCommon.getEthereumAddressByChain(chainId);
+  }
+
+  public getRecipientInfo(): string {
+    return this.hinkalCommon.getRecipientInfo();
+  }
+
+  public getShieldedPublicKey(): string {
+    return this.hinkalCommon.userKeys.getShieldedPublicKey();
+  }
+
+  // --- Transaction functions ---
+  public prooflessDeposit(
+    erc20Tokens: ERC20Token[],
+    amountChanges: bigint[],
+    stealthAddressStructures?: StealthAddressStructure[],
+  ): Promise<string> {
+    return this.hinkalCommon.prooflessDeposit(erc20Tokens, amountChanges, stealthAddressStructures);
+  }
+
+  public deposit(
+    erc20Tokens: ERC20Token[],
+    amountChanges: bigint[],
+    preEstimateGas?: boolean,
+    returnTxData?: boolean,
+  ): Promise<ethers.TransactionResponse | ethers.TransactionRequest> {
+    return this.hinkalCommon.deposit(erc20Tokens, amountChanges, preEstimateGas, returnTxData);
+  }
+
+  public depositSolana(amount: bigint, token: ERC20Token): Promise<string> {
+    return this.hinkalCommon.depositSolana(amount, token);
+  }
+
+  public depositForOther(
+    erc20Tokens: ERC20Token[],
+    amountChanges: bigint[],
+    recipientInfo: string,
+    preEstimateGas?: boolean,
+    returnTxData?: boolean,
+  ): Promise<ethers.TransactionResponse | ethers.TransactionRequest> {
+    return this.hinkalCommon.depositForOther(erc20Tokens, amountChanges, recipientInfo, preEstimateGas, returnTxData);
+  }
+
+  public depositSolanaForOther(amount: bigint, token: ERC20Token, recipientInfo: string): Promise<string> {
+    return this.hinkalCommon.depositSolanaForOther(amount, token, recipientInfo);
+  }
+
+  public depositAndWithdraw(
+    erc20Token: ERC20Token,
+    recipientAmounts: bigint[],
+    recipientAddresses: string[],
+    txCompletionTime?: number,
+    feeStructureOverride?: FeeStructure,
+    preEstimateGas?: boolean,
+  ): Promise<string> {
+    return this.hinkalCommon.depositAndWithdraw(
+      erc20Token,
+      recipientAmounts,
+      recipientAddresses,
+      txCompletionTime,
+      feeStructureOverride,
+      undefined,
+      undefined,
+      undefined,
+      preEstimateGas,
+    );
+  }
+
+  public depositAndBridge(
+    erc20Token: ERC20Token,
+    recipientBridges: BridgeRecipient[],
+    txCompletionTime?: number,
+    feeStructureOverride?: FeeStructure,
+    preEstimateGas?: boolean,
+  ): Promise<string> {
+    return this.hinkalCommon.depositAndBridge(
+      erc20Token,
+      recipientBridges,
+      txCompletionTime,
+      feeStructureOverride,
+      undefined,
+      undefined,
+      undefined,
+      preEstimateGas,
+    );
+  }
+
+  public claimUtxo(erc20Token: ERC20Token, utxo: Utxo, feeStructureOverride?: FeeStructure): Promise<string> {
+    return this.hinkalCommon.claimUtxo(erc20Token, utxo, feeStructureOverride);
+  }
+
+  public transfer(
+    erc20Tokens: ERC20Token[],
+    amountChanges: bigint[],
+    recipientAddress: string,
+    feeToken?: string,
+    feeStructureOverride?: FeeStructure,
+  ): Promise<string> {
+    return this.hinkalCommon.transfer(erc20Tokens, amountChanges, recipientAddress, feeToken, feeStructureOverride);
+  }
+
+  public withdraw(
+    erc20Tokens: ERC20Token[],
+    deltaAmounts: bigint[],
+    recipientAddress: string,
+    isRelayerOff: boolean,
+    feeToken?: string,
+    feeStructureOverride?: FeeStructure,
+  ): Promise<ethers.TransactionResponse | string> {
+    return this.hinkalCommon.withdraw(
+      erc20Tokens,
+      deltaAmounts,
+      recipientAddress,
+      isRelayerOff,
+      feeToken,
+      feeStructureOverride,
+    );
+  }
+
+  public withdrawStuckUtxos(erc20Token: ERC20Token, recipientAddress: string): Promise<string[]> {
+    return this.hinkalCommon.withdrawStuckUtxos(erc20Token, recipientAddress);
+  }
+
+  public swap(
+    erc20Tokens: ERC20Token[],
+    deltaAmounts: bigint[],
+    externalActionId: ExternalActionId,
+    swapData: string,
+    feeToken?: string,
+    feeStructureOverride?: FeeStructure,
+  ): Promise<string> {
+    return this.hinkalCommon.swap(
+      erc20Tokens,
+      deltaAmounts,
+      externalActionId,
+      swapData,
+      feeToken,
+      feeStructureOverride,
+    );
+  }
+
+  public actionPrivateWallet(
+    chainId: number,
+    erc20Tokens: ERC20Token[],
+    deltaAmounts: bigint[],
+    onChainCreation: boolean[],
+    ops: string[],
+    emporiumTokenChanges: TokenChanges<bigint>[],
+    subAccount?: SubAccount,
+    feeToken?: string,
+    feeStructureOverride?: FeeStructure,
+  ): Promise<string> {
+    return this.hinkalCommon.actionPrivateWallet(
+      chainId,
+      erc20Tokens,
+      deltaAmounts,
+      onChainCreation,
+      ops,
+      emporiumTokenChanges,
+      subAccount,
+      feeToken,
+      feeStructureOverride,
+    );
+  }
+
+  public proxySwap(
+    erc20Tokens: ERC20Token[],
+    deltaAmounts: bigint[],
+    externalActionId: ExternalActionId,
+    swapData: string,
+    isTheSameChainSwap: boolean,
+    subAccount: SubAccount,
+    feeToken?: string,
+    feeStructureOverride?: FeeStructure,
+  ): Promise<string> {
+    return this.hinkalCommon.proxySwap(
+      erc20Tokens,
+      deltaAmounts,
+      externalActionId,
+      swapData,
+      isTheSameChainSwap,
+      subAccount,
+      feeToken,
+      feeStructureOverride,
+    );
+  }
+
+  public proxyToPrivate(
+    erc20Tokens: ERC20Token[],
+    deltaAmountsBase: bigint[],
+    subAccount: SubAccount,
+    recipientInfo: string,
+    feeToken?: string,
+    feeStructureOverride?: FeeStructure,
+  ): Promise<string> {
+    return this.hinkalCommon.proxyToPrivate(
+      erc20Tokens,
+      deltaAmountsBase,
+      subAccount,
+      recipientInfo,
+      feeToken,
+      feeStructureOverride,
+    );
+  }
+
+  public proxySend(
+    erc20Tokens: ERC20Token[],
+    amounts: bigint[],
+    subAccount: SubAccount,
+    recipientAddress: string,
+    feeToken?: string,
+    feeStructureOverride?: FeeStructure,
+  ): Promise<string> {
+    return this.hinkalCommon.proxySend(
+      erc20Tokens,
+      amounts,
+      subAccount,
+      recipientAddress,
+      feeToken,
+      feeStructureOverride,
+    );
+  }
+}

package/src/types/IHinkal.ts

@@ -0,0 +1,193 @@
+import type { PrivateBalancesState } from '@hinkal/common/types';
+import {
+  BridgeRecipient,
+  ERC20Token,
+  ExternalActionId,
+  FeeStructure,
+  LoginMessageMode,
+  StealthAddressStructure,
+  SubAccount,
+  TokenBalance,
+  TokenChanges,
+} from '@hinkal/common/types';
+import { ethers, TypedDataDomain, TypedDataField } from 'ethers';
+import { Utxo } from '@hinkal/common/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>;
+
+  // --- Address ---
+  getSolanaPublicKey(): PublicKey;
+  getEthereumAddress(): Promise<string>;
+  getEthereumAddressByChain(chainId: number): Promise<string>;
+  getRecipientInfo(): string;
+  getShieldedPublicKey(): string;
+
+  // --- Transactions ---
+  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/src/types/IProviderAdapter.ts

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

package/src/types/balances.types.ts

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

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

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

package/src/types/fee.types.ts

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

package/src/types/privateTypes.ts

@@ -0,0 +1,8 @@
+// Dont export this file from the SDK, It's for internal use only
+
+import { IHinkal } from './IHinkal';
+import { IHinkal as IHinkalCommon } from '@hinkal/common/data-structures/Hinkal/IHinkal';
+
+export type IHinkalSDK<ConnectorType = unknown> = IHinkal<ConnectorType> & {
+  hinkalCommon: IHinkalCommon<ConnectorType>;
+};

package/src/types/token.types.ts

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

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "declaration": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/libs/shared/sdk",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts", "copyPackageJson.d.ts", "handleCDNWorkers.d.ts"],
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,14 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "module": "CommonJS",
+    "esModuleInterop": true,
+    "types": ["jest", "node"],
+    "moduleResolution": "Node16",
+    "paths": {
+      "@hinkal/sdk": ["./src/index.ts"]
+    }
+  },
+  "include": ["jest.config.ts", "src/**/*.test.ts", "src/**/*.spec.ts", "src/**/*.d.ts"]
+}