@sign-global/tokentable 0.5.3-beta.0 → 1.0.0

package/src/strategies/TonAirdropStrategy.ts

@@ -0,0 +1,76 @@
+import { TonClient } from '@ton/ton';
+import { TonConnectUI } from '@tonconnect/ui-react';
+import { TonAirdropService, IWalletClient } from '@sign-global/tokentable-core';
+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);
+  }
+}

package/src/tests/index.test.ts

@@ -0,0 +1,387 @@
+import { AirdropClient } from '../AirdropClient';
+import { TonClient } from '@ton/ton';
+
+describe('AirdropClient', () => {
+  let client: AirdropClient;
+  const mockTonClient = new TonClient({
+    endpoint: 'https://testnet.toncenter.com/api/v2/jsonRPC'
+  });
+  const mockEndpoint = 'https://dev.dev.ethsign.xyz:3057/api';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('initialize', () => {
+    it('should use projectId correctly', async () => {
+      client = new AirdropClient({
+        projectId: 'AD_TEV94wvkxkvn',
+        endpoint: mockEndpoint
+      });
+
+      const projectInfo = await client.getProjectInfo();
+      expect(projectInfo).toBeDefined();
+    }, 6000);
+
+    it('should use slug correctly', async () => {
+      client = new AirdropClient({
+        slug: 'wat'
+      });
+
+      const projectInfo = await client.getProjectInfo();
+      expect(projectInfo).toBeTruthy();
+    });
+  });
+
+  describe('test main features', () => {
+    beforeEach(async () => {
+      client = new AirdropClient({
+        projectId: 'AD_TEV94wvkxkvn',
+        endpoint: mockEndpoint
+      });
+    });
+
+    it('should get version', async () => {
+      const version = await client.getVersion();
+      console.log(version);
+      expect(version).toBeDefined();
+
+      const client1 = new AirdropClient({
+        projectId: 'AD_oLDjKWXU6JZe'
+      });
+
+      const version1 = await client1.getVersion();
+      console.log(version1, 'v1');
+      expect(version1).toBeDefined();
+    });
+
+    it('should get paused', async () => {
+      const client = new AirdropClient({
+        projectId: 'AD_PeMV2dboWAui',
+        endpoint: mockEndpoint
+      });
+      const paused = await client.getPaused();
+      console.log(paused);
+      expect(paused).toBeDefined();
+    });
+
+    it('should get claim fee', async () => {
+      // evm
+      const client = new AirdropClient({
+        projectId: 'AD_50lczFu9Yhvq',
+        endpoint: mockEndpoint
+      });
+      const fee = await client.getClaimFee();
+      console.log(fee);
+      expect(fee).toBeDefined();
+    });
+
+    it('should get paused throw error', async () => {
+      // evm
+      const client = new AirdropClient({
+        projectId: 'AD_50lczFu9Yhvq',
+        endpoint: mockEndpoint
+      });
+      await expect(client.getPaused()).rejects.toThrow();
+    });
+
+    it('should check ton claimed', async () => {
+      const tonClient = new TonClient({
+        endpoint: 'https://testnet.toncenter.com/api/v2/jsonRPC'
+      });
+
+      const client = new AirdropClient({
+        projectId: 'AD_WIN4aTbjJPOp',
+        endpoint: mockEndpoint
+      });
+      client.setTonClient(tonClient);
+
+      const version = await client.getVersion();
+      console.log(version);
+      expect(version).toBeDefined();
+
+      const claims = await client.getAirdropClaims({ address: 'UQANAsrLyyHoq8N4EZ-QfADXhtoSUybdSKXOknMLWLbA7rt7' });
+
+      const claimed = await client.checkClaimed(claims?.[0].claimId as string);
+      expect(claimed).toBeDefined();
+    });
+
+    //AD_S4dSTEXQN96i
+
+    it('should work on native v1', async () => {
+      client = new AirdropClient({
+        projectId: 'AD_S4dSTEXQN96i',
+        endpoint: mockEndpoint
+      });
+      const version = await client.getVersion();
+      console.log(version);
+      expect(version).toBeDefined();
+      const fee = await client.getClaimFee();
+      console.log(fee);
+      expect(fee).toBeDefined();
+    });
+
+    it('should get airdrop claims', async () => {
+      const claims = await client.getAirdropClaims({ address: '0xDfc4FbbDd9C47c7976fEBb14B1D37C7f85FE299D' });
+      expect(claims).toBeTruthy();
+      expect(claims?.length).toBe(1);
+    });
+
+    it('should check claimed', async () => {
+      const claims = await client.getAirdropClaims({ address: '0xDfc4FbbDd9C47c7976fEBb14B1D37C7f85FE299D' });
+
+      const claimed = await client.checkClaimed(claims?.[0].claimId as string);
+      expect(claimed).toBeDefined();
+    });
+  });
+
+  describe('getStrategy', () => {
+    let client: AirdropClient;
+    const mockWalletClient = {
+      connected: true,
+      account: { address: '0xMockAddress' },
+      network: { name: 'mock', chainId: 1 },
+      connector: { name: 'mock' },
+      sendTransaction: jest.fn()
+    } as any;
+
+    beforeEach(async () => {
+      client = new AirdropClient({
+        projectId: 'AD_TEV94wvkxkvn',
+        endpoint: mockEndpoint
+      });
+      // Clear strategy cache before each test
+      jest.clearAllMocks();
+    });
+
+    it('should get strategy without wallet client (read-only mode)', async () => {
+      const strategy = await client.getStrategy();
+      expect(strategy).toBeDefined();
+      // Verify it's in read-only mode
+      expect((strategy as any).walletClient).toBeUndefined();
+    });
+
+    it('should get strategy with wallet client (interactive mode)', async () => {
+      const strategy = await client.getStrategy(mockWalletClient);
+      expect(strategy).toBeDefined();
+      expect((strategy as any).walletClient).toBeDefined();
+    });
+
+    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);
+    });
+
+    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,
+        account: { address: '0xNewMockAddress' },
+        network: { name: 'mock', chainId: 1 },
+        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);
+    });
+  });
+
+  describe('claimAirdrop', () => {
+    const mockClaim = jest.fn();
+    const mockGetClaimFee = jest.fn();
+    const mockWalletClient = {
+      connected: true,
+      account: { address: '0xDfc4FbbDd9C47c7976fEBb14B1D37C7f85FE299D' },
+      network: { name: 'mock', chainId: 1 },
+      connector: { name: 'mock' },
+      sendTransaction: jest.fn(),
+      writeContract: jest.fn()
+    } as any;
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+      // Mock getStrategy to return a mock strategy
+      jest.spyOn(AirdropClient.prototype, 'getStrategy').mockResolvedValue({
+        claim: mockClaim,
+        isInitialized: () => true,
+        initialize: jest.fn(),
+        getVersion: jest.fn().mockResolvedValue('1.0.0'),
+        checkClaimed: jest.fn(),
+        getClaimFee: mockGetClaimFee
+      });
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('should claim EVM airdrop with fee (v1/v2)', async () => {
+      // Mock getClaimFee to return a specific value for this test
+      mockGetClaimFee.mockResolvedValueOnce(BigInt(1000));
+
+      const client = new AirdropClient({
+        projectId: 'AD_50lczFu9Yhvq', // EVM project with fee
+        endpoint: mockEndpoint
+      });
+
+      const claims = await client.getAirdropClaims({ address: '0xDfc4FbbDd9C47c7976fEBb14B1D37C7f85FE299D' });
+
+      await client.claimAirdrop({
+        claimId: claims[0].claimId as string,
+        walletClient: mockWalletClient
+      });
+
+      // Verify claim was called with correct parameters
+      expect(mockClaim).toHaveBeenCalledWith(
+        expect.objectContaining({
+          extraData: {
+            isLegacy: true,
+            attestationId: BigInt(1)
+          },
+          value: BigInt(1000) // Should match the mocked getClaimFee value
+        }),
+        undefined
+      );
+    });
+
+    it('should claim EVM airdrop without fee', async () => {
+      // Mock getClaimFee to return undefined for this test
+      mockGetClaimFee.mockResolvedValueOnce(undefined);
+
+      const client = new AirdropClient({
+        projectId: 'AD_WMTW9cHZJB46', // EVM v3/v4 native project
+        endpoint: mockEndpoint
+      });
+
+      const claims = await client.getAirdropClaims({ address: '0x5f5F5919dEc54AdF9743dd2c9dA4EbE7D60B8B9b' });
+
+      await client.claimAirdrop({
+        claimId: claims[0].claimId as string,
+        walletClient: mockWalletClient
+      });
+
+      expect(mockClaim).toHaveBeenCalledWith(
+        expect.objectContaining({
+          extraData: {
+            isLegacy: true,
+            attestationId: BigInt(1)
+          },
+          value: undefined
+        }),
+        undefined
+      );
+    });
+
+    it('should claim TON airdrop', async () => {
+      const mockTonWallet = {
+        connected: true,
+        account: { address: 'EQMockTonAddress' },
+        network: { name: 'mock', chainId: 'mainnet' },
+        connector: { name: 'mock' },
+        sendTransaction: jest.fn()
+      } as any;
+
+      const client = new AirdropClient({
+        projectId: 'AD_PeMV2dboWAui', // TON project
+        endpoint: mockEndpoint
+      });
+
+      const claims = await client.getAirdropClaims({ address: 'UQANAsrLyyHoq8N4EZ-QfADXhtoSUybdSKXOknMLWLbA7rt7' });
+
+      await client.claimAirdrop({
+        claimId: claims[0].claimId!,
+        walletClient: mockTonWallet
+      });
+
+      // Verify claim parameters don't include extraData for TON
+      expect(mockClaim).toHaveBeenCalledWith(
+        expect.not.objectContaining({
+          extraData: expect.anything()
+        }),
+        undefined
+      );
+
+      // Verify the claim parameters have the necessary data
+      const callArgs = mockClaim.mock.calls[0][0];
+      expect(callArgs).toHaveProperty('claimId');
+      expect(callArgs).toHaveProperty('value', '0.1');
+      expect(callArgs).toHaveProperty('extraData', undefined);
+    });
+
+    it('should use custom claimHook if provided', async () => {
+      const client = new AirdropClient({
+        projectId: 'AD_50lczFu9Yhvq',
+        endpoint: mockEndpoint
+      });
+
+      const customExtraData = {
+        isLegacy: false,
+        attestationId: BigInt(999)
+      };
+
+      client.setClaimHook(() => customExtraData);
+
+      const claims = await client.getAirdropClaims({ address: '0xDfc4FbbDd9C47c7976fEBb14B1D37C7f85FE299D' });
+
+      await client.claimAirdrop({
+        claimId: claims[0].claimId as string,
+        walletClient: mockWalletClient
+      });
+
+      expect(mockClaim).toHaveBeenCalledWith(
+        expect.objectContaining({
+          extraData: customExtraData
+        }),
+        undefined
+      );
+    });
+
+    it('should handle loading callback', async () => {
+      const client = new AirdropClient({
+        projectId: 'AD_PeMV2dboWAui',
+        endpoint: mockEndpoint
+      });
+
+      const claims = await client.getAirdropClaims({ address: 'UQANAsrLyyHoq8N4EZ-QfADXhtoSUybdSKXOknMLWLbA7rt7' });
+      const onLoading = jest.fn();
+
+      await client.claimAirdrop(
+        {
+          claimId: claims[0].claimId!,
+          walletClient: mockWalletClient
+        },
+        { onLoading }
+      );
+
+      expect(mockClaim).toHaveBeenCalledWith(expect.any(Object), { onLoading });
+    });
+
+    it('should throw error for invalid claim ID', async () => {
+      const client = new AirdropClient({
+        projectId: 'AD_50lczFu9Yhvq',
+        endpoint: mockEndpoint
+      });
+
+      await expect(
+        client.claimAirdrop({
+          claimId: 'invalid_claim_id',
+          walletClient: mockWalletClient
+        })
+      ).rejects.toThrow();
+    });
+  });
+});

