@sign-global/tokentable-core 1.1.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sign-global/tokentable-core",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -35,7 +35,10 @@
     "@solana/wallet-adapter-react": "^0.15.0",
     "bignumber.js": "^9.1.2",
     "dayjs": "^1.11.13",
-    "nanoid": "^5.0.9"
+    "nanoid": "^5.0.9",
+    "@mysten/dapp-kit": "^0.16.3",
+    "@mysten/sui": "^1.29.1",
+    "@mysten/wallet-standard": "^0.16.10"
   },
   "publishConfig": {
     "access": "public"

package/src/constants/chain-config.ts

@@ -12,7 +12,16 @@ import {
   berachainTestnet,
   arbitrum
 } from 'viem/chains';
-import { mevmDevNet, signBrBTestnet, solanaDevNet, solanaMainNet, tonMainNet, tonTestNet } from './network';
+import {
+  mevmDevNet,
+  signBrBTestnet,
+  solanaDevNet,
+  solanaMainNet,
+  suiMainNet,
+  suiTestNet,
+  tonMainNet,
+  tonTestNet
+} from './network';
 import { CHAIN } from '@tonconnect/sdk';
 
 export const ChainConfig = {
@@ -96,6 +105,14 @@ export const ChainConfig = {
   [solanaMainNet.id]: {
     contractAddress: '',
     rpcUrl: solanaMainNet.rpcUrls.default.http[0]
+  },
+  [suiTestNet.id]: {
+    contractAddress: '0xb99be918b901c472b9839871b0341bf53a4d94a19312008a2e6c98908c92b778',
+    rpcUrl: suiTestNet.rpcUrls.default.http[0]
+  },
+  [suiMainNet.id]: {
+    contractAddress: '',
+    rpcUrl: suiMainNet.rpcUrls.default.http[0]
   }
 };
 

package/src/constants/network.ts

@@ -1,3 +1,4 @@
+import { getFullnodeUrl } from '@mysten/sui/client';
 import { CHAIN } from '@tonconnect/sdk';
 import { defineChain } from 'viem';
 
@@ -150,3 +151,55 @@ export const signBrBTestnet = /*#__PURE__*/ defineChain({
   },
   testnet: true
 });
+
+export const suiTestNet = {
+  id: 'testnet',
+  name: 'Sui Testnet',
+  network: 'Sui Testnet',
+  nativeCurrency: {
+    decimals: 9,
+    name: 'Sui',
+    symbol: 'SUI'
+  },
+  rpcUrls: {
+    public: {
+      http: [getFullnodeUrl('testnet')]
+    },
+    default: {
+      http: [getFullnodeUrl('testnet')]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: 'sui scan',
+      url: 'https://testnet.suivision.xyz/'
+    }
+  },
+  testnet: true
+};
+
+export const suiMainNet = {
+  id: 'mainnet',
+  name: 'Sui Mainnet',
+  network: 'Sui Mainnet',
+  nativeCurrency: {
+    decimals: 9,
+    name: 'Sui',
+    symbol: 'SUI'
+  },
+  rpcUrls: {
+    public: {
+      http: [getFullnodeUrl('mainnet')]
+    },
+    default: {
+      http: [getFullnodeUrl('mainnet')]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: 'sui scan',
+      url: 'https://suivision.xyz/'
+    }
+  },
+  testnet: false
+};

package/src/contracts/index.ts

@@ -8,3 +8,6 @@ export { SignatureAirdropService as SolanaSignatureAirdropService } from './sola
 
 // TON Contracts
 export { AirdropService as TonAirdropService } from './ton/AirdropService';
+
+// SUI Contracts
+export { SignatureAirdropService as SuiSignatureAirdropService } from './sui/SignatureAirdropService';

package/src/contracts/solana/AirdropSignatureClient.ts

@@ -6,6 +6,7 @@ import { EddsaTokenWithFeesDistributorSolana } from './eddsa_token_with_fees_dis
 import { TOKEN_2022_PROGRAM_ID } from '@solana/spl-token';
 import { FeeCollectorClient } from './FeeCollectorClient';
 import { fetchTokenVersion, getOrCreateAssociatedTokenAccount, hexStrToU8Array } from '../../utils';
+import { ISignatureClaimData } from '../../types';
 
 export class AirdropSignatureClient extends SolanaContractClientBase<EddsaTokenWithFeesDistributorSolana> {
   projectId: string;
@@ -156,19 +157,7 @@ export class AirdropSignatureClient extends SolanaContractClientBase<EddsaTokenW
     };
   }
 
