@sign-global/tokentable-core 1.0.0 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sign-global/tokentable-core",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -11,6 +11,11 @@
       "types": "./dist/index.d.ts"
     }
   },
+  "devDependencies": {
+    "vitest": "^1.0.0",
+    "@vitest/ui": "^1.0.0",
+    "jsdom": "^23.0.0"
+  },
   "dependencies": {
     "@tonconnect/sdk": "^3.0.6",
     "viem": "^2.0.0",
@@ -39,6 +44,8 @@
     "build": "tsup",
     "build:watch": "tsup --watch",
     "clean": "rm -rf dist",
-    "test": "jest"
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:watch": "vitest --watch"
   }
 }

package/src/constants/chain-config.ts

@@ -49,8 +49,8 @@ export const ChainConfig = {
     rpcUrl: 'https://zetachain-mainnet.g.alchemy.com/v2/1tmk0FrhwTJHXh0XIyae7_SXw1lDCjgs'
   },
   [arbitrum.id]: {
-    contractAddress: '0x759ac3CA33FeeAfB8C41aEbC8687A7Bd849Fc87a',
-    rpcUrl: arbitrum.rpcUrls.default.http[0]
+    contractAddress: '0xeD09c23677D02f4f486E55f0f081cfc114EEa53b',
+    rpcUrl: 'https://arb-mainnet.g.alchemy.com/v2/udrqNPSB6i5n5L6QSM31Ng72h_hFOrVT'
   },
   [berachainTestnet.id]: {
     contractAddress: '',

package/src/contracts/evm/AirdropService.ts

@@ -160,22 +160,27 @@ export class AirdropService {
   }
 
   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);
