@sign-global/tokentable 0.4.2-beta.2 → 0.4.2-beta.4

package/src/airdrop/services/wallet-service/ton/WalletService.ts

@@ -1,226 +0,0 @@
-import TonWeb from 'tonweb';
-import { Address } from '@ton/core';
-import { JettonMaster, TonClient } from '@ton/ton';
-import { delay, flipAddressType } from '../../../../utils';
-
-import { Api, HttpClient, Event } from 'tonapi-sdk-js';
-import { ChainConfig } from '../../../constants';
-import { getJettonInfo } from '../../index';
-import { CHAIN } from '@tonconnect/ui-react';
-// import { getHttpEndpoint } from '@orbs-network/ton-access';
-// import { CHAIN } from '@tonconnect/ui-react';
-
-interface WaitForTransactionOptions {
-  address: string;
-  hash: string;
-  refetchInterval?: number;
-  refetchLimit?: number;
-  chainId: string;
-  contractAddress?: string;
-}
-
-export abstract class TonWalletService {
-  // static walletClient = tonStore.walletClient;
-
-  static disconnect() {
-    //
-  }
-
-  static async getTonClient(chainId: string) {
-    const endpoint = ChainConfig[chainId as keyof typeof ChainConfig].rpcUrl;
-    // const endpoint = await getHttpEndpoint({ network: chainId === CHAIN.TESTNET ? 'testnet' : 'mainnet' });
-    return new TonClient({
-      endpoint: endpoint
-    });
-  }
-
-  static getTonApiClient(chainId: string) {
-    const { tonApiPrefix } = ChainConfig[chainId as keyof typeof ChainConfig] as any;
-
-    const httpClient = new HttpClient({
-      baseUrl: tonApiPrefix
-      // baseApiParams: {
-      //   headers: {
-      //     Authorization: `Bearer ${tonApiKey}`,
-      //     'Content-type': 'application/json'
-      //   }
-      // }
-    });
-
-    const client = new Api(httpClient);
-    return client;
-  }
-
-  static waitForTransactionByClient = async (options: WaitForTransactionOptions): Promise<Event | null> => {
-    const { hash, refetchInterval = 3000, refetchLimit, chainId } = options;
-
-    return new Promise((resolve) => {
-      let refetches = 0;
-      const interval = setInterval(async () => {
-        refetches += 1;
-
-        console.log(hash, 'waiting transaction...');
-        const tonApi = this.getTonApiClient(chainId);
-        const events = await tonApi.events.getEvent(hash);
-        console.log(events, 'traceData');
-        if (!events.in_progress) {
-          await delay(3000);
-          clearInterval(interval);
-          resolve(events);
-        }
-        if (refetchLimit && refetches >= refetchLimit) {
-          clearInterval(interval);
-          resolve(null);
-        }
-      }, refetchInterval);
-    });
-  };
-
-  static waitForTransactionLegacy = async (options: WaitForTransactionOptions): Promise<Event | null> => {
-    const { refetchInterval = 3000, refetchLimit, chainId, address, contractAddress } = options;
-
-    const tonApi = this.getTonApiClient(chainId);
-    const tonClient = await this.getTonClient(chainId);
-    const walletAddress = Address.parse(address);
-
-    return new Promise((resolve) => {
-      let refetches = 0;
-      const interval = setInterval(async () => {
-        refetches += 1;
-
-        console.log('waiting transaction...');
-
-        let hash;
-
-        if (contractAddress) {
-          const res = await tonApi.accounts.getAccountEvents(address, {
-            limit: 5
-          });
-          const targetTransaction = res.events.find((it) => {
-            return (
-              it.actions.length &&
-              it.actions.find((action) => {
-                return action.simple_preview.accounts.find((ac) => {
-                  return Address.parse(ac.address).toRawString() === Address.parse(contractAddress).toRawString();
-                });
-              })
-            );
-          });
-          console.log(targetTransaction, 'res');
-          if (targetTransaction) {
-            hash = targetTransaction.event_id;
-          }
-        } else {
-          const state = await tonClient.getContractState(walletAddress);
-          console.log(state, 'state');
-          hash = state.lastTransaction?.hash;
-        }
-        if (hash) {
-          const events = await tonApi.events.getEvent(hash);
-          console.log(events, 'events');
-          if (!events.in_progress) {
-            clearInterval(interval);
-            resolve(events);
-          }
-        }
-        if (refetchLimit && refetches >= refetchLimit) {
-          clearInterval(interval);
-          resolve(null);
-        }
-      }, refetchInterval);
-    });
-  };
-
-  static async waitForTransaction({
-    hash,
-    chainId,
-    address,
-    contractAddress
-  }: {
-    hash: string;
-    chainId: string;
-    address: string;
-    contractAddress?: string;
-  }) {
-    return this.waitForTransactionByClient({ hash, address, chainId, contractAddress });
-  }
-
-  static async fetchBalance(args: { chainId: string; address: string; token?: string }) {
-    try {
-      const config = ChainConfig[args.chainId as keyof typeof ChainConfig] as any;
-      const options = { method: 'GET' };
-      const rawAddress = flipAddressType(args.address);
-
-      const url = args.token
-        ? `${config.tonApiPrefix}/v2/accounts/${rawAddress}/jettons?currencies=usd`
-        : `${config.tonApiPrefix}/v2/blockchain/accounts/${rawAddress}`;
-
-      const response = await fetch(url, options);
-      const responseJSON: any = await response.json();
-      const current = args.token
-        ? responseJSON.balances.find((it: any) => it.jetton.address === flipAddressType(args.token!))
-        : { balance: responseJSON.balance / 1000000000 };
-
-      return {
-        value: current?.balance || 0
-      };
-    } catch {
-      return {
-        value: 0
-      };
-    }
-  }
-
-  static async fetchToken(args: { chainId: string; address: string }) {
-    return getJettonInfo({
-      address: args.address,
-      isTestnet: args.chainId === CHAIN.TESTNET ? 'true' : 'false'
-    });
-    // const client = this.getTonApiClient(args.chainId as string);
-    // const data: any = await client.jettons.getJettonInfo(args.address);
-    // const { metadata, total_supply } = data;
-    // return {
-    //   ...metadata,
-    //   totalSupply: {
-    //     value: total_supply,
-    //     formatted: fromNano(total_supply)
-    //   }
-    // };
-  }
-
-  static async signMessage() {}
-
-  static async addChain() {}
-
-  static async fetchEnsAddress() {
-    return '';
-  }
-
-  static validateAddress(address: string) {
-    try {
-      Address.parse(address);
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-
-  static isSameAddress(address1: string, address2: string) {
-    return Address.parse(address1).toRawString() === Address.parse(address2).toRawString();
-  }
-
-  static getJettonAddress = async ({
-    chainId,
-    address,
-    token
-  }: {
-    chainId: string;
-    address: string;
-    token: string;
-  }) => {
-    const client = await this.getTonClient(chainId);
-    const jettonWallet = client.open(JettonMaster.create(Address.parse(token)));
-
-    return jettonWallet.getWalletAddress(Address.parse(address));
-  };
-}

package/src/airdrop/services/wallet-service/ton/index.ts

@@ -1 +0,0 @@
-export { TonWalletService } from './WalletService';

package/src/airdrop/strategies/AirdropStrategyFactory.ts

@@ -1,31 +0,0 @@
-import { ChainType, IWalletClient } from '../types';
-import { EvmAirdropStrategy } from './EvmAirdropStrategy';
-import { IAirdropStrategy, IAirdropStrategyConstructor } from './IAirdropStrategy';
-import { TonAirdropStrategy } from './TonAirdropStrategy';
-import { TonClient } from '@ton/ton';
-
-export class AirdropStrategyFactory {
-  private static strategyMap: Record<ChainType, IAirdropStrategyConstructor | null> = {
-    [ChainType.Evm]: EvmAirdropStrategy,
-    [ChainType.Ton]: TonAirdropStrategy,
-    [ChainType.Solana]: null
-  };
-
-  static createStrategy(params: {
-    chainType: ChainType;
-    contractAddress: string;
-    chainId: string | number;
-    walletClient?: IWalletClient;
-    tonClient?: TonClient;
-    version?: string;
-  }): IAirdropStrategy {
-    const { chainType, ...strategyParams } = params;
-    const StrategyClass = this.strategyMap[chainType];
-
-    if (!StrategyClass) {
-      throw new Error(`Unsupported chain type: ${chainType}`);
-    }
-
-    return new StrategyClass(strategyParams);
-  }
-}

package/src/airdrop/strategies/EvmAirdropStrategy.ts

@@ -1,81 +0,0 @@
-import { EvmAirdropService } from '../contracts';
-import { ChainId, IWalletClient } from '../types';
-import { IAirdropStrategy } from './IAirdropStrategy';
-import { WalletClient as ViemWalletClient } from 'viem';
-
-export class EvmAirdropStrategy implements IAirdropStrategy {
-  private service: EvmAirdropService | undefined;
-  private readonly contractAddress: string;
-  private readonly chainId: ChainId;
-  private walletClient?: ViemWalletClient;
-  private cachedVersion: string | null = null;
-
-  constructor(params: { contractAddress: string; chainId: string | number; walletClient?: IWalletClient }) {
-    this.contractAddress = params.contractAddress;
-    this.chainId = Number(params.chainId) as ChainId;
-    if (params.walletClient) {
-      this.walletClient = params.walletClient as ViemWalletClient;
-    }
-  }
-
-  async initialize(walletClient?: IWalletClient): Promise<void> {
-    if (walletClient) {
-      this.walletClient = walletClient as ViemWalletClient;
-    }
-    this.service = new EvmAirdropService({
-      contractAddress: this.contractAddress,
-      chainId: this.chainId,
-      walletClient: this.walletClient
-    });
-  }
-
-  isInitialized(): boolean {
-    return !!this.service;
-  }
-
-  async getVersion(): Promise<string> {
-    if (this.cachedVersion) {
-      return this.cachedVersion;
-    }
-    if (!this.service) throw new Error('Strategy not initialized');
-    this.cachedVersion = await this.service.getVersion();
-    return this.cachedVersion;
-  }
-
-  async claim(claimData: any): Promise<any> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    const { proof, group, data, value, extraData } = claimData;
-    return this.service.claim({
-      proof,
-      group,
-      data,
-      value,
-      extraData
-    });
-  }
-
-  async checkClaimed(claimData: any): Promise<boolean> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    return this.service.isLeafUsed(claimData.leaf);
-  }
-
-  async batchCheckClaimed(leafs: string[]): Promise<{ result: boolean; status: string }[]> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    return this.service.batchFetchClaimed(leafs);
-  }
-
-  async getNFT(): Promise<string> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    return this.service.getNFT() as unknown as string;
-  }
-
-  async getKycThreshold(): Promise<bigint> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    return this.service.getKycThreshold();
-  }
-
-  async getClaimFee(contractAddress: string, amount: bigint): Promise<bigint> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    return this.service.getClaimFee(contractAddress, amount) as unknown as bigint;
-  }
-}

