@sign-global/tokentable 0.4.0 → 0.4.1-beta.0

package/dist/esm/wallets/providers/ton/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/wallets/providers/ton/index.tsx"],"names":[],"mappings":";AAAA,OAAO,EAAa,SAAS,EAAE,MAAM,OAAO,CAAC;AAC7C,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,YAAY,EACZ,kBAAkB,EAEnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAEzE,OAAO,EAAE,SAAS,EAAE,CAAC;AAErB,MAAM,CAAC,MAAM,YAAY,GAAG,GAAG,EAAE;IAC/B,MAAM,MAAM,GAAG,YAAY,EAAE,CAAC;IAC9B,MAAM,CAAC,YAAY,CAAC,GAAG,eAAe,EAAE,CAAC;IACzC,MAAM,YAAY,GAAG,kBAAkB,EAAE,CAAC;IAE1C,QAAQ,CAAC,YAAY,GAAG,YAAY,CAAC;IACrC,QAAQ,CAAC,YAAY,GAAG,YAAY,CAAC;IACrC,QAAQ,CAAC,OAAO,GAAG,MAAM,CAAC;IAE1B,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,MAAM,EAAE,CAAC;YACX,QAAQ,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,MAAM,CAAC,CAAC;QACvC,CAAC;IACH,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;IAEb,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,EAAE,QAAQ,EAAE,MAAM,EAA8D,EAAE,EAAE;IAC9G,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC;IAEzB,OAAO,CACL,MAAC,oBAAoB,OAAK,MAAM,aAC7B,QAAQ,EACT,KAAC,YAAY,KAAG,IACK,CACxB,CAAC;AACJ,CAAC,CAAC"}

package/dist/esm/wallets/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/wallets/types.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,UAYX;AAZD,WAAY,UAAU;IACpB,yBAAW,CAAA;IACX,iCAAmB,CAAA;IACnB,+BAAiB,CAAA;IACjB,yBAAW,CAAA;IACX,6BAAe,CAAA;IACf,uCAAyB,CAAA;IACzB,yBAAW,CAAA;IACX,6BAAe,CAAA;IACf,mCAAqB,CAAA;IACrB,6CAA+B,CAAA;IAC/B,iCAAmB,CAAA;AACrB,CAAC,EAZW,UAAU,KAAV,UAAU,QAYrB;AAED,MAAM,CAAN,IAAY,SAKX;AALD,WAAY,SAAS;IACnB,wBAAW,CAAA;IACX,wBAAW,CAAA;IACX,yBAAyB;IACzB,8BAAiB,CAAA;AACnB,CAAC,EALW,SAAS,KAAT,SAAS,QAKpB;AACD,MAAM,CAAN,IAAY,kBAGX;AAHD,WAAY,kBAAkB;IAC5B,uCAAiB,CAAA;IACjB,wCAAkB,CAAA;AACpB,CAAC,EAHW,kBAAkB,KAAlB,kBAAkB,QAG7B"}

package/dist/esm/wallets/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/wallets/utils/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAExC,MAAM,CAAC,MAAM,eAAe,GAAG,GAAW,EAAE;IAC1C,MAAM,MAAM,GAAG,cAAc,CAAC,sCAAsC,EAAE,EAAE,CAAC,CAAC;IAC1E,OAAO,MAAM,EAAE,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,UAAU,kBAAkB,CAAC,EACjC,OAAO,EACP,OAAO,EACP,SAAS,EAKV;IACC,OAAO;QACL,SAAS,EAAE,SAAS,IAAI,oBAAoB;QAC5C,OAAO,EAAE,OAAO;QAChB,OAAO,EAAE,OAAO;QAChB,QAAQ,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QAClC,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,IAAI;QAC5B,GAAG,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM;QAC3B,OAAO,EAAE,GAAG;QACZ,KAAK,EAAE,eAAe,EAAE;KACzB,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,EAC7B,MAAM,EACN,OAAO,EACP,KAAK,EACL,QAAQ,EACR,SAAS,EACT,OAAO,EACP,GAAG,EACH,OAAO,EACQ,EAAU,EAAE;IAC3B,MAAM,MAAM,GAAG,GAAG,MAAM,mDAAmD,CAAC;IAC5E,MAAM,QAAQ,GAAG,QAAQ,GAAG,EAAE,CAAC;IAC/B,IAAI,MAAM,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1C,MAAM,YAAY,GAAG,YAAY,OAAO,EAAE,CAAC;IAE3C,8CAA8C;IAE9C,MAAM,UAAU,GAAG,YAAY,GAAG,OAAO,IAAI,GAAG,CAAC;IAEjD,MAAM,UAAU,GAAG,UAAU,KAAK,EAAE,CAAC;IAErC,MAAM,WAAW,GAAG,CAAC,QAAQ,EAAE,YAAY,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC;IAErE,WAAW,CAAC,IAAI,CAAC,cAAc,QAAQ,EAAE,CAAC,CAAC;IAE3C,MAAM,MAAM,GAAG,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACtC,MAAM,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1C,IAAI,SAAS,EAAE,CAAC;QACd,MAAM,IAAI,IAAI,CAAC;IACjB,CAAC;IACD,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACrC,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sign-global/tokentable",
-  "version": "0.4.0",
+  "version": "0.4.1-beta.0",
   "publishConfig": {
     "access": "public"
   },