package/tsup.config.ts

@@ -0,0 +1,28 @@
+import { createTsupConfig } from '../tsup.config.base';
+
+export default createTsupConfig({
+  external: [
+    // Workspace dependencies (内部包依赖)
+    '@sign-global/tokentable-core',
+    '@sign-global/tokentable-wallets',
+
+    // External dependencies (外部依赖)
+    '@coral-xyz/anchor',
+    '@ethsign/utils-web',
+    '@orbs-network/ton-access',
+    '@solana/spl-token',
+    '@solana/wallet-adapter-base',
+    '@solana/wallet-adapter-wallets',
+    '@solana/web3.js',
+    '@ton/core',
+    '@ton/ton',
+    '@tonconnect/ui',
+    '@tonconnect/ui-react',
+    'bs58',
+    'ton-core',
+    'tonapi-sdk-js',
+    '@tonconnect/sdk',
+    'tonweb',
+    'viem'
+  ]
+});

package/.github/workflows/beta.yml

@@ -1,28 +0,0 @@
-name: beta publish
-on:
-  workflow_dispatch:
-
-jobs:
-  publish:
-    name: npm publish
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: latest
-          run_install: true
-      - name: Install dependencies
-        run: pnpm install
-
-      - name: Build
-        run: pnpm run build
-
-      - name: Setup npm auth
-        run: echo "//registry.npmjs.org/:_authToken=${{ secrets.PROD_NPM_AUTH_TOKEN }}" > ~/.npmrc
-
-      - name: Publish package
-        run: npm publish --tag beta --access=public

