@triadxyz/triad-protocol 3.1.4-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
@@ -434,4 +437,13 @@ export default class TriadProtocolClient {
      * @param question - Question
      */
     updatePoolQuestion(poolId: number, question: string): Promise<string>;
+    /**
+     * Update Customer Fee
+     * @param customerId - Customer ID
+     * @param feeBps - Fee in basis points
+     */
+    updateCustomerFee({ customerId, feeBps }: {
+        customerId: number;
+        feeBps: number;
+    }): Promise<string>;
 }

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
@@ -1145,5 +1148,22 @@ class TriadProtocolClient {
             return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
         });
     }
+    /**
+     * Update Customer Fee
+     * @param customerId - Customer ID
+     * @param feeBps - Fee in basis points
+     */
+    updateCustomerFee({ customerId, feeBps }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            ixs.push(yield this.program.methods
+                .updateCustomerFee({ id: customerId, feeBps })
+                .accounts({
+                signer: this.program.provider.publicKey
+            })
+                .instruction());
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
 }
 exports.default = TriadProtocolClient;

package/dist/types/idl_triad_protocol.json

@@ -2566,6 +2566,47 @@
                 }
             ]
         },
+        {
+            "name": "update_customer_fee",
+            "discriminator": [218, 240, 1, 38, 34, 166, 40, 25],
+            "accounts": [
+                {
+                    "name": "signer",
+                    "writable": true,
+                    "signer": true
+                },
+                {
+                    "name": "customer",
+                    "writable": true,
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const",
+                                "value": [99, 117, 115, 116, 111, 109, 101, 114]
+                            },
+                            {
+                                "kind": "arg",
+                                "path": "args.id"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "name": "system_program",
+                    "address": "11111111111111111111111111111111"
+                }
+            ],
+            "args": [
+                {
+                    "name": "args",
+                    "type": {
+                        "defined": {
+                            "name": "UpdateCustomerFeeArgs"
+                        }
+                    }
+                }
+            ]
+        },
         {
             "name": "update_market_end",
             "discriminator": [10, 188, 22, 219, 206, 83, 67, 31],
@@ -4713,6 +4754,22 @@
                 ]
             }
         },
+        {
+            "name": "UpdateCustomerFeeArgs",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "id",
+                        "type": "u16"
+                    },
+                    {
+                        "name": "fee_bps",
+                        "type": "u16"
+                    }
+                ]
+            }
+        },
         {
             "name": "UserTrade",
             "type": {

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/types/triad_protocol.d.ts

@@ -3599,6 +3599,47 @@ export type TriadProtocol = {
                 }
             ];
         },
+        {
+            name: 'updateCustomerFee';
+            discriminator: [218, 240, 1, 38, 34, 166, 40, 25];
+            accounts: [
+                {
+                    name: 'signer';
+                    writable: true;
+                    signer: true;
+                },
+                {
+                    name: 'customer';
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const';
+                                value: [99, 117, 115, 116, 111, 109, 101, 114];
+                            },
+                            {
+                                kind: 'arg';
+                                path: 'args.id';
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: 'systemProgram';
+                    address: '11111111111111111111111111111111';
+                }
+            ];
+            args: [
+                {
+                    name: 'args';
+                    type: {
+                        defined: {
+                            name: 'updateCustomerFeeArgs';
+                        };
+                    };
+                }
+            ];
+        },
         {
             name: 'updateMarketEnd';
             discriminator: [10, 188, 22, 219, 206, 83, 67, 31];
@@ -5758,6 +5799,22 @@ export type TriadProtocol = {
                 ];
             };
         },
+        {
+            name: 'updateCustomerFeeArgs';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'id';
+                        type: 'u16';
+                    },
+                    {
+                        name: 'feeBps';
+                        type: 'u16';
+                    }
+                ];
+            };
+        },
         {
             name: 'userTrade';
             type: {

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.4-beta",
+  "version": "3.1.6-beta",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",