-    const version = await this.getVersion();
-    if (version === AirdropVersionEnum.V3) {
-      const threshold = await this.getFeelessThreshold();
-      if (isGreaterThan(Number(amount), Number(threshold))) {
-        return fee;
-      } else {
+    try {
+      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);
+      const version = await this.getVersion();
+      if (version === AirdropVersionEnum.V3) {
+        const threshold = await this.getFeelessThreshold();
+        if (isGreaterThan(Number(amount), Number(threshold))) {
+          return fee;
+        } else {
+          return undefined;
+        }
+      }
+      return fee;
+    } catch (error) {
+      console.error('Failed to get claim fee:', error);
+      throw new Error(`Failed to calculate claim fee: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
-    return fee;
   }
 
   async getKycThreshold() {

package/src/services/airdrop/index.ts

@@ -15,7 +15,9 @@ 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 is null
+  if (!res) {
+    throw new Error(`Project not found: ${projectId}`);
+  }
   const projectConfig = res?.themeConf;
   const blockCountries = safeParseJSON(projectConfig?.blockCountries);
   return {

package/src/test/setup.ts

@@ -0,0 +1,24 @@
+import { vi } from 'vitest';
+
+// Mock console.log to avoid noise in tests
+global.console = {
+  ...console,
+  log: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn()
+};
+
+// Setup global test environment
+Object.defineProperty(window, 'matchMedia', {
+  writable: true,
+  value: vi.fn().mockImplementation(query => ({
+    matches: false,
+    media: query,
+    onchange: null,
+    addListener: vi.fn(),
+    removeListener: vi.fn(),
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+    dispatchEvent: vi.fn(),
+  })),
+});

package/src/types/index.ts

@@ -105,6 +105,7 @@ export type IAirdropClaim = {
   data: string;
   leaf: string;
   claimed?: boolean;
+  fees: string;
 
   claimId?: string;
 
@@ -118,9 +119,14 @@ export type IAirdropClaim = {
   project: IProject;
 };
 
+export interface IExtraData {
+  isLegacy: boolean;
+  attestationId: bigint;
+}
+
 export interface IAirdropClaimData extends IAirdropClaim {
-  extraData: any;
-  value: bigint;
+  extraData?: IExtraData;
+  value?: bigint | string;
 }
 
 export type IAirdropSignatureClaim = {

package/src/utils/__tests__/web3.test.ts

@@ -0,0 +1,326 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Connection, PublicKey, Transaction, Commitment } from '@solana/web3.js';
+import {
+  getAccount,
+  getAssociatedTokenAddress,
+  createAssociatedTokenAccountInstruction,
+  TokenAccountNotFoundError,
+  TokenInvalidAccountOwnerError,
+  TokenInvalidMintError,
+  TokenInvalidOwnerError,
+  TOKEN_PROGRAM_ID,
+  ASSOCIATED_TOKEN_PROGRAM_ID
+} from '@solana/spl-token';
+import { getOrCreateAssociatedTokenAccount } from '../web3';
+
+// Mock @solana/spl-token
+vi.mock('@solana/spl-token', () => ({
+  getAccount: vi.fn(),
+  getAssociatedTokenAddress: vi.fn(),
+  createAssociatedTokenAccountInstruction: vi.fn(),
+  TokenAccountNotFoundError: class extends Error {},
+  TokenInvalidAccountOwnerError: class extends Error {},
+  TokenInvalidMintError: class extends Error {},
+  TokenInvalidOwnerError: class extends Error {},
+  TOKEN_PROGRAM_ID: new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'),
+  ASSOCIATED_TOKEN_PROGRAM_ID: new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL')
+}));
+
+// Mock @solana/web3.js
+vi.mock('@solana/web3.js', async () => {
+  const actual = await vi.importActual('@solana/web3.js');
+  return {
+    ...actual,
+    Connection: vi.fn(),
+    PublicKey: actual.PublicKey,
+    Transaction: vi.fn()
+  };
+});
+
+describe('getOrCreateAssociatedTokenAccount', () => {
+  let mockConnection: any;
+  let mockSignTransaction: any;
+  let mockPayer: PublicKey;
+  let mockMint: PublicKey;
+  let mockOwner: PublicKey;
+  let mockAssociatedToken: PublicKey;
+  let mockTransaction: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Setup mock objects with valid base58 public keys
+    mockPayer = new PublicKey('11111111111111111111111111111112');
+    mockMint = new PublicKey('So11111111111111111111111111111111111111112');
+    mockOwner = new PublicKey('9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM');
+    mockAssociatedToken = new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
+
+    mockConnection = {
+      getLatestBlockhash: vi.fn().mockResolvedValue({
+        blockhash: 'test-blockhash',
+        lastValidBlockHeight: 12345
+      }),
+      sendRawTransaction: vi.fn().mockResolvedValue('test-signature'),
+      confirmTransaction: vi.fn().mockResolvedValue({ value: { err: null } })
+    };
+
+    mockTransaction = {
+      add: vi.fn().mockReturnThis(),
+      serialize: vi.fn().mockReturnValue(Buffer.from('serialized-transaction')),
+      feePayer: undefined,
+      recentBlockhash: undefined
+    };
+
+    mockSignTransaction = vi.fn().mockResolvedValue(mockTransaction);
+
+    // Setup mocks
+    vi.mocked(getAssociatedTokenAddress).mockResolvedValue(mockAssociatedToken);
+    vi.mocked(Transaction).mockReturnValue(mockTransaction);
+    vi.mocked(createAssociatedTokenAccountInstruction).mockReturnValue({} as any);
+  });
+
+  it('should return existing account when account exists', async () => {
+    const mockAccount = {
+      address: mockAssociatedToken,
+      mint: mockMint,
+      owner: mockOwner,
+      amount: BigInt(1000),
+      delegate: null,
+      delegatedAmount: BigInt(0),
+      isInitialized: true,
+      isFrozen: false,
+      isNative: false,
+      rentExemptReserve: null,
+      closeAuthority: null,
+      tlvData: Buffer.alloc(0),
+    };
+
+    vi.mocked(getAccount).mockResolvedValue(mockAccount);
+
+    const result = await getOrCreateAssociatedTokenAccount({
+      connection: mockConnection,
+      payer: mockPayer,
+      mint: mockMint,
+      owner: mockOwner,
+      signTransaction: mockSignTransaction
+    });
+
+    expect(result).toBe(mockAccount);
+    expect(getAssociatedTokenAddress).toHaveBeenCalledWith(
+      mockMint,
+      mockOwner,
+      false,
+      TOKEN_PROGRAM_ID,
+      ASSOCIATED_TOKEN_PROGRAM_ID
+    );
+    expect(getAccount).toHaveBeenCalledWith(
+      mockConnection,
+      mockAssociatedToken,
+      undefined,
+      TOKEN_PROGRAM_ID
+    );
+  });
+
+  it('should create new account when TokenAccountNotFoundError occurs', async () => {
+    const mockAccount = {
+      address: mockAssociatedToken,
+      mint: mockMint,
+      owner: mockOwner,
+      amount: BigInt(1000),
+      delegate: null,
+      delegatedAmount: BigInt(0),
+      isInitialized: true,
+      isFrozen: false,
+      isNative: false,
+      rentExemptReserve: null,
+      closeAuthority: null,
+      tlvData: Buffer.alloc(0),
+    };
+
+    // First call throws error, second call returns account
+    vi.mocked(getAccount)
+      .mockRejectedValueOnce(new TokenAccountNotFoundError())
+      .mockResolvedValueOnce(mockAccount);
+
+    const result = await getOrCreateAssociatedTokenAccount({
+      connection: mockConnection,
+      payer: mockPayer,
+      mint: mockMint,
+      owner: mockOwner,
+      signTransaction: mockSignTransaction
+    });
+
+    expect(result).toBe(mockAccount);
+    expect(createAssociatedTokenAccountInstruction).toHaveBeenCalledWith(
+      mockPayer,
+      mockAssociatedToken,
+      mockOwner,
+      mockMint,
+      TOKEN_PROGRAM_ID,
+      ASSOCIATED_TOKEN_PROGRAM_ID
+    );
+    expect(mockSignTransaction).toHaveBeenCalledWith(mockTransaction);
+    expect(mockConnection.sendRawTransaction).toHaveBeenCalledWith(
+      Buffer.from('serialized-transaction')
+    );
+    expect(mockConnection.confirmTransaction).toHaveBeenCalled();
+  });
+
+  it('should create new account when TokenInvalidAccountOwnerError occurs', async () => {
+    const mockAccount = {
+      address: mockAssociatedToken,
+      mint: mockMint,
+      owner: mockOwner,
+      amount: BigInt(1000),
+      delegate: null,
+      delegatedAmount: BigInt(0),
+      isInitialized: true,
+      isFrozen: false,
+      isNative: false,
+      rentExemptReserve: null,
+      closeAuthority: null,
+      tlvData: Buffer.alloc(0),
+    };
+
+    // First call throws error, second call returns account
+    vi.mocked(getAccount)
+      .mockRejectedValueOnce(new TokenInvalidAccountOwnerError())
+      .mockResolvedValueOnce(mockAccount);
+
+    const result = await getOrCreateAssociatedTokenAccount({
+      connection: mockConnection,
+      payer: mockPayer,
+      mint: mockMint,
+      owner: mockOwner,
+      signTransaction: mockSignTransaction
+    });
+
+    expect(result).toBe(mockAccount);
+    expect(createAssociatedTokenAccountInstruction).toHaveBeenCalled();
+    expect(mockSignTransaction).toHaveBeenCalled();
+  });
+
+  it('should throw TokenInvalidMintError when mint does not match', async () => {
+    const wrongMint = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
+    const wrongAccount = {
+        address: mockAssociatedToken,
+        mint: wrongMint,
+        owner: mockOwner,
+        amount: BigInt(1000),
+        delegate: null,
+        delegatedAmount: BigInt(0),
+        isInitialized: true,
+        isFrozen: false,
+        isNative: false,
+        rentExemptReserve: null,
+        closeAuthority: null,
+        tlvData: Buffer.alloc(0),
+      };
+
+    vi.mocked(getAccount).mockResolvedValue(wrongAccount);
+
+    await expect(
+      getOrCreateAssociatedTokenAccount({
+        connection: mockConnection,
+        payer: mockPayer,
+        mint: mockMint,
+        owner: mockOwner,
+        signTransaction: mockSignTransaction
+      })
+    ).rejects.toThrow(TokenInvalidMintError);
+  });
+
+  it('should throw TokenInvalidOwnerError when owner does not match', async () => {
+    const wrongOwner = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
+    const wrongAccount = {
+        address: mockAssociatedToken,
+        mint: mockMint,
+        owner: wrongOwner,
+        amount: BigInt(1000),
+        delegate: null,
+        delegatedAmount: BigInt(0),
+        isInitialized: true,
+        isFrozen: false,
+        isNative: false,
+        rentExemptReserve: null,
+        closeAuthority: null,
+        tlvData: Buffer.alloc(0),
+      };
+
+    vi.mocked(getAccount).mockResolvedValue(wrongAccount);
+
+    await expect(
+      getOrCreateAssociatedTokenAccount({
+        connection: mockConnection,
+        payer: mockPayer,
+        mint: mockMint,
+        owner: mockOwner,
+        signTransaction: mockSignTransaction
+      })
+    ).rejects.toThrow(TokenInvalidOwnerError);
+  });
+
+  it('should handle custom parameters', async () => {
+    const customCommitment: Commitment = 'confirmed';
+    const customProgramId = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
+    const customAssociatedTokenProgramId = new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
+    
+    const mockAccount = {
+      address: mockAssociatedToken,
+      mint: mockMint,
+      owner: mockOwner,
+      amount: BigInt(1000),
+      delegate: null,
+      delegatedAmount: BigInt(0),
+      isInitialized: true,
+      isFrozen: false,
+      isNative: false,
+      rentExemptReserve: null,
+      closeAuthority: null,
+      tlvData: Buffer.alloc(0),
+    };
+
+    vi.mocked(getAccount).mockResolvedValue(mockAccount);
+
+    await getOrCreateAssociatedTokenAccount({
+      connection: mockConnection,
+      payer: mockPayer,
+      mint: mockMint,
+      owner: mockOwner,
+      signTransaction: mockSignTransaction,
+      allowOwnerOffCurve: true,
+      commitment: customCommitment,
+      programId: customProgramId,
+      associatedTokenProgramId: customAssociatedTokenProgramId
+    });
+
+    expect(getAssociatedTokenAddress).toHaveBeenCalledWith(
+      mockMint,
+      mockOwner,
+      true,
+      customProgramId,
+      customAssociatedTokenProgramId
+    );
+    expect(getAccount).toHaveBeenCalledWith(
+      mockConnection,
+      mockAssociatedToken,
+      customCommitment,
+      customProgramId
+    );
+  });
+
+  it('should rethrow unexpected errors', async () => {
+    const unexpectedError = new Error('Unexpected error');
+    vi.mocked(getAccount).mockRejectedValue(unexpectedError);
+
+    await expect(
+      getOrCreateAssociatedTokenAccount({
+        connection: mockConnection,
+        payer: mockPayer,
+        mint: mockMint,
+        owner: mockOwner,
+        signTransaction: mockSignTransaction
+      })
+    ).rejects.toThrow('Unexpected error');
+  });
+});

package/src/utils/api-client.ts

@@ -16,7 +16,7 @@ type ApiResponse = {
 };
 
 export class ApiClient {
-  constructor(private options?: ApiClientOptions) {}
+  constructor(private options?: ApiClientOptions) { }
 
   extend(options: ApiClientOptions): ApiClient {
     return new ApiClient({
@@ -59,7 +59,7 @@ export class ApiClient {
 
     const res = await fetch(finalUrl, init);
     const [status, resData]: [number, ApiResponse] = await Promise.all([res.status, res.json() as any]);
-    if ((status < 200 && status >= 300) || resData?.success !== true) {
+    if (status < 200 || status >= 300 || resData?.success !== true) {
       return Promise.reject(resData);
     }
     return resData.data;

package/src/utils/utils.ts

@@ -6,11 +6,16 @@ export const getCustomNaNoId = (): string => {
   return nanoid();
 };
 
-export const safeParseJSON = (str: string): any => {
+export const safeParseJSON = <T = any>(str: string | null | undefined, defaultValue: T = {} as T): T => {
+  if (!str || typeof str !== 'string') {
+    return defaultValue;
+  }
   try {
-    return JSON.parse(str);
+    const parsed = JSON.parse(str);
+    return parsed !== null && parsed !== undefined ? parsed : defaultValue;
   } catch (error) {
-    return {};
+    console.warn('Failed to parse JSON:', error);
+    return defaultValue;
   }
 };
 

package/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'jsdom',
+    globals: true,
+    setupFiles: ['./src/test/setup.ts']
+  },
+  resolve: {
+    alias: {
+      '@': './src'
+    }
+  }
+});