@@ -17,6 +17,8 @@
   "author": "Evan",
   "license": "ISC",
   "dependencies": {
+    "@coral-xyz/anchor": "^0.30.1",
+    "@solana/spl-token": "^0.4.12",
     "@ethsign/utils-web": "^0.8.9",
     "@orbs-network/ton-access": "^2.3.3",
     "@rainbow-me/rainbowkit": "^2.2.3",
@@ -34,7 +36,7 @@
     "dayjs": "^1.11.13",
     "jest": "^29.7.0",
     "nanoid": "^5.0.9",
-    "react": "^19.0.0",
+    "react": "^18.2.0",
     "ton-core": "^0.53.0",
     "tonapi-sdk-js": "^2.0.3",
     "tonweb": "^0.0.66",
@@ -43,7 +45,7 @@
     "wagmi": "^2.13.0"
   },
   "devDependencies": {
-    "@types/react": "^19.0.8",
+    "@types/react": "^18.2.0",
     "bun-types": "latest",
     "typescript": "^5.6.3"
   }

package/src/airdrop/AirdropClient.ts

@@ -32,7 +32,11 @@ export class AirdropClient {
     }
     this.projectId = params.projectId;
     this.endpoint = params.endpoint;
-    this.projectPromise = this.initializeProjects();
+    if (this.project) {
+      this.project = params.project;
+    } else {
+      this.projectPromise = this.initializeProjects();
+    }
   }
 
   setTonClient(tonClient: TonClient) {
@@ -84,7 +88,9 @@ export class AirdropClient {
   }
 
   async getProjectInfo() {
-    await this.projectPromise;
+    if (this.projectPromise) {
+      await this.projectPromise;
+    }
     if (!this.project) throw new Error('Project not found');
     return this.project;
   }

package/src/airdrop/SignatureAirdropClient.ts

@@ -1,25 +1,49 @@
+import { getAddress } from 'viem';
 import { CONST } from './constants';
-import { WalletFactory } from './core/useWeb3ConnectWallet';
-import { ChainType } from './core/useWeb3ConnectWallet/types';
-import { bindWallet, connectTwitter, getAirdropProject } from './services';
-import { AirdropSigIdentityTypeEnum, IAirdropOptions, IProject } from './types';
+import { EvmSignatureAirdropService, SolanaSignatureAirdropService } from './contracts';
+import { WalletFactory } from '../wallets';
+import { ChainType } from '../wallets/types';
+import {
+  bindWallet,
+  checkEligibility,
+  checkGetSignatures,
+  connectTwitter,
+  disconnectRecipient,
+  getAirdropProject
+} from './services';
+import {
+  AirdropSigIdentityTypeEnum,
+  ChainId,
+  ErrorCode,
+  IAirdropOptions,
+  IAirdropSignatureClaim,
+  IAirdropSignatureIdentity,
+  IClaimSignature,
+  IProject,
+  IWalletClient
+} from './types';
 
 export class SignatureAirdropClient {
-  private slug?: string;
   private projectId?: string;
   private endpoint?: string;
   private project: IProject | undefined;
-  protected claims?: any[];
+  protected claims?: IAirdropSignatureClaim[];
+  protected identities?: IAirdropSignatureIdentity[];
   private projectPromise: Promise<void> | undefined;
-  private claimHook: ((v: any) => any) | undefined;
-  //   private contractConfig: IContractConfig | null = null;
   constructor(params: IAirdropOptions) {
-    if ('slug' in params) {
-      this.slug = params.slug;
-    }
     this.projectId = params.projectId;
     this.endpoint = params.endpoint;
-    this.projectPromise = this.initializeProjects();
+    if (this.project) {
+      this.project = params.project;
+    } else {
+      this.projectPromise = this.initializeProjects();
+    }
+  }
+
+  private readonly LOCAL_STORAGE_SID_PREFIX = 'sid_';
+
+  private setSid(projectId: string, sid: string): void {
+    window.localStorage.setItem(`${this.LOCAL_STORAGE_SID_PREFIX}${projectId}`, sid);
   }
 
   private async fetchProjectDetails(projectId: string): Promise<void> {
@@ -34,7 +58,6 @@ export class SignatureAirdropClient {
         return;
       }
 
-      // Fetch project details
       await this.fetchProjectDetails(projectId);
     } catch (error: any) {
       throw new Error(`Failed to initialize project: ${error.message}`);
@@ -42,7 +65,9 @@ export class SignatureAirdropClient {
   }
 
   async getProjectInfo() {
-    await this.projectPromise;
+    if (this.projectPromise) {
+      await this.projectPromise;
+    }
     if (!this.project) throw new Error('Project not found');
     return this.project;
   }
@@ -51,13 +76,14 @@ export class SignatureAirdropClient {
     const project = await this.getProjectInfo();
     const onWindowMessage = async (message: any) => {
       if (message.data.name && message.data.name === CONST.TWITTER_AUTH_SUCCESS) {
-        const { isError, code, redirectUri } = message.data.data || {};
+        const { code } = message.data.data || {};
         try {
-          await connectTwitter({ code, redirectUri: redirectUri }, this.endpoint);
-          onSuccess();
-          if (isError) {
-            onError();
+          const res = await connectTwitter({ code, projectId: project.id }, this.endpoint);
+
+          if (res?.sid) {
+            this.setSid(project.id, res?.sid);
           }
+          onSuccess();
         } catch (error) {
           onError();
         } finally {
@@ -70,7 +96,7 @@ export class SignatureAirdropClient {
     const authorizeUrl = project.identities.find(
       (item: any) => item.identityType === AirdropSigIdentityTypeEnum.Twitter
     )?.authorizeUrl;
-    window.open(authorizeUrl + '&state=state', '_blank', 'width=600,height=800');
+    window.open(authorizeUrl + '&state=state', `twitter_auth_${project.id}`, 'width=600,height=800');
   }
 
   async connectWallet({
@@ -79,37 +105,187 @@ export class SignatureAirdropClient {
     onError
   }: {
     chainType: ChainType;
-    onSuccess: () => void;
-    onError: (error: any) => void;
+    onSuccess?: () => void;
+    onError?: (error: any) => void;
   }) {
     try {
       const project = await this.getProjectInfo();
       const wallet = WalletFactory.getWallet(chainType);
-      const signResult = await wallet.signin(CONST.WELCOME_SIGNATURE_STATEMENT);
-
-      const { message, signature } = signResult || {};
-
+      const timestamp = Date.now();
       const recipientTypeMap = {
         [ChainType.Evm]: AirdropSigIdentityTypeEnum.EVMWallet,
         [ChainType.Solana]: AirdropSigIdentityTypeEnum.SolanaWallet,
-        [ChainType.Ton]: ''
+        [ChainType.Ton]: AirdropSigIdentityTypeEnum.TONWallet
       };
+      console.log(recipientTypeMap, recipientTypeMap[chainType], 'chain');
+      const msg = [project.id, recipientTypeMap[chainType], timestamp].join(',');
+      const signResult = await wallet.signin(msg, false);
+      await wallet.disconnect();
+      const { message, signature } = signResult || {};
+
+      if (this.identities?.find((it) => it.value?.toLowerCase() === wallet.address?.toLowerCase())) {
+        onError?.(ErrorCode.WALLET_ALREADY_CONNECTED);
+        return;
+      }
 
       const payload = {
         signature: signature as string,
         message: message as string,
         key: wallet.publicKey || wallet.address!,
+        address: wallet.address!,
         projectId: project.id,
-        timestamp: Date.now(),
+        timestamp: timestamp,
         recipientType: recipientTypeMap[chainType]
       };
 
-      await bindWallet(payload, this.endpoint);
-      onSuccess();
+      const res = await bindWallet(payload, this.endpoint);
+      if (res?.sid) {
+        this.setSid(project.id, res?.sid);
+      }
+      onSuccess?.();
     } catch (error) {
-      onError(error);
-    } finally {
-      onSuccess();
+      onError?.(error);
+    }
+  }
+
+  async getClaims() {
+    const project = await this.getProjectInfo();
+    const res = await checkEligibility(
+      {
+        projectId: project.id
+      },
+      this.endpoint
+    );
+    this.claims = res.claims;
+    this.identities = res.identities;
+    return res;
+  }
+
+  public async disconnectIdentity({
+    recipientType,
+    recipient
+  }: {
+    recipientType: AirdropSigIdentityTypeEnum;
+    recipient?: string;
+  }) {
+    const project = await this.getProjectInfo();
+    return await disconnectRecipient(
+      {
+        projectId: project.id,
+        recipientType,
+        recipient
+      },
+      this.endpoint
+    );
+  }
+
+  public async getStrategy(
+    walletClient?: IWalletClient
+  ): Promise<EvmSignatureAirdropService | SolanaSignatureAirdropService> {
+    const project = await this.getProjectInfo();
+
+    if (project.chainType === ChainType.Solana) {
+      return new SolanaSignatureAirdropService({
+        chainId: project.chainId,
+        projectId: project.id,
+        token: project.tokenAddress,
+        walletClient: walletClient as any
+      });
+    }
+    return new EvmSignatureAirdropService({
+      chainId: Number(project.chainId) as ChainId,
+      contractAddress: project.contractAddress,
+      walletClient: walletClient as any
+    });
+  }
+
+  async getVersion(): Promise<string> {
+    const strategy = await this.getStrategy();
+    return strategy.getVersion();
+  }
+
+  async getClaimFee(amount?: bigint): Promise<undefined | bigint> {
+    const strategy = await this.getStrategy();
+    if (!strategy.getClaimFee) {
+      throw new Error('getClaimFee is not supported for this chain');
+    }
+    return await strategy.getClaimFee(this.project?.contractAddress || '', amount || BigInt(1));
+  }
+
+  async claimAirdrop({
+    claimIds,
+    walletClient,
+    recipient
+  }: {
+    claimIds: string[];
+    walletClient: IWalletClient;
+    recipient?: string;
+  }) {
+    if (!claimIds.length) {
+      throw new Error('Claim IDs cannot be empty');
+    }
+    if (!walletClient) {
+      throw new Error('Wallet client is required');
+    }
+    if (!this.claims?.length) {
+      throw new Error('No claims available');
+    }
+    const service = await this.getStrategy(walletClient);
+    const res = await checkGetSignatures(
+      {
+        claimIds,
+        projectId: this.projectId!
+      },
+      this.endpoint
+    );
+    if (!res?.signatures?.length) {
+      throw new Error('Failed to get signatures');
+    }
+    const signatureMap = res?.signatures?.reduce((map, item) => {
+      map[item.claimId] = item;
+      return map;
+    }, {} as Record<string, IClaimSignature>);
+    const filteredClaims = this.claims.filter((it) => claimIds.includes(it.claimId));
+    if (!filteredClaims.length) {
+      throw new Error('No matching claims found');
+    }
+
+    const claimData = filteredClaims.map((it) => {
+      const signature = signatureMap[it.claimId];
+      if (!signature) {
+        throw new Error(`Signature not found for claim ID: ${it.claimId}`);
+      }
+
+      return {
+        ...it,
+        recipient: recipient ? recipient : walletClient.account?.address!,
+        ...signature
+      };
+    });
+    const delegateMode = recipient ? getAddress(recipient) !== walletClient.account?.address : false;
+    const feeData = (await this.getClaimFee(1n)) || 0n;
+    const hash = (await service!.claim(
+      claimData,
+      delegateMode ? feeData * BigInt(claimData.length) : feeData
+    )) as `0x${string}`;
+    return hash;
+  }
+
+  async batchCheckClaimed(): Promise<boolean[]> {
+    if (!this.claims?.length) return [];
+    const strategy = await this.getStrategy();
+    if (!strategy.batchFetchClaimed) {
+      throw new Error('batchCheckClaimed is not supported for this chain');
+    }
+    const claimIds = this.claims?.map((it) => it.claimId);
+    return strategy.batchFetchClaimed(claimIds);
+  }
+
+  async getPaused(): Promise<boolean> {
+    const strategy = await this.getStrategy();
+    if (!strategy.getPaused) {
+      throw new Error('getPaused is not supported for this chain');
     }
+    return strategy.getPaused();
   }
 }

package/src/airdrop/contracts/evm/SignatureAirdropService.ts

@@ -0,0 +1,94 @@
+import { ZERO_ADDRESS } from '../../constants';
+import { ChainId, EvmContractClientOption } from '../../types';
+import { AirdropSignatureClient } from './contracts/AirdropSignatureClient';
+import { DeployerClient } from './contracts/DeployClient';
+import { FeeCollectorClient } from './contracts/FeeCollectorClient';
+
+export class SignatureAirdropService {
+  options: EvmContractClientOption;
+  constructor(options: EvmContractClientOption) {
+    this.options = options;
+  }
+
+  private get airdropClient(): AirdropSignatureClient {
+    if (!this.options) {
+      throw new Error('options is empty');
+    }
+
+    return new AirdropSignatureClient(this.options);
+  }
+
+  async getDeployerClient(): Promise<DeployerClient> {
+    const deployer = await this.getDeployer();
+    return new DeployerClient({
+      ...this.options,
+      contractAddress: deployer
+    });
+  }
+
+  private getFeeClient(address: string): FeeCollectorClient {
+    if (!this.options) {
+      throw new Error('options is empty');
+    }
+
+    return new FeeCollectorClient({
+      ...this.options,
+      chainId: this.options.chainId as ChainId,
+      contractAddress: address
+    });
+  }
+
+  async getDeployer() {
+    return this.airdropClient.getDeployer();
+  }
+
+  async getVersion() {
+    return this.airdropClient.getVersion();
+  }
+
+  feeCollectors = async (address: string) => {
+    const deployerClient = await this.getDeployerClient();
+    return await deployerClient.feeCollectors(address);
+  };
+
+  feeTokens = async (address: string) => {
+    const deployerClient = await this.getDeployerClient();
+    return await deployerClient.feeTokens(address);
+  };
+
+  async getFeelessThreshold() {
+    // return this.airdropClient.getFeelessThreshold();
+  }
+
+  async getClaimFee(address: string, amount: bigint): Promise<bigint | undefined> {
+    const feeCollector = await this.feeCollectors(this.options.contractAddress as string);
+    if (!feeCollector || feeCollector === ZERO_ADDRESS) {
+      return undefined;
+    }
+    const feeClient = this.getFeeClient(feeCollector as string);
+    const fee = (await feeClient.getFee(address, amount)) as bigint;
+    return fee;
+  }
+
+  async batchFetchClaimed(userClaimIds: string[]): Promise<boolean[]> {
+    const res = await this.airdropClient.batchFetchClaimed(userClaimIds);
+    return res;
+  }
+
+  async getPaused() {
+    return this.airdropClient.getPaused();
+  }
+
+  async claim(
+    data: {
+      recipient: string;
+      claimId: string;
+      data: string;
+      signature: string;
+      extraData?: string;
+    }[],
+    value?: bigint
+  ) {
+    return this.airdropClient.claim(data, value);
+  }
+}

package/src/airdrop/contracts/evm/contracts/AirdropSignatureClient.ts

@@ -0,0 +1,61 @@
+import { EvmContractClientOption } from '../../../types';
+import ABI from './abis/FungibleTokenECDSADistributor.json';
+import { ContractBaseClient } from './ContractBaseClient';
+
+export class AirdropSignatureClient extends ContractBaseClient {
+  constructor(options: EvmContractClientOption) {
+    super({
+      ...options,
+      abi: ABI
+    });
+  }
+
+  async getClaimStatus(userClaimId: string) {
+    return this.readContract({ functionName: 'getClaimStatus', args: [userClaimId] });
+  }
+
+  async claim(
+    data: {
+      recipient: string;
+      data: string;
+      claimId: string;
+      signature: string;
+      extraData?: string;
+    }[],
+    value?: bigint
+  ) {
+    const [recipients = [], userClaimIds = [], datas = [], signatures = [], extraDatas = []] = [
+      'recipient',
+      'claimId',
+      'data',
+      'signature',
+      'extraData'
+    ].map((key) => data.map((item) => item[key as keyof (typeof data)[0]] || ''));
+
+    return this.writeContract({
+      functionName: 'claim',
+      args: [recipients, userClaimIds, datas, signatures, extraDatas],
+      value: value || 0n
+    });
+  }
+
+  async batchFetchClaimed(userClaimIds: string[]) {
+    const res = (await this.readContract({ functionName: 'getClaimStatus', args: [userClaimIds] })) as boolean[];
+    return res;
+  }
+
+  async getDeployer() {
+    const res = (await this.readContract({ functionName: 'getStorage' })) as any[];
+    return res?.[3] as string;
+  }
+
+  async getVersion() {
+    const res = (await this.readContract({ functionName: 'getStorage' })) as any[];
+    return res?.[0];
+  }
+
+  async getPaused() {
+    const res = (await this.readContract({ functionName: 'getStorage' })) as any[];
+    return res?.[2] as boolean;
+  }
+}