package/src/airdrop/strategies/IAirdropStrategy.ts

@@ -1,26 +0,0 @@
-import { IWalletClient } from '../types';
-import { TonClient } from '@ton/ton';
-
-export interface IAirdropStrategy {
-  getVersion(): Promise<string>;
-  claim(claimData: any, options?: { onLoading?: () => void }): Promise<any>;
-  checkClaimed(claimData: any): Promise<boolean>;
-  isInitialized(): boolean;
-  initialize(walletClient?: IWalletClient): Promise<void>;
-  getPaused?(): Promise<boolean>;
-  // EVM specific methods
-  batchCheckClaimed?(leafs: string[]): Promise<Array<{ result: boolean; status: string }>>;
-  getNFT?(): Promise<string>;
-  getKycThreshold?(): Promise<bigint>;
-  getClaimFee?(contractAddress: string, amount: bigint): Promise<string | bigint>;
-}
-
-export interface IAirdropStrategyConstructor {
-  new (params: {
-    contractAddress: string;
-    chainId: string | number;
-    walletClient?: IWalletClient;
-    tonClient?: TonClient;
-    version?: string;
-  }): IAirdropStrategy;
-}

package/src/airdrop/strategies/StrategyCache.ts

@@ -1,34 +0,0 @@
-import { IAirdropStrategy } from './IAirdropStrategy';
-
-export class StrategyCache {
-  private readOnlyStrategies: Map<string, IAirdropStrategy> = new Map();
-  private walletStrategies: Map<string, IAirdropStrategy> = new Map();
-
-  private getCacheKey(contractAddress: string, chainId: string | number, chainType: string): string {
-    return `${chainType}:${contractAddress}:${chainId}`;
-  }
-
-  getStrategy(contractAddress: string, chainId: string | number, chainType: string, hasWallet: boolean = false): IAirdropStrategy | undefined {
-    const cache = hasWallet ? this.walletStrategies : this.readOnlyStrategies;
-    const cacheKey = this.getCacheKey(contractAddress, chainId, chainType);
-    return cache.get(cacheKey);
-  }
-
-  setStrategy(contractAddress: string, chainId: string | number, chainType: string, strategy: IAirdropStrategy, hasWallet: boolean = false): void {
-    const cache = hasWallet ? this.walletStrategies : this.readOnlyStrategies;
-    const cacheKey = this.getCacheKey(contractAddress, chainId, chainType);
-    cache.set(cacheKey, strategy);
-  }
-
-  clearStrategy(contractAddress: string, chainId: string | number, chainType: string, hasWallet?: boolean): void {
-    const cacheKey = this.getCacheKey(contractAddress, chainId, chainType);
-    if (hasWallet === undefined || hasWallet) {
-      this.walletStrategies.delete(cacheKey);
-    }
-    if (hasWallet === undefined || !hasWallet) {
-      this.readOnlyStrategies.delete(cacheKey);
-    }
-  }
-}
-
-export const strategyCache = new StrategyCache();