-  async claim(
-    data: {
-      recipient: string;
-      data: string;
-      claimId: string;
-      signature: string;
-      extraData?: string;
-      unlockingAt: number;
-      value: string;
-      fees: string;
-      hash: string;
-    }[]
-  ) {
+  async claim(data: ISignatureClaimData[]) {
     const config = await this.getContractInfo();
     const feeCollectorStoragePDA = await this.FeeCollector.getStoragePDA();
     const feePDA = await this.FeeCollector.getProjectFeePDA(this.programId);

package/src/contracts/solana/SignatureAirdropService.ts

@@ -1,3 +1,4 @@
+import { ISignatureClaimData } from '../../types';
 import { AirdropSignatureClient } from './AirdropSignatureClient';
 import { SolanaContractInfo } from './SolanaContractClient';
 
@@ -33,20 +34,7 @@ export class SignatureAirdropService {
     return this.airdropClient.getPaused();
   }
 
-  async claim(
-    data: {
-      recipient: string;
-      claimId: string;
-      data: string;
-      signature: string;
-      extraData?: string;
-      unlockingAt: number;
-      value: string;
-      hash: string;
-      fees: string;
-    }[],
-    recipient?: string
-  ) {
+  async claim(data: ISignatureClaimData[], recipient?: string) {
     return this.airdropClient.claim(data);
   }
 }

package/src/contracts/solana/SolanaContractClient.ts

@@ -32,13 +32,13 @@ export abstract class SolanaContractClientBase<T extends Idl = Idl> {
     this.wallet = walletClient;
     this.chainRpc = chainRpc;
 
-    const provider = new AnchorProvider(this.connection, this.wallet, { commitment: 'confirmed' });
+    const provider = new AnchorProvider(this.connection as any, this.wallet, { commitment: 'confirmed' });
     setProvider(provider);
 
     this.program = new Program(idl, provider);
   }
 
-  get programId() {
+  get programId(): PublicKey {
     return this.program.programId;
   }
 

package/src/contracts/sui/BaseDistributorClient.ts

@@ -0,0 +1,162 @@
+import { SuiContractClientBase, SuiContractInfo } from './SuiContractClient';
+import { Transaction } from '@mysten/sui/transactions';
+import { bcs } from '@mysten/sui/bcs';
+
+export class SuiBaseDistributorClient extends SuiContractClientBase {
+  constructor(info: SuiContractInfo) {
+    super({ ...info, moduleName: 'base_distributor' }); // 固定 base_distributor
+  }
+
+  async createDistributor(coinType: string, projectId: string, projectRegistryId: string) {
+    const tx = new Transaction();
+    // 使用 Uint8Array 编码 vector<u8>
+    const projectIdBytes = bcs.vector(bcs.u8()).serialize(Array.from(Buffer.from(projectId, 'utf8')));
+
+    tx.moveCall({
+      target: `${this.packageId}::${this.moduleName}::create_and_share_distributor`,
+      typeArguments: [coinType],
+      arguments: [tx.pure(projectIdBytes), tx.object(projectRegistryId)]
+    });
+
+    const result = await this.signAndExecute(tx);
+
+    console.log(result, 'res');
+
+    let distributorId: string | undefined;
+    if (result.effects?.created) {
+      const createdObj = result.effects.created.find(
+        (obj: any) => obj.owner === 'Shared' || obj.owner?.Shared // 某些版本字段是对象
+      );
+      if (createdObj) {
+        distributorId = createdObj.reference.objectId;
+      }
+    }
+
+    return {
+      txResult: result,
+      distributorId
+    };
+  }
+
+  async setBaseParams(
+    coinType: string,
+    startTime: string | number,
+    endTime: string | number,
+    authorizedSigner: string,
+    ownerCapId: string
+  ) {
+    const tx = new Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::${this.moduleName}::set_base_params`,
+      typeArguments: [coinType],
+      arguments: [
+        tx.object(this.distributorId!),
+        tx.pure.u64(startTime),
+        tx.pure.u64(endTime),
+        tx.pure.address(authorizedSigner),
+        tx.object(ownerCapId)
+      ]
+    });
+    return this.signAndExecute(tx);
+  }
+
+  async togglePause(coinType: string, ownerCapId: string) {
+    const tx = new Transaction();
+    tx.moveCall({
+      target: `${this.packageId}::${this.moduleName}::toggle_pause`,
+      typeArguments: [coinType],
+      arguments: [tx.object(this.distributorId!), tx.object(ownerCapId)]
+    });
+    return this.signAndExecute(tx);
+  }
+
+  async getDistributorInfo() {
+    console.log(this.client, this.distributorId, 'distributorId');
+    const res = await this.client.getObject({
+      id: this.distributorId!,
+      options: { showContent: true }
+    });
+    const content: any = (res as any).data?.content as any;
+    const fields = content?.fields as any;
+    const match = content?.type.match(/<(.+)>$/);
+    const coinType = match ? match[1] : '';
+    return {
+      startTime: fields?.start_time,
+      endTime: fields?.end_time,
+      signer: fields?.authorized_signer,
+      ownerCapId: fields?.owner_cap_id,
+      version: fields?.version ? String.fromCharCode(...(fields.version as number[])) : undefined,
+      feeCollector: fields?.fee_collector,
+      token: coinType,
+      tokenBalance: fields?.token_balance,
+      paused: fields?.paused
+    };
+  }
+
+  async getVersion() {
+    const { version } = await this.getDistributorInfo();
+    return version;
+  }
+
+  async getPaused() {
+    const { paused } = await this.getDistributorInfo();
+    return paused;
+  }
+
+  async getClaimFee(amount: bigint) {
+    // const { token } = await this.getDistributorInfo();
+    // const fee = await this.readMoveFunction<{ Some?: string; None?: null }>(
+    //   'get_claim_fee',
+    //   [token],
+    //   [amount]
+    // );
+    // return fee;
+    return 0n;
+  }
+
+  async batchFetchClaimed(coinType: string, claimIds: string[]): Promise<boolean[]> {
+    const claimIdsBytes = claimIds.map((id) => Array.from(new TextEncoder().encode(id)));
+    const res = await this.readMoveFunction<[number[], string]>(
+      'get_claim_status',
+      [coinType],
+      [this.distributorId!, claimIdsBytes]
+    );
+    console.log(res, 'claims');
+
+    const [data, type] = res;
+
+    // 使用 BCS 解码 vector<bool>
+    if (type === 'vector<bool>' && data) {
+      // data 通常是 Uint8Array 格式
+      const uint8Array = new Uint8Array(data);
+      return Array.from(bcs.vector(bcs.bool()).parse(uint8Array));
+    }
+    return [];
+  }
+
+  async getDistributorId(projectId: string, projectRegistryId: string) {
+    const distributorId = await this.readMoveFunction<{ Some?: string; None?: null }>(
+      'get_distributor_by_project_id',
+      [],
+      [projectRegistryId, Array.from(Buffer.from(projectId, 'utf8'))]
+    );
+    console.log(distributorId, 'id');
+    return distributorId.Some;
+  }
+
+  async getOwnerCapId() {
+    const objects = await this.client.getOwnedObjects({
+      owner: this.wallet.accounts[0].address,
+      filter: {
+        StructType: `${this.packageId}::ownable::OwnerCap`
+      }
+    });
+
+    console.log(objects, 'objects');
+
+    // 获取 OwnerCap 对象ID
+    const ownerCapId = objects.data[0]?.data?.objectId;
+
+    return ownerCapId;
+  }
+}

package/src/contracts/sui/DistributorWithFeeClient.ts

@@ -0,0 +1,102 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { SuiContractClientBase, SuiContractInfo } from './SuiContractClient';
+import { bcs } from '@mysten/sui/bcs';
+import { ISignatureClaimData } from '../../types';
+
+export class SuiDistributorWithFeeClient extends SuiContractClientBase {
+  constructor(info: SuiContractInfo) {
+    super({ ...info, moduleName: 'fungible_token_with_fees_distributor' });
+  }
+
+  private async prepareFeePayment(totalFeesStr: string, feeTokenType: string, tx: Transaction): Promise<any> {
+    const totalFees = BigInt(totalFeesStr);
+
+    // 获取用户的 coins
+    const coins = await this.client.getCoins({
+      owner: this.wallet.accounts[0].address,
+      coinType: feeTokenType
+    });
+
+    // 找到足够余额的单个 coin
+    const suitableCoin = coins.data.find((coin) => BigInt(coin.balance) >= totalFees);
+
+    if (suitableCoin) {
+      // 如果coin的余额正好等于所需费用，直接使用
+      if (BigInt(suitableCoin.balance) === totalFees) {
+        return tx.object(suitableCoin.coinObjectId);
+      }
+      // 如果coin的余额大于所需费用，需要分割coin
+      const [feeCoin] = tx.splitCoins(tx.object(suitableCoin.coinObjectId), [tx.pure(bcs.u64().serialize(totalFees))]);
+      return feeCoin;
+    }
+
+    // 如果没有单个足够的 coin，需要合并多个 coins
+    // 这里可以实现 coin 合并逻辑或抛出错误
+    throw new Error(`Insufficient balance. Required: ${totalFeesStr}, Available coins: ${coins.data.length}`);
+  }
+
+  async claimWithFee(coinType: string, feeCollector: string, data: ISignatureClaimData[]) {
+    console.log(data, feeCollector, this.distributorId, 'data');
+    const recipients = data.map((item) => item.recipient);
+    const claimIds = data.map((item) => item.claimId);
+    const signatures = data.map((item) => item.signature);
+
+    function encodeClaimDataWithFees(timestamp: bigint, amount: bigint, fees: bigint): number[] {
+      const tsBytes = bcs.u64().serialize(timestamp).toBytes(); // 8B, LE
+      const amtBytes = bcs.u64().serialize(amount).toBytes(); // 8B, LE
+      const feeBytes = bcs.u64().serialize(fees).toBytes(); // 8B, LE
+      return Array.from(new Uint8Array([...tsBytes, ...amtBytes, ...feeBytes])); // 24B
+    }
+    const datas = data.map((item) => {
+      const claimData = item.data as {
+        claimableTimestamp: string;
+        claimableAmount: string;
+      };
+      return encodeClaimDataWithFees(
+        BigInt(claimData.claimableTimestamp),
+        BigInt(claimData.claimableAmount),
+        BigInt(item.fees || '0')
+      );
+    });
+    const totalFees = data.map((item) => BigInt(item.fees || '0')).reduce((sum, fee) => sum + fee, BigInt(0));
+    const tx = new Transaction();
+    // 获取 distributor (mutable)
+    const distributor = await this.getSharedObjectRef(tx, this.distributorId!, true);
+
+    // 获取 feeCollector (mutable)
+    const feeConfig = await this.getSharedObjectRef(tx, feeCollector, true);
+
+    // 获取 clock (immutable, Sui 系统对象)
+    const clock = await this.getSharedObjectRef(tx, '0x6', false);
+
+    const hexToBytes = (hex: string) => Array.from(Buffer.from(hex.replace(/^0x/, ''), 'hex'));
+
+    const feeTokenType = '0x2::sui::SUI'; // 或其他费用代币类型
+
+    const [feeCoin] = tx.splitCoins(
+      tx.gas, // 用 gas 对象作为源
+      [tx.pure(bcs.u64().serialize(totalFees))]
+    );
+
+    // 调用 claim_with_fees 方法
+    tx.moveCall({
+      target: `${this.packageId}::${this.moduleName}::claim_with_fees`,
+      arguments: [
+        distributor,
+        feeConfig,
+        tx.pure(bcs.vector(bcs.Address).serialize(recipients as string[])), // recipients: vector<address>
+        tx.pure(
+          bcs.vector(bcs.vector(bcs.u8())).serialize(claimIds.map((id) => Array.from(new TextEncoder().encode(id))))
+        ), // claim_ids: vector<vector<u8>>
+        tx.pure(bcs.vector(bcs.vector(bcs.u8())).serialize(datas)), // claim_datas: vector<vector<u8>>
+        tx.pure(bcs.vector(bcs.vector(bcs.u8())).serialize(signatures.map((sig) => hexToBytes(sig)))), // signatures: vector<vector<u8>>
+        feeCoin,
+        clock
+      ],
+      typeArguments: [coinType, feeTokenType] // Token类型, Fee类型
+    });
+
+    const res = await this.signAndExecute(tx);
+    return res.digest;
+  }
+}

package/src/contracts/sui/SignatureAirdropService.ts

@@ -0,0 +1,59 @@
+import { getChainConfig } from '../../common';
+import { ISignatureClaimData } from '../../types';
+import { SuiBaseDistributorClient } from './BaseDistributorClient';
+import { SuiDistributorWithFeeClient } from './DistributorWithFeeClient';
+import { SuiContractInfo } from './SuiContractClient';
+
+export class SignatureAirdropService {
+  options: SuiContractInfo;
+  constructor(options: Omit<SuiContractInfo, 'packageId'>) {
+    const chainConfig = getChainConfig(options.chainId as any);
+    this.options = {
+      ...options,
+      packageId: chainConfig.contractAddress
+    };
+  }
+
+  private get baseDistributorClient(): SuiBaseDistributorClient {
+    if (!this.options) {
+      throw new Error('options is empty');
+    }
+
+    return new SuiBaseDistributorClient(this.options);
+  }
+
+  private get feeDistributorClient(): SuiDistributorWithFeeClient {
+    if (!this.options) {
+      throw new Error('options is empty');
+    }
+
+    return new SuiDistributorWithFeeClient(this.options);
+  }
+
+  async getVersion() {
+    return this.baseDistributorClient.getVersion();
+  }
+
+  async getClaimFee(address: string, amount: bigint): Promise<bigint> {
+    const fee = await this.baseDistributorClient.getClaimFee(amount);
+    return fee;
+  }
+
+  async batchFetchClaimed(userClaimIds: string[]): Promise<boolean[]> {
+    const res = await this.baseDistributorClient.batchFetchClaimed(this.options.coinType, userClaimIds);
+    return res;
+  }
+
+  async getPaused() {
+    return this.baseDistributorClient.getPaused();
+  }
+
+  async getContractInfo() {
+    return this.baseDistributorClient.getDistributorInfo();
+  }
+
+  async claim(data: ISignatureClaimData[], recipient?: string) {
+    const { feeCollector } = await this.getContractInfo();
+    return this.feeDistributorClient.claimWithFee(this.options.coinType, feeCollector, data);
+  }
+}