@sign-global/tokentable-core 1.1.0 → 1.2.0

package/dist/index.mjs

@@ -15,6 +15,7 @@ import {
 } from "viem/chains";
 
 // src/constants/network.ts
+import { getFullnodeUrl } from "@mysten/sui/client";
 import { CHAIN } from "@tonconnect/sdk";
 import { defineChain } from "viem";
 var mevmDevNet = defineChain({
@@ -161,6 +162,56 @@ var signBrBTestnet = /* @__PURE__ */ defineChain({
   },
   testnet: true
 });
+var 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
+};
+var 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
+};
 
 // src/constants/chain-config.ts
 import { CHAIN as CHAIN2 } from "@tonconnect/sdk";
@@ -247,6 +298,14 @@ var 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]
   }
 };
 var SupportedChains = [
@@ -3660,6 +3719,7 @@ var ChainType = /* @__PURE__ */ ((ChainType2) => {
   ChainType2["Evm"] = "evm";
   ChainType2["Ton"] = "ton";
   ChainType2["Solana"] = "solana";
+  ChainType2["Sui"] = "sui";
   return ChainType2;
 })(ChainType || {});
 var AirdropSigIdentityTypeEnum = /* @__PURE__ */ ((AirdropSigIdentityTypeEnum2) => {
@@ -3726,7 +3786,7 @@ async function getOrCreateAssociatedTokenAccount({
   payer,
   mint,
   owner,
-  signTransaction,
+  signTransaction: signTransaction2,
   allowOwnerOffCurve = false,
   commitment,
   programId = TOKEN_PROGRAM_ID,
@@ -3759,7 +3819,7 @@ async function getOrCreateAssociatedTokenAccount({
         console.log(blockhash, "blockhash");
         transaction.feePayer = await payer;
         transaction.recentBlockhash = blockhash;
-        const signed = await signTransaction(transaction);
+        const signed = await signTransaction2(transaction);
         const signature = await connection.sendRawTransaction(signed.serialize());
         const latestBlockhash = await connection.getLatestBlockhash();
         await connection.confirmTransaction(
@@ -12218,6 +12278,395 @@ var AirdropService3 = class {
     return fromNano2(feeInfo.claimFee);
   }
 };
+
+// src/contracts/sui/SuiContractClient.ts
+import { SuiClient, getFullnodeUrl as getFullnodeUrl2 } from "@mysten/sui/client";
+import { bcs } from "@mysten/sui/bcs";
+import { Transaction as Transaction2 } from "@mysten/sui/transactions";
+import { signTransaction } from "@mysten/wallet-standard";
+var SuiContractClientBase = class {
+  packageId;
+  chainId;
+  moduleName;
+  distributorId;
+  wallet;
+  client;
+  constructor(contractInfo) {
+    this.packageId = contractInfo.packageId;
+    this.chainId = contractInfo.chainId ? contractInfo.chainId : "mainnet";
+    this.moduleName = contractInfo.moduleName;
+    this.distributorId = contractInfo.distributorId;
+    this.wallet = contractInfo.walletClient;
+    this.client = new SuiClient({ network: this.chainId, url: getFullnodeUrl2(this.chainId) });
+  }
+  async signAndExecute(tx) {
+    if (!this.wallet) {
+      throw new Error("Wallet not connected");
+    }
+    if (!this.wallet.features?.["sui:signTransaction"] && !this.wallet.features?.["sui:signTransactionBlock"]) {
+      throw new Error("Wallet doesn't support transaction signing");
+    }
+    const accounts = await this.wallet.accounts;
+    const client = this.client;
+    if (!accounts || accounts.length === 0) {
+      throw new Error("No wallet account connected");
+    }
+    const signerAccount = accounts[0];
+    if ("setSenderIfNotSet" in tx) {
+      tx.setSenderIfNotSet(signerAccount.address);
+    }
+    console.log(
+      tx,
+      await tx.toJSON({
+        supportedIntents: [],
+        client
+      })
+    );
+    const chain = `sui:${this.chainId}`;
+    const { signature, bytes } = await signTransaction(this.wallet, {
+      transaction: {
+        async toJSON() {
+          return typeof tx === "string" ? tx : await tx.toJSON({
+            supportedIntents: [],
+            client
+          });
+        }
+      },
+      account: signerAccount,
+      chain
+    });
+    const result = await this.client.executeTransactionBlock({
+      transactionBlock: bytes,
+      signature,
+      options: {
+        showEffects: true,
+        showEvents: true
+      }
+    });
+    await this.waitForTx(result.digest);
+    return result;
+  }
+  async waitForTx(digest) {
+    return this.client.waitForTransaction({
+      digest,
+      options: { showEffects: true, showEvents: true }
+    });
+  }
+  /**
+   * 读取合约返回值（只读调用）
+   * @param func Move function 名
+   * @param typeArgs 类型参数
+   * @param args Move function 参数
+   */
+  async readMoveFunction(func, typeArgs = [], args = []) {
+    const DEFAULT_SENDER = "0x0000000000000000000000000000000000000000000000000000000000000001";
+    const sender = this.wallet?.accounts?.[0]?.address || DEFAULT_SENDER;
+    if (!sender) throw new Error("No wallet account selected");
+    const tx = new Transaction2();
+    tx.moveCall({
+      target: `${this.packageId}::${this.moduleName}::${func}`,
+      typeArguments: typeArgs,
+      arguments: args.map((arg) => {
+        if (Array.isArray(arg)) return tx.pure(bcs.vector(bcs.vector(bcs.u8())).serialize(arg));
+        if (typeof arg === "string" && arg.startsWith("0x")) return tx.object(arg);
+        return tx.pure(arg);
+      })
+    });
+    const res = await this.client.devInspectTransactionBlock({
+      sender,
+      transactionBlock: tx
+      // ✅ 这里传 Transaction，不再报 TS 类型错误
+    });
+    console.log(res, "res");
+    if (!res || !res.results?.[0]?.returnValues) {
+      throw new Error(`Failed to read ${func}`);
+    }
+    return res.results[0].returnValues[0];
+  }
+  /**
+   * 查询 Distributor MoveObject 的 fields
+   */
+  async getObjectFields(objectId) {
+    const res = await this.client.getObject({
+      id: objectId,
+      options: { showContent: true }
+    });
+    if (res.data?.content?.dataType !== "moveObject") {
+      throw new Error(`Object ${objectId} is not a moveObject`);
+    }
+    return res.data.content.fields;
+  }
+  async getSharedObjectRef(tx, objectId, mutable) {
+    const obj = await this.client.getObject({
+      id: objectId,
+      options: { showOwner: true }
+    });
+    console.log(obj, "obj");
+    if (!obj.data) {
+      throw new Error(`Object ${objectId} not found`);
+    }
+    if (!obj.data.owner?.Shared) {
+      throw new Error(`Object ${objectId} is not a shared object`);
+    }
+    const initialSharedVersion = obj.data.owner.Shared.initial_shared_version;
+    return tx.sharedObjectRef({
+      objectId,
+      initialSharedVersion: Number(initialSharedVersion),
+      mutable
+    });
+  }
+};
+
+// src/contracts/sui/BaseDistributorClient.ts
+import { Transaction as Transaction3 } from "@mysten/sui/transactions";
+import { bcs as bcs2 } from "@mysten/sui/bcs";
+var SuiBaseDistributorClient = class extends SuiContractClientBase {
+  constructor(info) {
+    super({ ...info, moduleName: "base_distributor" });
+  }
+  async createDistributor(coinType, projectId, projectRegistryId) {
+    const tx = new Transaction3();
+    const projectIdBytes = bcs2.vector(bcs2.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;
+    if (result.effects?.created) {
+      const createdObj = result.effects.created.find(
+        (obj) => obj.owner === "Shared" || obj.owner?.Shared
+        // 某些版本字段是对象
+      );
+      if (createdObj) {
+        distributorId = createdObj.reference.objectId;
+      }
+    }
+    return {
+      txResult: result,
+      distributorId
+    };
+  }
+  async setBaseParams(coinType, startTime, endTime, authorizedSigner, ownerCapId) {
+    const tx = new Transaction3();
+    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, ownerCapId) {
+    const tx = new Transaction3();
+    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 = res.data?.content;
+    const fields = content?.fields;
+    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) : void 0,
+      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) {
+    return 0n;
+  }
+  async batchFetchClaimed(coinType, claimIds) {
+    const claimIdsBytes = claimIds.map((id) => Array.from(new TextEncoder().encode(id)));
+    const res = await this.readMoveFunction(
+      "get_claim_status",
+      [coinType],
+      [this.distributorId, claimIdsBytes]
+    );
+    console.log(res, "claims");
+    const [data, type] = res;
+    if (type === "vector<bool>" && data) {
+      const uint8Array = new Uint8Array(data);
+      return Array.from(bcs2.vector(bcs2.bool()).parse(uint8Array));
+    }
+    return [];
+  }
+  async getDistributorId(projectId, projectRegistryId) {
+    const distributorId = await this.readMoveFunction(
+      "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");
+    const ownerCapId = objects.data[0]?.data?.objectId;
+    return ownerCapId;
+  }
+};
+
+// src/contracts/sui/DistributorWithFeeClient.ts
+import { Transaction as Transaction4 } from "@mysten/sui/transactions";
+import { bcs as bcs3 } from "@mysten/sui/bcs";
+var SuiDistributorWithFeeClient = class extends SuiContractClientBase {
+  constructor(info) {
+    super({ ...info, moduleName: "fungible_token_with_fees_distributor" });
+  }
+  async prepareFeePayment(totalFeesStr, feeTokenType, tx) {
+    const totalFees = BigInt(totalFeesStr);
+    const coins = await this.client.getCoins({
+      owner: this.wallet.accounts[0].address,
+      coinType: feeTokenType
+    });
+    const suitableCoin = coins.data.find((coin) => BigInt(coin.balance) >= totalFees);
+    if (suitableCoin) {
+      if (BigInt(suitableCoin.balance) === totalFees) {
+        return tx.object(suitableCoin.coinObjectId);
+      }
+      const [feeCoin] = tx.splitCoins(tx.object(suitableCoin.coinObjectId), [tx.pure(bcs3.u64().serialize(totalFees))]);
+      return feeCoin;
+    }
+    throw new Error(`Insufficient balance. Required: ${totalFeesStr}, Available coins: ${coins.data.length}`);
+  }
+  async claimWithFee(coinType, feeCollector, data) {
+    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, amount, fees) {
+      const tsBytes = bcs3.u64().serialize(timestamp).toBytes();
+      const amtBytes = bcs3.u64().serialize(amount).toBytes();
+      const feeBytes = bcs3.u64().serialize(fees).toBytes();
+      return Array.from(new Uint8Array([...tsBytes, ...amtBytes, ...feeBytes]));
+    }
+    const datas = data.map((item) => {
+      const claimData = item.data;
+      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 Transaction4();
+    const distributor = await this.getSharedObjectRef(tx, this.distributorId, true);
+    const feeConfig = await this.getSharedObjectRef(tx, feeCollector, true);
+    const clock = await this.getSharedObjectRef(tx, "0x6", false);
+    const hexToBytes = (hex) => Array.from(Buffer.from(hex.replace(/^0x/, ""), "hex"));
+    const feeTokenType = "0x2::sui::SUI";
+    const [feeCoin] = tx.splitCoins(
+      tx.gas,
+      // 用 gas 对象作为源
+      [tx.pure(bcs3.u64().serialize(totalFees))]
+    );
+    tx.moveCall({
+      target: `${this.packageId}::${this.moduleName}::claim_with_fees`,
+      arguments: [
+        distributor,
+        feeConfig,
+        tx.pure(bcs3.vector(bcs3.Address).serialize(recipients)),
+        // recipients: vector<address>
+        tx.pure(
+          bcs3.vector(bcs3.vector(bcs3.u8())).serialize(claimIds.map((id) => Array.from(new TextEncoder().encode(id))))
+        ),
+        // claim_ids: vector<vector<u8>>
+        tx.pure(bcs3.vector(bcs3.vector(bcs3.u8())).serialize(datas)),
+        // claim_datas: vector<vector<u8>>
+        tx.pure(bcs3.vector(bcs3.vector(bcs3.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;
+  }
+};
+
+// src/contracts/sui/SignatureAirdropService.ts
+var SignatureAirdropService3 = class {
+  options;
+  constructor(options) {
+    const chainConfig = getChainConfig(options.chainId);
+    this.options = {
+      ...options,
+      packageId: chainConfig.contractAddress
+    };
+  }
+  get baseDistributorClient() {
+    if (!this.options) {
+      throw new Error("options is empty");
+    }
+    return new SuiBaseDistributorClient(this.options);
+  }
+  get feeDistributorClient() {
+    if (!this.options) {
+      throw new Error("options is empty");
+    }
+    return new SuiDistributorWithFeeClient(this.options);
+  }
+  async getVersion() {
+    return this.baseDistributorClient.getVersion();
+  }
+  async getClaimFee(address, amount) {
+    const fee = await this.baseDistributorClient.getClaimFee(amount);
+    return fee;
+  }
+  async batchFetchClaimed(userClaimIds) {
+    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, recipient) {
+    const { feeCollector } = await this.getContractInfo();
+    return this.feeDistributorClient.claimWithFee(this.options.coinType, feeCollector, data);
+  }
+};
 export {
   AirdropSigIdentityTypeEnum,
   ApiClient,
@@ -12232,6 +12681,7 @@ export {
   AirdropService2 as SolanaAirdropService,
   SignatureAirdropService2 as SolanaSignatureAirdropService,
   SplTokenVersion,
+  SignatureAirdropService3 as SuiSignatureAirdropService,
   SupportedChains,
   AirdropService3 as TonAirdropService,
   TonAirdropVersionEnum,
@@ -12274,6 +12724,8 @@ export {
   signBrBTestnet,
   solanaDevNet,
   solanaMainNet,
+  suiMainNet,
+  suiTestNet,
   tonMainNet,
   tonTestNet
 };