package/src/airdrop/strategies/TonAirdropStrategy.ts

@@ -1,77 +0,0 @@
-import { TonClient } from '@ton/ton';
-import { TonConnectUI } from '@tonconnect/ui-react';
-import { TonAirdropService } from '../contracts';
-import { IWalletClient } from '../types';
-import { IAirdropStrategy } from './IAirdropStrategy';
-
-export class TonAirdropStrategy implements IAirdropStrategy {
-  private service: TonAirdropService | undefined;
-  private readonly contractAddress: string;
-  private readonly chainId: string;
-  private readonly tonClient?: TonClient;
-  private walletClient?: TonConnectUI;
-  private cachedVersion: string | null = null;
-
-  constructor(params: {
-    contractAddress: string;
-    chainId: string | number;
-    walletClient?: IWalletClient;
-    tonClient?: TonClient;
-    version?: string;
-  }) {
-    this.contractAddress = params.contractAddress;
-    this.chainId = params.chainId.toString();
-    this.tonClient = params.tonClient;
-    if (params.walletClient) {
-      this.walletClient = params.walletClient as TonConnectUI;
-    }
-    if (params.version) {
-      this.cachedVersion = params.version;
-    }
-  }
-
-  async initialize(walletClient?: IWalletClient): Promise<void> {
-    if (walletClient) {
-      this.walletClient = walletClient as TonConnectUI;
-    }
-    this.service = new TonAirdropService({
-      address: this.contractAddress,
-      chainId: this.chainId,
-      walletClient: this.walletClient,
-      tonClient: this.tonClient,
-      version: this.cachedVersion || undefined
-    });
-  }
-
-  isInitialized(): boolean {
-    return !!this.service;
-  }
-
-  async getVersion(): Promise<string> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    if (!this.cachedVersion) {
-      this.cachedVersion = await this.service.getVersion();
-    }
-    return this.cachedVersion;
-  }
-
-  async claim(claimData: any, options?: { onLoading?: () => void }): Promise<any> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    return this.service.claim(claimData, options);
-  }
-
-  async checkClaimed(claimData: any): Promise<boolean> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    return this.service.checkClaimed(claimData);
-  }
-
-  async getPaused(): Promise<boolean> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    return this.service.getPaused();
-  }
-
-  async getClaimFee(contractAddress: string, amount: bigint): Promise<string> {
-    if (!this.service) throw new Error('Strategy not initialized');
-    return this.service.getClaimFee(contractAddress, amount);
-  }
-}