package/.github/workflows/push.yml

@@ -1,33 +0,0 @@
-name: npm publish
-on:
-  push:
-    branches:
-      - main
-    # file paths to consider in the event. Optional; defaults to all.
-    paths:
-      - package.json
-
-  workflow_dispatch:
-jobs:
-  publish:
-    name: npm publish
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Setup pnpm
-        # You may pin to the exact commit or the version.
-        # uses: pnpm/action-setup@c3b53f6a16e57305370b4ae5a540c2077a1d50dd
-        uses: pnpm/action-setup@v4
-        with:
-          # Version of pnpm to install
-          version: latest # optional
-          # Where to store pnpm files
-          # dest: # optional, default is ~/setup-pnpm
-          # If specified, run `pnpm install`
-          run_install: true # optional, default is null
-
-      - run: pnpm install
-      - run: pnpm run build
-      - run: echo "//registry.npmjs.org/:_authToken=${{ secrets.PROD_NPM_AUTH_TOKEN }}" > ~/.npmrc
-      - run: npm publish --access=public

package/.prettierignore

@@ -1,2 +0,0 @@
-dist
-node_modules

package/.prettierrc

@@ -1,7 +0,0 @@
-{
-  "singleQuote": true,
-  "tabWidth": 2,
-  "trailingComma": "none",
-  "printWidth": 120,
-  "endOfLine": "auto"
-}