@triadxyz/triad-protocol 4.2.0 → 4.2.2

package/dist/market.js

@@ -0,0 +1,571 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const spl_token_1 = require("@solana/spl-token");
+const bn_js_1 = __importDefault(require("bn.js"));
+const bs58_1 = __importDefault(require("bs58"));
+const helpers_1 = require("./utils/helpers");
+const types_1 = require("./types");
+const helpers_2 = require("./utils/helpers");
+const pda_1 = require("./utils/pda");
+const sendVersionedTransaction_1 = __importDefault(require("./utils/sendVersionedTransaction"));
+class Market {
+    constructor(program, rpcOptions) {
+        this.program = program;
+        this.rpcOptions = rpcOptions;
+    }
+    /**
+     * Get Orders By Market ID
+     * @param marketId - The ID of the market
+     */
+    getOrdersByMarketId(marketId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketIdBytes = new bn_js_1.default(marketId).toArray('le', 8);
+            const orders = yield this.program.account.predictorOrder.all([
+                {
+                    memcmp: {
+                        offset: 8 + 32,
+                        bytes: bs58_1.default.encode(marketIdBytes)
+                    }
+                }
+            ]);
+            return orders.map(({ account, publicKey }) => (0, helpers_1.formatPredictorOrder)(account, publicKey));
+        });
+    }
+    /**
+     * Get All Pools
+     */
+    getAllPools() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pool = yield this.program.account.pool.all();
+            return pool.map(({ account, publicKey }) => (0, helpers_1.formatPool)(account, publicKey));
+        });
+    }
+    /**
+     * Get All Markets
+     */
+    getAllMarkets() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketV2 = yield this.program.account.marketV2.all();
+            return marketV2.map(({ account, publicKey }) => (0, helpers_1.formatMarket)(account, publicKey));
+        });
+    }
+    /**
+     * Get Pool By ID
+     * @param poolId - The ID of the pool
+     */
+    getPoolById(poolId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolPDA = (0, pda_1.getPoolPDA)(this.program.programId, poolId);
+            const response = yield this.program.account.pool.fetch(poolPDA, this.rpcOptions.commitment);
+            return (0, helpers_1.formatPool)(response, poolPDA);
+        });
+    }
+    /**
+     * Get Market By ID
+     * @param marketId - The ID of the market
+     */
+    getMarketById(marketId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketPDA = (0, pda_1.getMarketPDA)(this.program.programId, marketId);
+            const response = yield this.program.account.marketV2.fetch(marketPDA, this.rpcOptions.commitment);
+            return (0, helpers_1.formatMarket)(response, marketPDA);
+        });
+    }
+    /**
+     * Get Market By Address
+     * @param marketAddress - The address of the market
+     */
+    getMarketByAddress(marketAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const account = yield this.program.account.marketV2.fetch(marketAddress, this.rpcOptions.commitment);
+            return (0, helpers_1.formatMarket)(account, marketAddress);
+        });
+    }
+    /**
+     * Get Current Market ID
+     */
+    nextMarketId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let validId = null;
+            while (!validId) {
+                const marketId = Math.floor(Math.random() * 1000000000000000);
+                try {
+                    yield this.program.account.marketV2.fetch((0, pda_1.getMarketPDA)(this.program.programId, marketId));
+                }
+                catch (_a) {
+                    validId = marketId;
+                }
+            }
+            return validId;
+        });
+    }
+    /**
+     * Get Next Pool ID
+     */
+    nextPoolId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pools = yield this.program.account.pool.all();
+            return pools.length + 1;
+        });
+    }
+    /**
+     * Create Market
+     * @param args.markets - Array of markets to create
+     * @param args.markets.marketId - Market ID
+     * @param args.markets.startTime - start time
+     * @param args.markets.endTime - end time
+     * @param args.markets.question - question (max 80 characters)
+     * @param args.markets.liquidityAtStart - liquidity at start
+     * @param args.markets.payoutFee - payout fee (to add affiliate system)
+     * @param args.customer - The customer of the market
+     * @param args.poolId - The ID of the pool
+     */
+    createMarket({ markets, customer, poolId }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            let poolPDA = null;
+            if (poolId) {
+                poolPDA = (0, pda_1.getPoolPDA)(this.program.programId, poolId);
+            }
+            for (const market of markets) {
+                if (market.question.length > 80) {
+                    throw new Error('Question must be less than 80 characters');
+                }
+                ixs.push(yield this.program.methods
+                    .createMarket({
+                    marketId: new bn_js_1.default(market.marketId),
+                    question: (0, helpers_1.encodeString)(market.question, 80),
+                    marketStart: new bn_js_1.default(market.startTime),
+                    marketEnd: new bn_js_1.default(market.endTime),
+                    feeBps: market.feeBps,
+                    payoutFee: market.payoutFee,
+                    preMarketEndTs: new bn_js_1.default(0),
+                    preOrdersAvailable: new bn_js_1.default(0)
+                })
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    pool: poolPDA,
+                    customer
+                })
+                    .instruction());
+                ixs.push(yield this.program.methods
+                    .createOrderBook(new bn_js_1.default(market.marketId))
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, market.marketId)
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Create Pool
+     * @param poolId - The ID of the pool
+     * @param question - The question of the pool
+     * @param markets - The markets of the pool
+     * @param customer - The customer of the pool
+     * @param startTime - The start time of the pool
+     * @param endTime - The end time of the pool
+     * @param feeBps - The fee in basis points of the pool
+     * @param payoutFee - The payout fee of the pool
+     * @param isFast - Whether the pool is fast
+     * @param isPyth - Whether the pool is pyth
+     * @param feedId - The feed ID of the pool
+     */
+    createPool({ poolId, question, markets, customer, startTime, endTime, feeBps, payoutFee, isFast, isPyth, feedId }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (question.length > 80) {
+                throw new Error('Pool question must be less than 80 characters');
+            }
+            const ixs = [];
+            let feedPDA = null;
+            if (isPyth) {
+                feedPDA = (0, helpers_2.getPriceFeedAccountForProgram)(feedId);
+            }
+            const poolPDA = (0, pda_1.getPoolPDA)(this.program.programId, poolId);
+            ixs.push(yield this.program.methods
+                .createPool({
+                poolId: new bn_js_1.default(poolId),
+                question: (0, helpers_1.encodeString)(question, 80),
+                isFast,
+                isPyth
+            })
+                .accounts({
+                signer: this.program.provider.publicKey,
+                priceUpdate: feedPDA,
+                customer,
+                feed: (0, helpers_1.getFeedIdFromHex)(feedId)
+            })
+                .instruction());
+            for (const market of markets) {
+                if (market.question.length > 80) {
+                    throw new Error('Market question must be less than 80 characters');
+                }
+                ixs.push(yield this.program.methods
+                    .createMarket({
+                    marketId: new bn_js_1.default(market.marketId),
+                    question: (0, helpers_1.encodeString)(market.question, 80),
+                    marketStart: new bn_js_1.default(startTime),
+                    marketEnd: new bn_js_1.default(endTime),
+                    feeBps,
+                    payoutFee,
+                    preMarketEndTs: new bn_js_1.default(0),
+                    preOrdersAvailable: new bn_js_1.default(0)
+                })
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    pool: poolPDA,
+                    customer
+                })
+                    .instruction());
+                ixs.push(yield this.program.methods
+                    .createOrderBook(new bn_js_1.default(market.marketId))
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, market.marketId)
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Update Market Winning Direction
+     * @param args.marketId - The ID of the Market
+     * @param args.winningDirection - The Winning Direction of the Market
+     * @param args.poolId - The ID of the Pool
+     * @param args.withPayout - Whether to allow the market to payout
+     */
+    updateMarketWinningDirection({ markets }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            for (const market of markets) {
+                ixs.push(yield this.program.methods
+                    .updateMarketWinningDirection(market.winningDirection)
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, market.marketId),
+                    pool: market.poolId
+                        ? (0, pda_1.getPoolPDA)(this.program.programId, market.poolId)
+                        : null
+                })
+                    .instruction());
+                if (market.withPayout) {
+                    ixs.push(yield this.program.methods
+                        .updateMarketPayout(true)
+                        .accounts({
+                        signer: this.program.provider.publicKey,
+                        market: (0, pda_1.getMarketPDA)(this.program.programId, market.marketId)
+                    })
+                        .instruction());
+                }
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Update Market Payout
+     * @param args.marketId - The ID of the market
+     * @param args.allowPayout - Whether to allow the market to payout
+     */
+    updateMarketPayout({ marketId, allowPayout }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [
+                yield this.program.methods
+                    .updateMarketPayout(allowPayout)
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, marketId)
+                })
+                    .instruction()
+            ];
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Update Market End
+     * @param args.marketId - The ID of the market
+     * @param args.marketEnd - The end time of the market
+     */
+    updateMarketEnd({ marketId, marketEnd }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [
+                yield this.program.methods
+                    .updateMarketEnd(new bn_js_1.default(marketEnd))
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, marketId)
+                })
+                    .instruction()
+            ];
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Update Market Question
+     * @param args.marketId - The ID of the market
+     * @param args.question - The question of the market
+     */
+    updateMarketQuestion({ marketId, question }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [
+                yield this.program.methods
+                    .updateMarketQuestion((0, helpers_1.encodeString)(question, 80))
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, marketId)
+                })
+                    .instruction()
+            ];
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Close Order Book
+     * @param markets.id - Market IDs
+     * @param markets.authority - The authority of the market
+     */
+    closeOrderBook(markets) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            for (const market of markets) {
+                ixs.push(yield this.program.methods
+                    .closeOrderBook()
+                    .accounts({
+                    authority: market.authority,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, market.id),
+                    orderBook: (0, pda_1.getOrderBookPDA)(this.program.programId, market.id)
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Close IDLE Market
+     * @param markets.id - Market ID
+     * @param markets.authority - Market authority
+     * @param markets.mint - Market mint
+     */
+    closeIdleMarket(markets) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            for (const market of markets) {
+                ixs.push(yield this.program.methods
+                    .closeIdleMarket(new bn_js_1.default(market.id))
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    mint: market.mint,
+                    tokenProgram: (0, helpers_1.getTokenProgram)(market.mint)
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Update Pool Question
+     * @param poolId - Pool ID
+     * @param question - Question
+     */
+    updatePoolQuestion(poolId, question) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [
+                yield this.program.methods
+                    .updatePoolQuestion((0, helpers_1.encodeString)(question, 80))
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    pool: (0, pda_1.getPoolPDA)(this.program.programId, poolId)
+                })
+                    .instruction()
+            ];
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Create Market Pyth
+     * @param args.markets - Array of markets to create
+     * @param args.markets.marketId - Market ID
+     * @param args.markets.resolveIn - Time to add for resolver the market in seconds
+     * @param args.customer - The customer of the market
+     * @param args.poolId - The ID of the pool
+     */
+    createMarketPyth({ markets }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            for (const market of markets) {
+                let poolPDA = (0, pda_1.getPoolPDA)(this.program.programId, market.poolId);
+                const feedPDA = (0, helpers_2.getPriceFeedAccountForProgram)(market.feedId);
+                ixs.push(yield this.program.methods
+                    .createMarketPyth({
+                    marketId: new bn_js_1.default(market.marketId),
+                    resolveIn: new bn_js_1.default(market.resolveIn),
+                    direction: market.direction
+                })
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                    pool: poolPDA,
+                    customer: market.customer,
+                    priceUpdate: feedPDA
+                })
+                    .instruction());
+                ixs.push(yield this.program.methods
+                    .createOrderBook(new bn_js_1.default(market.marketId))
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, market.marketId)
+                })
+                    .instruction());
+            }
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Create and Resolve Pyth Market
+     * @param toResolve - Market to resolve
+     * @param toResolve.marketId - Market ID
+     * @param toResolve.winningDirection - Winning direction
+     * @param toResolve.poolId - Pool ID
+     * @param toResolve.withPayout - Whether to update market payout
+     * @param market - Market to create
+     * @param market.marketId - Market ID
+     * @param market.resolveIn - Time to add for resolver the market in seconds
+     * @param market.direction - Direction of the market
+     * @param market.customer - The customer of the market
+     * @param market.poolId - The ID of the pool
+     */
+    createAndResolvePythMarket(toResolve, market) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            const marketInfo = yield this.getMarketById(toResolve.marketId);
+            if (marketInfo.winningDirection === types_1.WinningDirection.NONE) {
+                ixs.push(yield this.program.methods
+                    .updateMarketWinningDirection(toResolve.winningDirection)
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    pool: toResolve.poolId
+                        ? (0, pda_1.getPoolPDA)(this.program.programId, toResolve.poolId)
+                        : null,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, toResolve.marketId)
+                })
+                    .instruction());
+                if (toResolve.withPayout) {
+                    ixs.push(yield this.program.methods
+                        .updateMarketPayout(true)
+                        .accounts({
+                        signer: this.program.provider.publicKey,
+                        market: (0, pda_1.getMarketPDA)(this.program.programId, toResolve.marketId)
+                    })
+                        .instruction());
+                }
+            }
+            const feedPDA = (0, helpers_2.getPriceFeedAccountForProgram)(market.feedId);
+            ixs.push(yield this.program.methods
+                .createMarketPyth({
+                marketId: new bn_js_1.default(market.marketId),
+                resolveIn: new bn_js_1.default(market.resolveIn),
+                direction: market.direction
+            })
+                .accounts({
+                signer: this.program.provider.publicKey,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                pool: market.poolId
+                    ? (0, pda_1.getPoolPDA)(this.program.programId, market.poolId)
+                    : null,
+                customer: market.customer,
+                priceUpdate: feedPDA
+            })
+                .instruction());
+            ixs.push(yield this.program.methods
+                .createOrderBook(new bn_js_1.default(market.marketId))
+                .accounts({
+                signer: this.program.provider.publicKey,
+                market: (0, pda_1.getMarketPDA)(this.program.programId, market.marketId)
+            })
+                .instruction());
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+    /**
+     * Create and Resolve Market
+     * @param toResolve - Market to resolve
+     * @param toResolve.marketId - Market ID
+     * @param toResolve.winningDirection - Winning direction
+     * @param toResolve.withPayout - Whether to update market payout
+     * @param market - Market to create
+     * @param market.marketId - Market ID
+     * @param market.resolveIn - Time to add for resolver the market in seconds
+     * @param market.direction - Direction of the market
+     * @param market.customer - The customer of the market
+     * @param market.poolId - The ID of the pool
+     */
+    createAndResolveMarket(toResolve, market, customer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ixs = [];
+            const marketInfo = yield this.getMarketById(toResolve.marketId);
+            if (marketInfo.winningDirection === types_1.WinningDirection.NONE) {
+                ixs.push(yield this.program.methods
+                    .updateMarketWinningDirection(toResolve.winningDirection)
+                    .accounts({
+                    signer: this.program.provider.publicKey,
+                    pool: toResolve.poolId
+                        ? (0, pda_1.getPoolPDA)(this.program.programId, toResolve.poolId)
+                        : null,
+                    market: (0, pda_1.getMarketPDA)(this.program.programId, toResolve.marketId)
+                })
+                    .instruction());
+                if (toResolve.withPayout) {
+                    ixs.push(yield this.program.methods
+                        .updateMarketPayout(true)
+                        .accounts({
+                        signer: this.program.provider.publicKey,
+                        market: (0, pda_1.getMarketPDA)(this.program.programId, toResolve.marketId)
+                    })
+                        .instruction());
+                }
+            }
+            ixs.push(yield this.program.methods
+                .createMarket({
+                marketId: new bn_js_1.default(market.marketId),
+                question: (0, helpers_1.encodeString)(market.question, 80),
+                marketStart: new bn_js_1.default(market.startTime),
+                marketEnd: new bn_js_1.default(market.endTime),
+                feeBps: market.feeBps,
+                payoutFee: market.payoutFee,
+                preMarketEndTs: new bn_js_1.default(0),
+                preOrdersAvailable: new bn_js_1.default(0)
+            })
+                .accounts({
+                signer: this.program.provider.publicKey,
+                pool: toResolve.poolId
+                    ? (0, pda_1.getPoolPDA)(this.program.programId, toResolve.poolId)
+                    : null,
+                customer
+            })
+                .instruction());
+            ixs.push(yield this.program.methods
+                .createOrderBook(new bn_js_1.default(market.marketId))
+                .accounts({
+                signer: this.program.provider.publicKey,
+                market: (0, pda_1.getMarketPDA)(this.program.programId, market.marketId)
+            })
+                .instruction());
+            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+        });
+    }
+}
+exports.default = Market;

