@triadxyz/triad-protocol 3.1.5-beta → 3.1.6-beta

package/dist/claim.d.ts

@@ -23,15 +23,18 @@ export default class Claim {
     getClaimedUser(claimVault: PublicKey, user: PublicKey): Promise<import("./types").ClaimedUser>;
     /**
      * Claim Token
+     * @param claimData - Claim data
+     * @param vaultName - Vault name
+     * @param payer - Payer
+     * @param mint - Mint
      * @param amount - Amount to claim
-     * @param merkleProof - Merkle proof
      */
-    claimToken({ amount, merkleProof, mint, claimVault }: ClaimTokenArgs): Promise<string>;
+    claimToken({ mint, vaultName, payer, claimData, amount, isFirstComeFirstServed }: ClaimTokenArgs): Promise<string>;
     /**
      * Create Claim Vault
      * @param args - Create Claim Vault Args
      */
-    createClaimVault({ totalAmount, totalUsers, name, isFirstComeFirstServed, endTs, merkleRoot, mint }: CreateClaimVaultArgs): Promise<string>;
+    createClaimVault({ totalAmount, totalUsers, name, isFirstComeFirstServed, endTs, claimData, mint }: CreateClaimVaultArgs): Promise<string>;
     /**
      * Update Claim Vault Is Active
      * @param isActive - Is active

package/dist/claim.js

@@ -16,6 +16,7 @@ const anchor_1 = require("@coral-xyz/anchor");
 const helpers_1 = require("./utils/helpers");
 const sendVersionedTransaction_1 = __importDefault(require("./utils/sendVersionedTransaction"));
 const pda_1 = require("./utils/pda");
+const merkle_1 = require("./utils/merkle");
 class Claim {
     constructor(program, rpcOptions) {
         this.program = program;
@@ -55,21 +56,32 @@ class Claim {
     }
     /**
      * Claim Token
+     * @param claimData - Claim data
+     * @param vaultName - Vault name
+     * @param payer - Payer
+     * @param mint - Mint
      * @param amount - Amount to claim
-     * @param merkleProof - Merkle proof
      */
-    claimToken({ amount, merkleProof, mint, claimVault }) {
+    claimToken({ mint, vaultName, payer, claimData, amount, isFirstComeFirstServed }) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            let proof = [];
+            if (!isFirstComeFirstServed) {
+                const { proofs } = (0, merkle_1.generateMerkleTree)(claimData);
+                proof = (_a = proofs.find((p) => p.user.toBase58() === this.program.provider.publicKey.toBase58())) === null || _a === void 0 ? void 0 : _a.proof;
+            }
             const ixs = [
                 yield this.program.methods
                     .claimToken({
-                    amount: new anchor_1.BN(amount),
-                    merkleProof
+                    amount: new anchor_1.BN(amount * Math.pow(10, 6)),
+                    merkleProof: proof
                 })
                     .accounts({
                     signer: this.program.provider.publicKey,
+                    payer,
                     mint,
-                    claimVault
+                    claimVault: (0, pda_1.getClaimVaultPDA)(this.program.programId, vaultName),
+                    tokenProgram: (0, helpers_1.getTokenProgram)(mint)
                 })
                     .instruction()
             ];
@@ -80,12 +92,13 @@ class Claim {
      * Create Claim Vault
      * @param args - Create Claim Vault Args
      */
-    createClaimVault({ totalAmount, totalUsers, name, isFirstComeFirstServed, endTs, merkleRoot, mint }) {
+    createClaimVault({ totalAmount, totalUsers, name, isFirstComeFirstServed, endTs, claimData, mint }) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { merkleRoot } = (0, merkle_1.generateMerkleTree)(claimData);
             const ixs = [
                 yield this.program.methods
                     .createClaimVault({
-                    totalAmount: new anchor_1.BN(totalAmount),
+                    totalAmount: new anchor_1.BN(totalAmount * Math.pow(10, 6)),
                     totalUsers: new anchor_1.BN(totalUsers),
                     name,
                     isFirstComeFirstServed,
@@ -94,7 +107,8 @@ class Claim {
                 })
                     .accounts({
                     signer: this.program.provider.publicKey,
-                    mint
+                    mint,
+                    tokenProgram: (0, helpers_1.getTokenProgram)(mint)
                 })
                     .instruction()
             ];

package/dist/index.d.ts

@@ -5,8 +5,10 @@ import { TriadProtocol } from './types/triad_protocol';
 import { CreateMarketArgs, OpenOrderArgs, UserTrade, CreateCustomerArgs, MarketBidOrderArgs, CancelBidOrderArgs, CancelAskOrderArgs, PlaceBidOrderArgs, PlaceAskOrderArgs, CollectMarketFeeArgs, CreatePoolArgs, BookOrder, MarketAskOrderArgs, RpcOptions, OrderDirection } from './types';
 import Stake from './stake';
 import Poseidon from './poseidon';
+import Claim from './claim';
 export * from './types';
 export * from './utils/helpers';
+export * from './utils/merkle';
 export default class TriadProtocolClient {
     private connection;
     private wallet;
@@ -15,6 +17,7 @@ export default class TriadProtocolClient {
     provider: AnchorProvider;
     stake: Stake;
     poseidon: Poseidon;
+    claim: Claim;
     constructor(connection: Connection, wallet: Wallet, rpcOptions: RpcOptions);
     /**
      * Get All Pools

package/dist/index.js

@@ -28,6 +28,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const web3_js_1 = require("@solana/web3.js");
 const anchor_1 = require("@coral-xyz/anchor");
+const spl_token_1 = require("@solana/spl-token");
 const bn_js_1 = __importDefault(require("bn.js"));
 const idl_triad_protocol_json_1 = __importDefault(require("./types/idl_triad_protocol.json"));
 const types_1 = require("./types");
@@ -38,9 +39,10 @@ const sendVersionedTransaction_1 = __importDefault(require("./utils/sendVersione
 const swap_1 = require("./utils/swap");
 const stake_1 = __importDefault(require("./stake"));
 const poseidon_1 = __importDefault(require("./poseidon"));
-const spl_token_1 = require("@solana/spl-token");
+const claim_1 = __importDefault(require("./claim"));
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils/helpers"), exports);
+__exportStar(require("./utils/merkle"), exports);
 class TriadProtocolClient {
     constructor(connection, wallet, rpcOptions) {
         this.connection = connection;
@@ -52,6 +54,7 @@ class TriadProtocolClient {
         this.program = new anchor_1.Program(idl_triad_protocol_json_1.default, this.provider);
         this.stake = new stake_1.default(this.program, this.rpcOptions);
         this.poseidon = new poseidon_1.default(this.program, this.rpcOptions);
+        this.claim = new claim_1.default(this.program, this.rpcOptions);
     }
     /**
      * Get All Pools

package/dist/types/index.d.ts

@@ -207,6 +207,15 @@ export type ClaimedUser = {
     amount: number;
     ts: number;
 };
+export interface ClaimData {
+    user: PublicKey;
+    amount: number;
+}
+export interface MerkleProof {
+    user: PublicKey;
+    amount: number;
+    proof: number[][];
+}
 export type PlaceBidOrderArgs = {
     marketId: number;
     orders: {
@@ -320,13 +329,15 @@ export type CreateClaimVaultArgs = {
     name: string;
     isFirstComeFirstServed: boolean;
     endTs: number;
-    merkleRoot?: number[];
+    claimData: ClaimData[];
 };
 export type ClaimTokenArgs = {
     amount: number;
-    claimVault: PublicKey;
+    vaultName: string;
     mint: PublicKey;
-    merkleProof: number[][];
+    payer: PublicKey;
+    claimData: ClaimData[];
+    isFirstComeFirstServed: boolean;
 };
 export type UpdateClaimVaultIsActiveArgs = {
     isActive: boolean;

package/dist/utils/helpers.js

@@ -166,11 +166,11 @@ const formatClaimVault = (account, address) => {
         authority: account.authority.toString(),
         initTs: account.initTs.toNumber(),
         endTs: account.endTs.toNumber(),
-        totalAmount: account.totalAmount.toNumber(),
-        totalClaimed: account.totalClaimed.toNumber(),
+        totalAmount: account.totalAmount.toNumber() / Math.pow(10, 6),
+        totalClaimed: account.totalClaimed.toNumber() / Math.pow(10, 6),
         totalUsers: account.totalUsers.toNumber(),
         claimedUsers: account.claimedUsers.toNumber(),
-        tokenPerUser: account.tokenPerUser.toNumber(),
+        tokenPerUser: account.tokenPerUser.toNumber() / Math.pow(10, 6),
         mint: account.mint.toBase58(),
         isActive: account.isActive,
         name: account.name,
@@ -184,7 +184,7 @@ const formatClaimedUser = (account, address) => {
         user: address.toString(),
         address: account.user.toString(),
         claimVault: account.claimVault.toString(),
-        amount: account.amount.toNumber(),
+        amount: account.amount.toNumber() / Math.pow(10, 6),
         ts: account.ts.toNumber()
     };
 };

package/dist/utils/merkle.d.ts

@@ -0,0 +1,22 @@
+import { PublicKey } from '@solana/web3.js';
+import { ClaimData, MerkleProof } from '../types';
+export declare class MerkleTree {
+    private leaves;
+    private tree;
+    private claimData;
+    constructor(claimData: ClaimData[]);
+    private generateLeaves;
+    private buildTree;
+    getRoot(): number[];
+    getProof(userPubkey: PublicKey, amount: number): number[][];
+    getAllProofs(): MerkleProof[];
+    verifyProof(userPubkey: PublicKey, amount: number, proof: number[][]): boolean;
+}
+export declare function generateMerkleTree(claimData: ClaimData[]): {
+    merkleRoot: number[];
+    proofs: MerkleProof[];
+};
+export declare function createClaimData(data: {
+    user: string;
+    amount: number;
+}[]): ClaimData[];

package/dist/utils/merkle.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClaimData = exports.generateMerkleTree = exports.MerkleTree = void 0;
+const sha3_1 = require("@noble/hashes/sha3");
+const web3_js_1 = require("@solana/web3.js");
+class MerkleTree {
+    constructor(claimData) {
+        this.claimData = claimData;
+        this.leaves = this.generateLeaves(claimData);
+        this.tree = this.buildTree(this.leaves);
+    }
+    generateLeaves(claimData) {
+        return claimData.map((data) => {
+            const userBytes = data.user.toBytes();
+            const amountBytes = Buffer.alloc(8);
+            const amountLamports = BigInt(Math.floor(data.amount * Math.pow(10, 6)));
+            amountBytes.writeBigUInt64LE(amountLamports, 0);
+            const leafData = Buffer.concat([userBytes, amountBytes]);
+            return Buffer.from((0, sha3_1.keccak_256)(leafData));
+        });
+    }
+    buildTree(leaves) {
+        if (leaves.length === 0) {
+            throw new Error('Cannot build tree with no leaves');
+        }
+        let currentLevel = [...leaves];
+        const tree = [currentLevel];
+        while (currentLevel.length > 1) {
+            const nextLevel = [];
+            for (let i = 0; i < currentLevel.length; i += 2) {
+                const left = currentLevel[i];
+                const right = i + 1 < currentLevel.length ? currentLevel[i + 1] : left;
+                const combined = left.compare(right) <= 0
+                    ? Buffer.concat([left, right])
+                    : Buffer.concat([right, left]);
+                nextLevel.push(Buffer.from((0, sha3_1.keccak_256)(combined)));
+            }
+            currentLevel = nextLevel;
+            tree.push(currentLevel);
+        }
+        return tree;
+    }
+    getRoot() {
+        if (this.tree.length === 0) {
+            throw new Error('Tree not built');
+        }
+        const root = this.tree[this.tree.length - 1][0];
+        return Array.from(root);
+    }
+    getProof(userPubkey, amount) {
+        const targetLeaf = this.generateLeaves([{ user: userPubkey, amount }])[0];
+        const leafIndex = this.leaves.findIndex((leaf) => leaf.equals(targetLeaf));
+        if (leafIndex === -1) {
+            throw new Error('User not found in merkle tree');
+        }
+        const proof = [];
+        let currentIndex = leafIndex;
+        for (let level = 0; level < this.tree.length - 1; level++) {
+            const isRightNode = currentIndex % 2 === 1;
+            const siblingIndex = isRightNode ? currentIndex - 1 : currentIndex + 1;
+            if (siblingIndex < this.tree[level].length) {
+                proof.push(this.tree[level][siblingIndex]);
+            }
+            currentIndex = Math.floor(currentIndex / 2);
+        }
+        return proof.map((hash) => Array.from(hash));
+    }
+    getAllProofs() {
+        return this.claimData.map((data) => ({
+            user: data.user,
+            amount: data.amount,
+            proof: this.getProof(data.user, data.amount)
+        }));
+    }
+    verifyProof(userPubkey, amount, proof) {
+        const leafData = Buffer.concat([
+            userPubkey.toBytes(),
+            (() => {
+                const amountBytes = Buffer.alloc(8);
+                const amountLamports = BigInt(Math.floor(amount * Math.pow(10, 6)));
+                amountBytes.writeBigUInt64LE(amountLamports, 0);
+                return amountBytes;
+            })()
+        ]);
+        let currentHash = Buffer.from((0, sha3_1.keccak_256)(leafData));
+        for (const proofElement of proof) {
+            const proofBuffer = Buffer.from(proofElement);
+            const combined = currentHash.compare(proofBuffer) <= 0
+                ? Buffer.concat([currentHash, proofBuffer])
+                : Buffer.concat([proofBuffer, currentHash]);
+            currentHash = Buffer.from((0, sha3_1.keccak_256)(combined));
+        }
+        const root = Buffer.from(this.getRoot());
+        return currentHash.equals(root);
+    }
+}
+exports.MerkleTree = MerkleTree;
+function generateMerkleTree(claimData) {
+    const tree = new MerkleTree(claimData);
+    return {
+        merkleRoot: tree.getRoot(),
+        proofs: tree.getAllProofs()
+    };
+}
+exports.generateMerkleTree = generateMerkleTree;
+function createClaimData(data) {
+    return data.map((item) => ({
+        user: new web3_js_1.PublicKey(item.user),
+        amount: item.amount
+    }));
+}
+exports.createClaimData = createClaimData;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triadxyz/triad-protocol",
-  "version": "3.1.5-beta",
+  "version": "3.1.6-beta",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",