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

package/src/airdrop/index.ts

@@ -2,4 +2,3 @@ export { AirdropClient } from './AirdropClient';
 export { SignatureAirdropClient } from './SignatureAirdropClient';
 
 export { CONST } from './constants';
-export * from './core/useWeb3ConnectWallet';

package/src/airdrop/services/index.ts

@@ -1,6 +1,13 @@
 import { apiClient } from '../../utils/api-client';
 import { safeParseJSON } from '../../utils/utils';
-import { IAirdropData, IContractConfig, IProject } from '../types';
+import {
+  AirdropSigIdentityTypeEnum,
+  IAirdropData,
+  IAirdropSignatureData,
+  IClaimSignature,
+  IContractConfig,
+  IProject
+} from '../types';
 
 export { TonWalletService } from './wallet-service/ton';
 
@@ -11,7 +18,7 @@ const createApiClient = (baseURL?: string) => {
 export const getAirdropProject = async (projectId: string, baseURL?: string): Promise<IProject> => {
   const client = createApiClient(baseURL);
   const res = await client.get<any>(`/airdrop-open/projects/${projectId}`);
-  if (!res) return res; // res为null
+  if (!res) return res; // res is null
   const projectConfig = res?.themeConf;
   const blockCountries = safeParseJSON(projectConfig?.blockCountries);
   return {
@@ -70,27 +77,82 @@ export const getJettonInfo = async (
   return client.get(`/airdrop-open/jetton/${data.address}?isTestnet=${data.isTestnet}`);
 };
 
-export const connectTwitter = async (data: { code: string; redirectUri: string }, baseURL?: string) => {
+interface SidResponse {
+  sid: string;
+}
+
+interface TwitterConnectParams {
+  code: string;
+  projectId: string;
+}
+
+interface WalletBindParams {
+  projectId: string;
+  key: string;
+  signature: string;
+  message: string;
+  timestamp: number;
+  recipientType: string;
+  address: string;
+}
+
+const getSidHeader = (projectId: string) => ({
+  sid: window.localStorage.getItem(`sid_${projectId}`) || ''
+});
+
+export const connectTwitter = async (data: TwitterConnectParams, baseURL?: string): Promise<SidResponse> => {
+  const client = createApiClient(baseURL);
+  return client.post('/airdrop-open/connect-twitter', data, {
+    headers: getSidHeader(data.projectId)
+  });
+};
+
+export const checkEligibility = async (
+  data: { projectId: string },
+  baseURL?: string
+): Promise<IAirdropSignatureData> => {
+  const headers = getSidHeader(data.projectId);
+  if (!headers.sid)
+    return {
+      claims: [],
+      identities: []
+    };
   const client = createApiClient(baseURL);
-  return client.post('/airdrop-open/connect-twitter', data);
+
+  return client.post('/airdrop-open/check-eligibility', data, {
+    headers: headers
+  });
 };
 
-export const checkEligibility = async (data: { projectId: string }, baseURL?: string) => {
+export const bindWallet = async (data: WalletBindParams, baseURL?: string): Promise<SidResponse> => {
   const client = createApiClient(baseURL);
-  return client.post('/airdrop-open/check-eligibility', data);
+  return client.post('/airdrop-open/connect-wallet', data, {
+    headers: getSidHeader(data.projectId)
+  });
 };
 
-export const bindWallet = async (
+interface DisconnectParams {
+  projectId: string;
+  recipientType: AirdropSigIdentityTypeEnum;
+  recipient?: string;
+}
+
+export const disconnectRecipient = async (data: DisconnectParams, baseURL?: string): Promise<void> => {
+  const client = createApiClient(baseURL);
+  return client.post('/airdrop-open/disconnect', data, {
+    headers: getSidHeader(data.projectId)
+  });
+};
+
+export const checkGetSignatures = async (
   data: {
     projectId: string;
-    key: string;
-    signature: string;
-    message: string;
-    timestamp: number;
-    recipientType: string;
+    claimIds: string[];
   },
   baseURL?: string
-) => {
+): Promise<{ signatures: IClaimSignature[] }> => {
   const client = createApiClient(baseURL);
-  return client.post('/airdrop-open/connect-wallet', data);
+  return client.post('/airdrop-open/check-get-signatures', data, {
+    headers: getSidHeader(data.projectId)
+  });
 };

package/src/airdrop/strategies/AirdropStrategyFactory.ts

@@ -5,9 +5,10 @@ import { TonAirdropStrategy } from './TonAirdropStrategy';
 import { TonClient } from '@ton/ton';
 
 export class AirdropStrategyFactory {
-  private static strategyMap: Record<ChainType, IAirdropStrategyConstructor> = {
+  private static strategyMap: Record<ChainType, IAirdropStrategyConstructor | null> = {
     [ChainType.Evm]: EvmAirdropStrategy,
-    [ChainType.Ton]: TonAirdropStrategy
+    [ChainType.Ton]: TonAirdropStrategy,
+    [ChainType.Solana]: null
   };
 
   static createStrategy(params: {
@@ -20,7 +21,7 @@ export class AirdropStrategyFactory {
   }): IAirdropStrategy {
     const { chainType, ...strategyParams } = params;
     const StrategyClass = this.strategyMap[chainType];
-    
+
     if (!StrategyClass) {
       throw new Error(`Unsupported chain type: ${chainType}`);
     }

package/src/airdrop/strategies/EvmAirdropStrategy.ts

@@ -1,4 +1,4 @@
-import { AirdropService as EvmAirdropService } from '../core/evm/AirdropService';
+import { EvmAirdropService } from '../contracts';
 import { ChainId, IWalletClient } from '../types';
 import { IAirdropStrategy } from './IAirdropStrategy';
 import { WalletClient as ViemWalletClient } from 'viem';
@@ -10,11 +10,7 @@ export class EvmAirdropStrategy implements IAirdropStrategy {
   private walletClient?: ViemWalletClient;
   private cachedVersion: string | null = null;
 
-  constructor(params: {
-    contractAddress: string;
-    chainId: string | number;
-    walletClient?: IWalletClient;
-  }) {
+  constructor(params: { contractAddress: string; chainId: string | number; walletClient?: IWalletClient }) {
     this.contractAddress = params.contractAddress;
     this.chainId = Number(params.chainId) as ChainId;
     if (params.walletClient) {

package/src/airdrop/strategies/TonAirdropStrategy.ts

@@ -1,6 +1,6 @@
 import { TonClient } from '@ton/ton';
 import { TonConnectUI } from '@tonconnect/ui-react';
-import { AirdropService as TonAirdropService } from '../core/ton/AirdropService';
+import { TonAirdropService } from '../contracts';
 import { IWalletClient } from '../types';
 import { IAirdropStrategy } from './IAirdropStrategy';
 
@@ -39,7 +39,7 @@ export class TonAirdropStrategy implements IAirdropStrategy {
       chainId: this.chainId,
       walletClient: this.walletClient,
       tonClient: this.tonClient,
-      version: this.cachedVersion || undefined,
+      version: this.cachedVersion || undefined
     });
   }
 

package/src/airdrop/tests/index.test.ts

@@ -1,5 +1,4 @@
-import { writeContract } from 'viem/actions';
-import { AirdropClient } from '../index';
+import { AirdropClient } from '../AirdropClient';
 import { TonClient } from '@ton/ton';
 
 describe('AirdropClient', () => {
@@ -26,7 +25,7 @@ describe('AirdropClient', () => {
 
     it('should use slug correctly', async () => {
       client = new AirdropClient({
-        slug: 'wat',
+        slug: 'wat'
       });
 
       const projectInfo = await client.getProjectInfo();
@@ -48,7 +47,7 @@ describe('AirdropClient', () => {
       expect(version).toBeDefined();
 
       const client1 = new AirdropClient({
-        projectId: 'AD_oLDjKWXU6JZe',
+        projectId: 'AD_oLDjKWXU6JZe'
       });
 
       const version1 = await client1.getVersion();
@@ -90,7 +89,7 @@ describe('AirdropClient', () => {
       const tonClient = new TonClient({
         endpoint: 'https://testnet.toncenter.com/api/v2/jsonRPC'
       });
-      
+
       const client = new AirdropClient({
         projectId: 'AD_WIN4aTbjJPOp',
         endpoint: mockEndpoint
@@ -105,7 +104,7 @@ describe('AirdropClient', () => {
 
       const claimed = await client.checkClaimed(claims?.[0].claimId as string);
       expect(claimed).toBeDefined();
-    })
+    });
 
     //AD_S4dSTEXQN96i
 
@@ -171,10 +170,10 @@ describe('AirdropClient', () => {
     it('should use cached strategy when available', async () => {
       // First call to get strategy
       const strategy1 = await client.getStrategy(mockWalletClient);
-      
+
       // Second call should return cached strategy
       const strategy2 = await client.getStrategy(mockWalletClient);
-      
+
       // Both should be the same instance
       expect(strategy1).toBe(strategy2);
     });
@@ -182,7 +181,7 @@ describe('AirdropClient', () => {
     it('should reinitialize wallet client even with cached strategy', async () => {
       // Get strategy with first wallet client
       const strategy1 = await client.getStrategy(mockWalletClient);
-      
+
       // Create new mock wallet client
       const newMockWalletClient = {
         connected: true,
@@ -191,10 +190,10 @@ describe('AirdropClient', () => {
         connector: { name: 'mock' },
         sendTransaction: jest.fn()
       } as any;
-      
+
       // Get strategy with new wallet client
       const strategy2 = await client.getStrategy(newMockWalletClient);
-      
+
       // Should be same strategy instance but reinitialized with new wallet
       expect((strategy2 as any).walletClient).toBeDefined();
       expect((strategy2 as any).walletClient).toBe(newMockWalletClient);
@@ -331,7 +330,7 @@ describe('AirdropClient', () => {
 
       const customExtraData = {
         isLegacy: false,
-        attestationId: BigInt(999),
+        attestationId: BigInt(999)
       };
 
       client.setClaimHook(() => customExtraData);
@@ -368,10 +367,7 @@ describe('AirdropClient', () => {
         { onLoading }
       );
 
-      expect(mockClaim).toHaveBeenCalledWith(
-        expect.any(Object),
-        { onLoading }
-      );
+      expect(mockClaim).toHaveBeenCalledWith(expect.any(Object), { onLoading });
     });
 
     it('should throw error for invalid claim ID', async () => {

package/src/airdrop/types/index.ts

@@ -1,9 +1,9 @@
 import { TonConnectUI } from '@tonconnect/ui-react';
-import { AirdropService as TonAirdropService } from '../core/ton/AirdropService';
-import { AirdropService as EvmAirdropService } from '../core/evm/AirdropService';
-import { TonClient } from '@ton/ton';
+import { AirdropService as TonAirdropService } from '../contracts/ton/AirdropService';
+import { AirdropService as EvmAirdropService } from '../contracts/evm/AirdropService';
 import { ChainConfig } from '../constants';
 import { WalletClient as ViemWalletClient } from 'viem';
+import { TonWallet } from '../../wallets';
 
 export type ChainId = keyof typeof ChainConfig;
 
@@ -16,33 +16,34 @@ export interface EvmContractClientOption {
 
 export enum ChainType {
   Evm = 'evm',
-  Ton = 'ton'
+  Ton = 'ton',
+  Solana = 'solana'
 }
 
 export type ThemeConfig = {
-  logo: string;
-  title: string;
-  description: string;
-  coverImage: string;
-  subTitle: string;
-  primaryColor: string;
-  secondaryColor: string;
-  buttonPrimaryHover: string;
-  buttonSecondaryHover: string;
-  buttonPrimaryForeground: string;
-  buttonSecondaryForeground: string;
-  welcomeModalText: string;
-  welcomeModalTitle: string;
-  isShowWelcomeModal: boolean;
-  blockCountries: string;
-  termsOfUse: string;
-  successModalPrimaryBtnText: string;
-  successModalUrl: string;
-  successModalTitle: string;
-  successModalDesc: string;
-  successModalShareTexts: string;
-  isUnAvailable: boolean;
-  privacyPolicy: string;
+  logo?: string;
+  title?: string;
+  description?: string;
+  coverImage?: string;
+  subTitle?: string;
+  primaryColor?: string;
+  secondaryColor?: string;
+  buttonPrimaryHover?: string;
+  buttonSecondaryHover?: string;
+  buttonPrimaryForeground?: string;
+  buttonSecondaryForeground?: string;
+  welcomeModalText?: string;
+  welcomeModalTitle?: string;
+  isShowWelcomeModal?: boolean;
+  blockCountries?: string;
+  termsOfUse?: string;
+  successModalPrimaryBtnText?: string;
+  successModalUrl?: string;
+  successModalTitle?: string;
+  successModalDesc?: string;
+  successModalShareTexts?: string;
+  isUnAvailable?: boolean;
+  privacyPolicy?: string;
 };
 
 export interface IProject {
@@ -63,6 +64,7 @@ export interface IProject {
   version: string;
   extra?: IProjectExtra;
   identities: Identity[];
+  projectTag: string;
 }
 
 export interface Identity {
@@ -73,7 +75,8 @@ export interface Identity {
 export enum AirdropSigIdentityTypeEnum {
   Twitter = 'X Account',
   SolanaWallet = 'Solana Wallet',
-  EVMWallet = 'EVM Wallet'
+  EVMWallet = 'EVM Wallet',
+  TONWallet = 'TON Wallet'
 }
 
 export interface IProjectExtra {
@@ -113,10 +116,41 @@ export type IAirdropClaim = {
   project: IProject;
 };
 
+export type IAirdropSignatureClaim = {
+  percent: number;
+  unlockingAt: number;
+  claimDeadline: number;
+  value: string;
+  recipient: string;
+  recipientType: string;
+  claimId: string;
+  data?: string;
+  signature?: string;
+  claimed?: boolean;
+};
+
+export interface IAirdropSignatureIdentity {
+  type: AirdropSigIdentityTypeEnum;
+  value: string;
+  displayName: string;
+}
+
 export interface IAirdropData {
   claims: IAirdropClaim[];
 }
 
+export interface IAirdropSignatureData {
+  claims: IAirdropSignatureClaim[];
+  identities: IAirdropSignatureIdentity[];
+}
+
+export interface IClaimSignature {
+  claimId: string;
+  data: string;
+  signature: string;
+  hash: string;
+}
+
 export enum TonAirdropVersionEnum {
   V1 = '1.0.0',
   V2 = '2.0.0',
@@ -136,6 +170,7 @@ export type IAirdropService = TonAirdropService | EvmAirdropService;
 
 type BaseAirdropOptions = {
   endpoint?: string;
+  project?: IProject;
 };
 
 type ProjectIdOptions = BaseAirdropOptions & {
@@ -155,3 +190,8 @@ export interface IContractConfig {
   paused: boolean | null;
   claimFee?: string | null;
 }
+
+export enum ErrorCode {
+  // 'Wallet already connected'
+  WALLET_ALREADY_CONNECTED = 'Wallet already connected'
+}

package/src/index.ts

@@ -1,2 +1,3 @@
-export { AirdropClient } from './airdrop';
+export { AirdropClient, SignatureAirdropClient, CONST } from './airdrop';
+export { WalletFactory, EvmProvider, SolanaProvider, TonProvider } from './wallets';
 export * from './airdrop/types';

package/src/utils/api-client.ts

@@ -5,6 +5,7 @@ export type ApiClientOptions = {
 export type ApiRequestOptions = {
   params?: Record<string, string | number>;
   skipHandleError?: boolean;
+  headers?: Record<string, string>;
 };
 
 type ApiResponse = {
@@ -48,11 +49,11 @@ export class ApiClient {
   ): Promise<unknown> {
     const finalUrl = (this.options?.baseURL || '') + url;
 
-    const init: RequestInit = { method };
+    const init: RequestInit = { method, headers: options?.headers || {} };
     if (data instanceof FormData) {
       init.body = data;
     } else {
-      init.headers = { 'content-type': 'application/json' };
+      init.headers = { 'content-type': 'application/json', ...init.headers };
       init.body = data ? JSON.stringify(data) : void 0;
     }
 

package/src/utils/utils.ts

@@ -28,5 +28,3 @@ export async function retry<T>(fn: () => Promise<T>, options: { retries: number;
   }
   throw lastError;
 }
-
-export const isLocal = window.location.href.includes('localhost');

package/src/utils/web3.ts

@@ -1,4 +1,16 @@
 import TonWeb from 'tonweb';
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  getAssociatedTokenAddress,
+  getAccount,
+  createAssociatedTokenAccountInstruction,
+  TokenAccountNotFoundError,
+  TokenInvalidAccountOwnerError,
+  TokenInvalidMintError,
+  TokenInvalidOwnerError,
+  TOKEN_PROGRAM_ID
+} from '@solana/spl-token';
+import { Commitment, Connection, PublicKey, Transaction } from '@solana/web3.js';
 
 export function flipAddressType(address: string) {
   if (!address) return '';
@@ -6,3 +18,95 @@ export function flipAddressType(address: string) {
     ? new TonWeb.utils.Address(address).toString(true, true, true)
     : new TonWeb.utils.Address(address).toString(false, false, true);
 }
+
+export function hexStrToU8Array(hexStr: string): number[] {
+  // 移除 "0x" 前缀（如果存在）
+  hexStr = hexStr.startsWith('0x') ? hexStr.slice(2) : hexStr;
+
+  // 确保 hexStr 长度正确（64 个字符，即 32 字节）
+  // if (hexStr.length !== 64) {
+  //   throw new Error('Invalid hex string length. Expected 64 characters (32 bytes).');
+  // }
+
+  // 将 16 进制字符串转换为 Uint8Array
+  const bytes = [];
+  for (let i = 0; i < hexStr.length / 2; i++) {
+    bytes[i] = parseInt(hexStr.substring(i * 2, i * 2 + 2), 16);
+  }
+
+  return bytes;
+}
+
+export async function getOrCreateAssociatedTokenAccount({
+  connection,
+  payer,
+  mint,
+  owner,
+  signTransaction,
+  allowOwnerOffCurve = false,
+  commitment,
+  programId = TOKEN_PROGRAM_ID,
+  associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID
+}: {
+  connection: Connection;
+  payer: PublicKey;
+  mint: PublicKey;
+  owner: PublicKey;
+  allowOwnerOffCurve?: boolean;
+  commitment?: Commitment;
+  programId?: PublicKey;
+  associatedTokenProgramId?: PublicKey;
+  signTransaction: (signature: Transaction) => Promise<Transaction>;
+}) {
+  const associatedToken = await getAssociatedTokenAddress(
+    mint,
+    owner,
+    allowOwnerOffCurve,
+    programId,
+    associatedTokenProgramId
+  );
+  // This is the optimal logic, considering TX fee, client-side computation, RPC roundtrips and guaranteed idempotent.
+  // Sadly we can't do this atomically.
+  let account;
+  try {
+    account = await getAccount(connection, associatedToken, commitment, programId);
+  } catch (error) {
+    // TokenAccountNotFoundError can be possible if the associated address has already received some lamports,
+    // becoming a system account. Assuming program derived addressing is safe, this is the only case for the
+    // TokenInvalidAccountOwnerError in this code path.
+    if (error instanceof TokenAccountNotFoundError || error instanceof TokenInvalidAccountOwnerError) {
+      // As this isn't atomic, it's possible others can create associated accounts meanwhile.
+      try {
+        const transaction = new Transaction().add(
+          createAssociatedTokenAccountInstruction(
+            payer,
+            associatedToken,
+            owner,
+            mint,
+            programId,
+            associatedTokenProgramId
+          )
+        );
+        const blockHash = await connection.getRecentBlockhash();
+        transaction.feePayer = await payer;
+        transaction.recentBlockhash = await blockHash.blockhash;
+        const signed = await signTransaction(transaction);
+
+        const signature = await connection.sendRawTransaction(signed.serialize());
+
+        await connection.confirmTransaction(signature);
+      } catch (error) {
+        console.log(error);
+        // Ignore all errors; for now there is no API-compatible way to selectively ignore the expected
+        // instruction error if the associated account exists already.
+      }
+      // Now this should always succeed
+      account = await getAccount(connection, associatedToken, commitment, programId);
+    } else {
+      throw error;
+    }
+  }
+  if (!account.mint.equals(mint)) throw new TokenInvalidMintError();
+  if (!account.owner.equals(owner)) throw new TokenInvalidOwnerError();
+  return account;
+}

package/src/{airdrop/core/useWeb3ConnectWallet → wallets}/providers/evm/EvmWallet.ts

@@ -53,13 +53,16 @@ export class EvmWallet extends WalletBase<EVMStoreType> {
     };
   }
 
-  override async signin(statement?: string): Promise<ISignResult> {
+  override async signin(statement: string, prepare = true): Promise<ISignResult> {
     return new Promise((resolve) => {
       const signCallback = (data: ReturnType<typeof useAccount>) => {
         this.address = data.address;
         this.chainId = data.chainId;
-        const msg = prepareSignMessage({ statement, chainId: data.chainId!, address: data.address! });
-        const fullMessage = get4361Message(msg);
+        let fullMessage = statement;
+        if (prepare) {
+          const msg = prepareSignMessage({ statement, chainId: data.chainId!, address: data.address! });
+          fullMessage = get4361Message(msg);
+        }
 
         const res = this.sign(fullMessage);
 

package/src/{airdrop/core/useWeb3ConnectWallet → wallets}/providers/evm/index.tsx

@@ -1,5 +1,5 @@
 import '@rainbow-me/rainbowkit/styles.css';
-import { RainbowKitProvider, lightTheme, useConnectModal } from '@rainbow-me/rainbowkit';
+import { RainbowKitProvider, darkTheme, useConnectModal } from '@rainbow-me/rainbowkit';
 import { ResolvedRegister, WagmiProvider, useAccount, useWalletClient } from 'wagmi';
 import { ReactNode, useEffect } from 'react';
 
@@ -26,14 +26,27 @@ export const EVMConnector = () => {
   return null;
 };
 
-export const EvmProvider = ({ children, config }: { children: ReactNode; config: ResolvedRegister['config'] }) => {
+export const EvmProvider = ({
+  children,
+  config,
+  theme
+}: {
+  children: ReactNode;
+  config: ResolvedRegister['config'];
+  theme?: any;
+}) => {
   evmStore.config = config;
   return (
     <WagmiProvider config={config}>
       <RainbowKitProvider
-        theme={lightTheme({
-          accentColor: '#DD8D58'
-        })}
+        locale="en-US"
+        theme={
+          theme ||
+          darkTheme({
+            accentColor: 'var(--t-primary)',
+            accentColorForeground: 'var(--t-button-primary-foreground)'
+          })
+        }
       >
         {children}
         <EVMConnector />