package/dist/poseidon.d.ts

@@ -19,14 +19,12 @@ export default class Poseidon {
     collectRoyalty(collectionSymbol: string): Promise<string | import("@solana/web3.js").VersionedTransaction>;
     /**
      * Add Trader Poseidon
-     * @param user - User Public Key
      * @param poseidonAsset - Poseidon Asset
      */
-    addTraderPoseidon(user: PublicKey, poseidonAsset: PublicKey): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    addTraderPoseidon(poseidonAsset: PublicKey): Promise<string | import("@solana/web3.js").VersionedTransaction>;
     /**
      * Remove Trader Poseidon
-     * @param user - User Public Key
      * @param poseidonAsset - Poseidon Asset
      */
-    removeTraderPoseidon(user: PublicKey, poseidonAsset: PublicKey): Promise<string | import("@solana/web3.js").VersionedTransaction>;
+    removeTraderPoseidon(poseidonAsset: PublicKey): Promise<string | import("@solana/web3.js").VersionedTransaction>;
 }

package/dist/poseidon.js

@@ -27,7 +27,7 @@ class Poseidon {
      */
     withdrawPoseidon(poseidonAsset, nft) {
         return __awaiter(this, void 0, void 0, function* () {
-            const ixs = [
+            return (0, sendVersionedTransaction_1.default)(this.program, [
                 yield this.program.methods
                     .withdrawPoseidon()
                     .accounts({
@@ -38,8 +38,7 @@ class Poseidon {
                     corePoseidonCollection: constants_1.POSEIDON_CORE_COLLECTION
                 })
                     .instruction()
-            ];
-            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+            ], this.rpcOptions);
         });
     }
     /**
@@ -48,7 +47,7 @@ class Poseidon {
      */
     collectRoyalty(collectionSymbol) {
         return __awaiter(this, void 0, void 0, function* () {
-            const ixs = [
+            return (0, sendVersionedTransaction_1.default)(this.program, [
                 yield this.program.methods
                     .collectRoyalty()
                     .accounts({
@@ -56,18 +55,16 @@ class Poseidon {
                     collection: (0, pda_1.getCollectionPDA)(this.program.programId, collectionSymbol)
                 })
                     .instruction()
-            ];
-            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+            ], this.rpcOptions);
         });
     }
     /**
      * Add Trader Poseidon
-     * @param user - User Public Key
      * @param poseidonAsset - Poseidon Asset
      */
-    addTraderPoseidon(user, poseidonAsset) {
+    addTraderPoseidon(poseidonAsset) {
         return __awaiter(this, void 0, void 0, function* () {
-            const ixs = [
+            return (0, sendVersionedTransaction_1.default)(this.program, [
                 yield this.program.methods
                     .addTraderPoseidon()
                     .accounts({
@@ -76,18 +73,16 @@ class Poseidon {
                     poseidonCollection: (0, pda_1.getCollectionPDA)(this.program.programId, constants_1.POSEIDON_COLLECTION_SYMBOL)
                 })
                     .instruction()
-            ];
-            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+            ], this.rpcOptions);
         });
     }
     /**
      * Remove Trader Poseidon
-     * @param user - User Public Key
      * @param poseidonAsset - Poseidon Asset
      */
-    removeTraderPoseidon(user, poseidonAsset) {
+    removeTraderPoseidon(poseidonAsset) {
         return __awaiter(this, void 0, void 0, function* () {
-            const ixs = [
+            return (0, sendVersionedTransaction_1.default)(this.program, [
                 yield this.program.methods
                     .removeTraderPoseidon()
                     .accounts({
@@ -96,8 +91,7 @@ class Poseidon {
                     poseidonCollection: (0, pda_1.getCollectionPDA)(this.program.programId, constants_1.POSEIDON_COLLECTION_SYMBOL)
                 })
                     .instruction()
-            ];
-            return (0, sendVersionedTransaction_1.default)(this.program, ixs, this.rpcOptions);
+            ], this.rpcOptions);
         });
     }
 }