flash-sdk 2.0.34 → 2.0.36

package/dist/PerpetualsClient.d.ts

@@ -12,6 +12,7 @@ import { SendTransactionOpts } from "./utils/rpc";
 import { MarketConfig, PoolConfig, Token } from "./PoolConfig";
 import { max } from "bn.js";
 import { MarketAccount } from "./MarketAccount";
+import { FbnftRewards } from "./idl/fbnft_rewards";
 export type PerpClientOptions = {
     postSendTxCallback?: ({ txid }: {
         txid: string;
@@ -23,6 +24,7 @@ export declare class PerpetualsClient {
     provider: AnchorProvider;
     program: Program<Perpetuals>;
     programPerpComposability: Program<PerpComposability>;
+    programFbnftReward: Program<FbnftRewards>;
     admin: PublicKey;
     programId: PublicKey;
     composabilityProgramId: PublicKey;
@@ -46,7 +48,7 @@ export declare class PerpetualsClient {
     private postSendTxCallback?;
     private prioritizationFee;
     private txConfirmationCommitment;
-    constructor(provider: AnchorProvider, programId: PublicKey, composabilityProgramId: PublicKey, opts: PerpClientOptions);
+    constructor(provider: AnchorProvider, programId: PublicKey, composabilityProgramId: PublicKey, fbNftRewardProgramId: PublicKey, opts: PerpClientOptions);
     setPrioritizationFee: (fee: number) => void;
     loadAddressLookupTable: (poolConfig: PoolConfig) => Promise<void>;
     findProgramAddress: (label: string, extraSeeds?: any) => {
@@ -2141,6 +2143,7 @@ export declare class PerpetualsClient {
     removeCustody: (poolName: string, tokenMint: PublicKey, ratios: TokenRatios[]) => Promise<void>;
     getLiquidationState: (positionAccount: PublicKey, poolName: string, tokenMint: PublicKey, collateralMint: PublicKey, poolConfig: PoolConfig) => Promise<any>;
     liquidate: (positionAccount: PublicKey, poolConfig: PoolConfig, tokenMint: PublicKey, collateralMint: PublicKey, marketPk: PublicKey) => Promise<TransactionInstruction>;
+    getApyPercentageUi: (rewardCustodyAccount: CustodyAccount, previousSnapShotRewardPerLpStaked: BN, lpTokenUsdPrice: BN) => string;
     getAddLiquidityAmountAndFeeSync: (amountIn: BN, poolAccount: PoolAccount, inputTokenPrice: OraclePrice, inputTokenEmaPrice: OraclePrice, inputTokenCustodyAccount: CustodyAccount, lpTokenSupplyAmount: BN, poolAumUsdMax: BN, poolConfig: PoolConfig) => AddLiquidityAmountAndFee;
     getRemoveLiquidityAmountAndFeeSync: (lpAmountIn: BN, poolAccount: PoolAccount, outputTokenPrice: OraclePrice, outputTokenEmaPrice: OraclePrice, outputTokenCustodyAccount: CustodyAccount, lpTokenSupply: BN, poolAumUsdMax: BN, poolConfig: PoolConfig) => RemoveLiquidityAmountAndFee;
     private getNewRatioHelper;
@@ -2289,6 +2292,18 @@ export declare class PerpetualsClient {
         instructions: TransactionInstruction[];
         additionalSigners: Signer[];
     }>;
+    initRewardVault: (nftCount: BN, rewardSymbol: string, collectionMint: PublicKey, poolConfig: PoolConfig) => Promise<{
+        instructions: TransactionInstruction[];
+        additionalSigners: Signer[];
+    }>;
+    distributeReward: (rewardAmount: BN, rewardSymbol: string, poolConfig: PoolConfig) => Promise<{
+        instructions: TransactionInstruction[];
+        additionalSigners: Signer[];
+    }>;
+    collectNftReward: (rewardSymbol: string, poolConfig: PoolConfig, nftMint: PublicKey) => Promise<{
+        instructions: TransactionInstruction[];
+        additionalSigners: Signer[];
+    }>;
     setPoolConfig: (permissions: Permissions, oracleAuthority: PublicKey, maxAumUsd: BN, stakingFeeShareBps: BN, poolConfig: PoolConfig) => Promise<{
         instructions: TransactionInstruction[];
         additionalSigners: Signer[];

package/dist/PerpetualsClient.js

@@ -70,13 +70,14 @@ var types_1 = require("./types");
 var OraclePrice_1 = require("./OraclePrice");
 var perpetuals_1 = require("./idl/perpetuals");
 var perp_composability_1 = require("./idl/perp_composability");
+var fbnft_rewards_1 = require("./idl/fbnft_rewards");
 var rpc_1 = require("./utils/rpc");
 var utils_1 = require("./utils");
 var constants_1 = require("./constants");
 var bignumber_js_1 = __importDefault(require("bignumber.js"));
 var getNftAccounts_1 = require("./utils/getNftAccounts");
 var PerpetualsClient = (function () {
-    function PerpetualsClient(provider, programId, composabilityProgramId, opts) {
+    function PerpetualsClient(provider, programId, composabilityProgramId, fbNftRewardProgramId, opts) {
         var _this = this;
         var _a;
         this.addressLookupTables = [];
@@ -567,6 +568,13 @@ var PerpetualsClient = (function () {
                 }
             });
         }); };
+        this.getApyPercentageUi = function (rewardCustodyAccount, previousSnapShotRewardPerLpStaked, lpTokenUsdPrice) {
+            var currentRewardPerLpStaked = rewardCustodyAccount.feesStats.rewardPerLpStaked;
+            var difference = currentRewardPerLpStaked.sub(previousSnapShotRewardPerLpStaked);
+            var anualizedRewardUi = new bignumber_js_1.default(difference.toString()).multipliedBy(365).dividedBy(lpTokenUsdPrice.toString());
+            var percentage = anualizedRewardUi.multipliedBy(100);
+            return percentage.toString();
+        };
         this.getAddLiquidityAmountAndFeeSync = function (amountIn, poolAccount, inputTokenPrice, inputTokenEmaPrice, inputTokenCustodyAccount, lpTokenSupplyAmount, poolAumUsdMax, poolConfig) {
             if (inputTokenCustodyAccount.isVirtual) {
                 throw new Error("Virtual custody, cannot add liquidity");
@@ -3275,9 +3283,7 @@ var PerpetualsClient = (function () {
                         for (_i = 0, flpStakeAccounts_1 = flpStakeAccounts; _i < flpStakeAccounts_1.length; _i++) {
                             flpStakeAccount = flpStakeAccounts_1[_i];
                             account = flpStakeAccount.account;
-                            if (account.stakeStats.pendingActivation.gt(constants_1.BN_ZERO)) {
-                                pendingActivationAccounts.push(flpStakeAccount.publicKey);
-                            }
+                            pendingActivationAccounts.push(flpStakeAccount.publicKey);
                         }
                         refreshStakeInstructions = [];
                         console.log("total no of pendingActivationAccounts: ", pendingActivationAccounts.length);
@@ -3530,7 +3536,7 @@ var PerpetualsClient = (function () {
                             tradingAccount.push({
                                 pubkey: nftTradingAccount,
                                 isSigner: false,
-                                isWritable: false,
+                                isWritable: true,
                             });
                         }
                         return [4, this.program.methods
@@ -3567,8 +3573,155 @@ var PerpetualsClient = (function () {
                 }
             });
         }); };
+        this.initRewardVault = function (nftCount, rewardSymbol, collectionMint, poolConfig) { return __awaiter(_this, void 0, void 0, function () {
+            var publicKey, rewardCustodyMint, instructions, additionalSigners, fbNftProgramData, rewardVault, rewardTokenAccount, nftTransferAuthority, initRewardVault, err_16;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        publicKey = this.provider.wallet.publicKey;
+                        rewardCustodyMint = poolConfig.getTokenFromSymbol(rewardSymbol).mintKey;
+                        instructions = [];
+                        additionalSigners = [];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        fbNftProgramData = web3_js_1.PublicKey.findProgramAddressSync([this.programFbnftReward.programId.toBuffer()], new web3_js_1.PublicKey("BPFLoaderUpgradeab1e11111111111111111111111"))[0];
+                        rewardVault = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("reward_vault")], this.programFbnftReward.programId)[0];
+                        rewardTokenAccount = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("reward_token_account")], this.programFbnftReward.programId)[0];
+                        nftTransferAuthority = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("transfer_authority")], this.programFbnftReward.programId)[0];
+                        return [4, this.programFbnftReward.methods
+                                .initRewardVault({
+                                nftCount: nftCount
+                            })
+                                .accounts({
+                                admin: publicKey,
+                                transferAuthority: nftTransferAuthority,
+                                rewardVault: rewardVault,
+                                rewardMint: rewardCustodyMint,
+                                rewardTokenAccount: rewardTokenAccount,
+                                collectionMint: collectionMint,
+                                programData: fbNftProgramData,
+                                systemProgram: web3_js_1.SystemProgram.programId,
+                                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                                rent: web3_js_1.SYSVAR_RENT_PUBKEY
+                            })
+                                .instruction()];
+                    case 2:
+                        initRewardVault = _a.sent();
+                        instructions.push(initRewardVault);
+                        return [3, 4];
+                    case 3:
+                        err_16 = _a.sent();
+                        console.log("perpClient InitRewardVault error:: ", err_16);
+                        throw err_16;
+                    case 4: return [2, {
+                            instructions: __spreadArray([], instructions, true),
+                            additionalSigners: additionalSigners
+                        }];
+                }
+            });
+        }); };
+        this.distributeReward = function (rewardAmount, rewardSymbol, poolConfig) { return __awaiter(_this, void 0, void 0, function () {
+            var publicKey, rewardCustodyMint, instructions, additionalSigners, fundingAccount, rewardVault, rewardTokenAccount, distributeReward, err_17;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        publicKey = this.provider.wallet.publicKey;
+                        rewardCustodyMint = poolConfig.getTokenFromSymbol(rewardSymbol).mintKey;
+                        instructions = [];
+                        additionalSigners = [];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 4, , 5]);
+                        return [4, (0, spl_token_1.getAssociatedTokenAddress)(rewardCustodyMint, publicKey)];
+                    case 2:
+                        fundingAccount = _a.sent();
+                        rewardVault = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("reward_vault")], this.programFbnftReward.programId)[0];
+                        rewardTokenAccount = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("reward_token_account")], this.programFbnftReward.programId)[0];
+                        return [4, this.programFbnftReward.methods
+                                .distributeRewards({
+                                rewardAmount: rewardAmount
+                            })
+                                .accounts({
+                                admin: publicKey,
+                                fundingAccount: fundingAccount,
+                                rewardVault: rewardVault,
+                                rewardTokenAccount: rewardTokenAccount,
+                                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                            })
+                                .instruction()];
+                    case 3:
+                        distributeReward = _a.sent();
+                        instructions.push(distributeReward);
+                        return [3, 5];
+                    case 4:
+                        err_17 = _a.sent();
+                        console.log("perpClient distributeReward error:: ", err_17);
+                        throw err_17;
+                    case 5: return [2, {
+                            instructions: __spreadArray([], instructions, true),
+                            additionalSigners: additionalSigners
+                        }];
+                }
+            });
+        }); };
+        this.collectNftReward = function (rewardSymbol, poolConfig, nftMint) { return __awaiter(_this, void 0, void 0, function () {
+            var publicKey, rewardCustodyMint, instructions, additionalSigners, nftTokenAccount, metadataAccount, receivingTokenAccount, rewardRecord, rewardVault, rewardTokenAccount, nftTransferAuthority, collectNftReward, err_18;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        publicKey = this.provider.wallet.publicKey;
+                        rewardCustodyMint = poolConfig.getTokenFromSymbol(rewardSymbol).mintKey;
+                        instructions = [];
+                        additionalSigners = [];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 5, , 6]);
+                        return [4, (0, spl_token_1.getAssociatedTokenAddress)(nftMint, publicKey)];
+                    case 2:
+                        nftTokenAccount = _a.sent();
+                        metadataAccount = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("metadata"), constants_1.METAPLEX_PROGRAM_ID.toBuffer(), nftMint.toBuffer()], constants_1.METAPLEX_PROGRAM_ID)[0];
+                        return [4, (0, spl_token_1.getAssociatedTokenAddress)(rewardCustodyMint, publicKey)];
+                    case 3:
+                        receivingTokenAccount = _a.sent();
+                        rewardRecord = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("reward_record"), nftMint.toBuffer()], this.programFbnftReward.programId)[0];
+                        rewardVault = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("reward_vault")], this.programFbnftReward.programId)[0];
+                        rewardTokenAccount = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("reward_token_account")], this.programFbnftReward.programId)[0];
+                        nftTransferAuthority = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("transfer_authority")], this.programFbnftReward.programId)[0];
+                        32 - 8 - 24 / 3;
+                        return [4, this.programFbnftReward.methods
+                                .collectReward()
+                                .accounts({
+                                owner: publicKey,
+                                feePayer: publicKey,
+                                nftMint: nftMint,
+                                nftTokenAccount: nftTokenAccount,
+                                metadataAccount: metadataAccount,
+                                receivingAccount: receivingTokenAccount,
+                                rewardRecord: rewardRecord,
+                                rewardVault: rewardVault,
+                                rewardTokenAccount: rewardTokenAccount,
+                                transferAuthority: nftTransferAuthority,
+                                systemProgram: web3_js_1.SystemProgram.programId,
+                                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                            })
+                                .instruction()];
+                    case 4:
+                        collectNftReward = _a.sent();
+                        instructions.push(collectNftReward);
+                        return [3, 6];
+                    case 5:
+                        err_18 = _a.sent();
+                        throw err_18;
+                    case 6: return [2, {
+                            instructions: __spreadArray([], instructions, true),
+                            additionalSigners: additionalSigners
+                        }];
+                }
+            });
+        }); };
         this.setPoolConfig = function (permissions, oracleAuthority, maxAumUsd, stakingFeeShareBps, poolConfig) { return __awaiter(_this, void 0, void 0, function () {
-            var publicKey, preInstructions, instructions, postInstructions, additionalSigners, setPoolConfigInstruction, err_16;
+            var publicKey, preInstructions, instructions, postInstructions, additionalSigners, setPoolConfigInstruction, err_19;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -3598,9 +3751,9 @@ var PerpetualsClient = (function () {
                         instructions.push(setPoolConfigInstruction);
                         return [3, 4];
                     case 3:
-                        err_16 = _a.sent();
-                        console.log("perpClient setPool error:: ", err_16);
-                        throw err_16;
+                        err_19 = _a.sent();
+                        console.log("perpClient setPool error:: ", err_19);
+                        throw err_19;
                     case 4: return [2, {
                             instructions: __spreadArray(__spreadArray(__spreadArray([], preInstructions, true), instructions, true), postInstructions, true),
                             additionalSigners: additionalSigners
@@ -3609,7 +3762,7 @@ var PerpetualsClient = (function () {
             });
         }); };
         this.setPermissions = function (permissions) { return __awaiter(_this, void 0, void 0, function () {
-            var publicKey, preInstructions, instructions, postInstructions, additionalSigners, setPermissionsInstruction, err_17;
+            var publicKey, preInstructions, instructions, postInstructions, additionalSigners, setPermissionsInstruction, err_20;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -3636,9 +3789,9 @@ var PerpetualsClient = (function () {
                         instructions.push(setPermissionsInstruction);
                         return [3, 4];
                     case 3:
-                        err_17 = _a.sent();
-                        console.log("perpClient setPool error:: ", err_17);
-                        throw err_17;
+                        err_20 = _a.sent();
+                        console.log("perpClient setPool error:: ", err_20);
+                        throw err_20;
                     case 4: return [2, {
                             instructions: __spreadArray(__spreadArray(__spreadArray([], preInstructions, true), instructions, true), postInstructions, true),
                             additionalSigners: additionalSigners
@@ -3650,6 +3803,7 @@ var PerpetualsClient = (function () {
         (0, anchor_1.setProvider)(provider);
         this.program = new anchor_1.Program(perpetuals_1.IDL, programId);
         this.programPerpComposability = new anchor_1.Program(perp_composability_1.IDL, composabilityProgramId);
+        this.programFbnftReward = new anchor_1.Program(fbnft_rewards_1.IDL, fbNftRewardProgramId);
         this.programId = programId;
         this.composabilityProgramId = composabilityProgramId;
         this.admin = this.provider.wallet.publicKey;

package/dist/PoolConfig.d.ts

@@ -39,6 +39,7 @@ export type Token = {
 export declare class PoolConfig {
     programId: PublicKey;
     perpComposibilityProgramId: PublicKey;
+    fbNftRewardProgramId: PublicKey;
     cluster: Cluster;
     poolName: string;
     poolAddress: PublicKey;
@@ -55,7 +56,7 @@ export declare class PoolConfig {
     tokens: Token[];
     custodies: CustodyConfig[];
     markets: MarketConfig[];
-    constructor(programId: PublicKey, perpComposibilityProgramId: PublicKey, cluster: Cluster, poolName: string, poolAddress: PublicKey, lpTokenMint: PublicKey, flpTokenAccount: PublicKey, lpDecimals: number, lpTokenSymbol: string, perpetuals: PublicKey, transferAuthority: PublicKey, multisig: PublicKey, addressLookupTableAddresses: PublicKey[], backupOracle: PublicKey, nftCollectionAddress: PublicKey, tokens: Token[], custodies: CustodyConfig[], markets: MarketConfig[]);
+    constructor(programId: PublicKey, perpComposibilityProgramId: PublicKey, fbNftRewardProgramId: PublicKey, cluster: Cluster, poolName: string, poolAddress: PublicKey, lpTokenMint: PublicKey, flpTokenAccount: PublicKey, lpDecimals: number, lpTokenSymbol: string, perpetuals: PublicKey, transferAuthority: PublicKey, multisig: PublicKey, addressLookupTableAddresses: PublicKey[], backupOracle: PublicKey, nftCollectionAddress: PublicKey, tokens: Token[], custodies: CustodyConfig[], markets: MarketConfig[]);
     getAllTokenMints(): PublicKey[];
     getMarketConfigByPk(marketAccountPk: PublicKey): MarketConfig;
     getMarketConfig(targetCustody: PublicKey, collateralCustody: PublicKey, side: Side): MarketConfig | null;

package/dist/PoolConfig.js

@@ -19,10 +19,11 @@ var web3_js_1 = require("@solana/web3.js");
 var PoolConfig_json_1 = __importDefault(require("./PoolConfig.json"));
 var types_1 = require("./types");
 var PoolConfig = (function () {
-    function PoolConfig(programId, perpComposibilityProgramId, cluster, poolName, poolAddress, lpTokenMint, flpTokenAccount, lpDecimals, lpTokenSymbol, perpetuals, transferAuthority, multisig, addressLookupTableAddresses, backupOracle, nftCollectionAddress, tokens, custodies, markets) {
+    function PoolConfig(programId, perpComposibilityProgramId, fbNftRewardProgramId, cluster, poolName, poolAddress, lpTokenMint, flpTokenAccount, lpDecimals, lpTokenSymbol, perpetuals, transferAuthority, multisig, addressLookupTableAddresses, backupOracle, nftCollectionAddress, tokens, custodies, markets) {
         var _this = this;
         this.programId = programId;
         this.perpComposibilityProgramId = perpComposibilityProgramId;
+        this.fbNftRewardProgramId = fbNftRewardProgramId;
         this.cluster = cluster;
         this.poolName = poolName;
         this.poolAddress = poolAddress;
@@ -161,7 +162,7 @@ var PoolConfig = (function () {
         catch (error) {
             console.log("ERROR: buildPoolconfigFromJson  unable to load markets ");
         }
-        return new PoolConfig(new web3_js_1.PublicKey(poolConfig.programId), new web3_js_1.PublicKey(poolConfig.perpComposibilityProgramId), poolConfig.cluster, poolConfig.poolName, new web3_js_1.PublicKey(poolConfig.poolAddress), new web3_js_1.PublicKey(poolConfig.lpTokenMint), new web3_js_1.PublicKey(poolConfig.flpTokenAccount), poolConfig.lpDecimals, poolConfig.lpTokenSymbol, new web3_js_1.PublicKey(poolConfig.perpetuals), new web3_js_1.PublicKey(poolConfig.transferAuthority), new web3_js_1.PublicKey(poolConfig.multisig), addressLookupTableAddresses, new web3_js_1.PublicKey(poolConfig.backupOracle), new web3_js_1.PublicKey(poolConfig.nftCollectionAddress), tokens, custodies, markets);
+        return new PoolConfig(new web3_js_1.PublicKey(poolConfig.programId), new web3_js_1.PublicKey(poolConfig.perpComposibilityProgramId), new web3_js_1.PublicKey(poolConfig.fbNftRewardProgramId), poolConfig.cluster, poolConfig.poolName, new web3_js_1.PublicKey(poolConfig.poolAddress), new web3_js_1.PublicKey(poolConfig.lpTokenMint), new web3_js_1.PublicKey(poolConfig.flpTokenAccount), poolConfig.lpDecimals, poolConfig.lpTokenSymbol, new web3_js_1.PublicKey(poolConfig.perpetuals), new web3_js_1.PublicKey(poolConfig.transferAuthority), new web3_js_1.PublicKey(poolConfig.multisig), addressLookupTableAddresses, new web3_js_1.PublicKey(poolConfig.backupOracle), new web3_js_1.PublicKey(poolConfig.nftCollectionAddress), tokens, custodies, markets);
     };
     PoolConfig.fromIdsByName = function (name, cluster) {
         var poolConfig = PoolConfig_json_1.default.pools.find(function (pool) { return pool['poolName'] === name && cluster === pool['cluster']; });

package/dist/PoolConfig.json

@@ -9,6 +9,7 @@
         {
             "programId": "FLASH6Lo6h3iasJKWDs2F8TkW2UKf3s15C8PMGuVfgBn",
             "perpComposibilityProgramId": "FSWAPViR8ny5K96hezav8jynVubP2dJ2L7SbKzds2hwm",
+            "fbNftRewardProgramId": "FB8mxzFuW99ExD1B14hFqoeWWS1UdbuK6iY2PVPpKFQi",
             "cluster": "mainnet-beta",
             "poolName": "Crypto.1",
             "poolAddress": "HfF7GCcEc76xubFCHLLXRdYcgRzwjEPdfKWqzRS8Ncog",
@@ -204,6 +205,7 @@
         {
             "programId": "FLASH6Lo6h3iasJKWDs2F8TkW2UKf3s15C8PMGuVfgBn",
             "perpComposibilityProgramId": "FSWAPViR8ny5K96hezav8jynVubP2dJ2L7SbKzds2hwm",
+            "fbNftRewardProgramId": "FB8mxzFuW99ExD1B14hFqoeWWS1UdbuK6iY2PVPpKFQi",
             "cluster": "mainnet-beta",
             "poolName": "Virtual.1",
             "poolAddress": "KwhpybQPe9xuZFmAfcjLHj3ukownWex1ratyascAC1X",
@@ -482,6 +484,7 @@
         {
             "programId": "FTN6rgbaaxwT8mpRuC55EFTwpHB3BwnHJ91Lqv4ZVCfW",
             "perpComposibilityProgramId": "SWAP4AE4N1if9qKD7dgfQgmRBRv1CtWG8xDs4HP14ST",
+            "fbNftRewardProgramId": "FB8mxzFuW99ExD1B14hFqoeWWS1UdbuK6iY2PVPpKFQi",
             "cluster": "devnet",
             "poolName": "devnet.1",
             "poolAddress": "7jA4ZSGwaBxXk5EmPKDCSc5RtZNHxyoxy22iQt3D2mH9",
@@ -677,6 +680,7 @@
         {
             "programId": "FTN6rgbaaxwT8mpRuC55EFTwpHB3BwnHJ91Lqv4ZVCfW",
             "perpComposibilityProgramId": "SWAP4AE4N1if9qKD7dgfQgmRBRv1CtWG8xDs4HP14ST",
+            "fbNftRewardProgramId": "FB8mxzFuW99ExD1B14hFqoeWWS1UdbuK6iY2PVPpKFQi",
             "cluster": "devnet",
             "poolName": "devnet.2",
             "poolAddress": "5MCtcNsF3dxna8ArzMamyciWDV3TBkiAzY1NqLtNiXvw",

package/dist/idl/fbnft_rewards.d.ts

@@ -0,0 +1,285 @@
+export type FbnftRewards = {
+    "version": "0.1.0";
+    "name": "fbnft_rewards";
+    "instructions": [
+        {
+            "name": "initRewardVault";
+            "accounts": [
+                {
+                    "name": "admin";
+                    "isMut": true;
+                    "isSigner": true;
+                },
+                {
+                    "name": "transferAuthority";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "rewardVault";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "rewardMint";
+                    "isMut": false;
+                    "isSigner": false;
+                },
+                {
+                    "name": "rewardTokenAccount";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "collectionMint";
+                    "isMut": false;
+                    "isSigner": false;
+                },
+                {
+                    "name": "programData";
+                    "isMut": false;
+                    "isSigner": false;
+                },
+                {
+                    "name": "systemProgram";
+                    "isMut": false;
+                    "isSigner": false;
+                },
+                {
+                    "name": "tokenProgram";
+                    "isMut": false;
+                    "isSigner": false;
+                },
+                {
+                    "name": "rent";
+                    "isMut": false;
+                    "isSigner": false;
+                }
+            ];
+            "args": [
+                {
+                    "name": "params";
+                    "type": {
+                        "defined": "InitRewardVaultParams";
+                    };
+                }
+            ];
+        },
+        {
+            "name": "distributeRewards";
+            "accounts": [
+                {
+                    "name": "admin";
+                    "isMut": false;
+                    "isSigner": true;
+                },
+                {
+                    "name": "fundingAccount";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "rewardVault";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "rewardTokenAccount";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "tokenProgram";
+                    "isMut": false;
+                    "isSigner": false;
+                }
+            ];
+            "args": [
+                {
+                    "name": "params";
+                    "type": {
+                        "defined": "DistributeRewardsParams";
+                    };
+                }
+            ];
+        },
+        {
+            "name": "collectReward";
+            "accounts": [
+                {
+                    "name": "owner";
+                    "isMut": true;
+                    "isSigner": true;
+                },
+                {
+                    "name": "feePayer";
+                    "isMut": true;
+                    "isSigner": true;
+                },
+                {
+                    "name": "nftMint";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "nftTokenAccount";
+                    "isMut": false;
+                    "isSigner": false;
+                },
+                {
+                    "name": "metadataAccount";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "receivingAccount";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "rewardRecord";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "rewardVault";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "rewardTokenAccount";
+                    "isMut": true;
+                    "isSigner": false;
+                },
+                {
+                    "name": "transferAuthority";
+                    "isMut": false;
+                    "isSigner": false;
+                },
+                {
+                    "name": "systemProgram";
+                    "isMut": false;
+                    "isSigner": false;
+                },
+                {
+                    "name": "tokenProgram";
+                    "isMut": false;
+                    "isSigner": false;
+                }
+            ];
+            "args": [];
+        }
+    ];
+    "accounts": [
+        {
+            "name": "rewardVault";
+            "type": {
+                "kind": "struct";
+                "fields": [
+                    {
+                        "name": "admin";
+                        "type": "publicKey";
+                    },
+                    {
+                        "name": "collection";
+                        "type": "publicKey";
+                    },
+                    {
+                        "name": "rewardMint";
+                        "type": "publicKey";
+                    },
+                    {
+                        "name": "transferAuthority";
+                        "type": "publicKey";
+                    },
+                    {
+                        "name": "rewardTokenAccount";
+                        "type": "publicKey";
+                    },
+                    {
+                        "name": "lpTokenAccount";
+                        "type": "publicKey";
+                    },
+                    {
+                        "name": "nftCount";
+                        "type": "u64";
+                    },
+                    {
+                        "name": "accruedAmount";
+                        "type": "u128";
+                    },
+                    {
+                        "name": "paidAmount";
+                        "type": "u128";
+                    },
+                    {
+                        "name": "rewardsPerNft";
+                        "type": "u64";
+                    },
+                    {
+                        "name": "bump";
+                        "type": "u8";
+                    },
+                    {
+                        "name": "transferAuthorityBump";
+                        "type": "u8";
+                    },
+                    {
+                        "name": "tokenAccountBump";
+                        "type": "u8";
+                    }
+                ];
+            };
+        },
+        {
+            "name": "rewardRecord";
+            "type": {
+                "kind": "struct";
+                "fields": [
+                    {
+                        "name": "mint";
+                        "type": "publicKey";
+                    },
+                    {
+                        "name": "rewardDebt";
+                        "type": "u64";
+                    }
+                ];
+            };
+        }
+    ];
+    "types": [
+        {
+            "name": "InitRewardVaultParams";
+            "type": {
+                "kind": "struct";
+                "fields": [
+                    {
+                        "name": "nftCount";
+                        "type": "u64";
+                    }
+                ];
+            };
+        },
+        {
+            "name": "DistributeRewardsParams";
+            "type": {
+                "kind": "struct";
+                "fields": [
+                    {
+                        "name": "rewardAmount";
+                        "type": "u64";
+                    }
+                ];
+            };
+        }
+    ];
+    "errors": [
+        {
+            "code": 6000;
+            "name": "InvalidCollection";
+            "msg": "Unsuppported NFT collection";
+        }
+    ];
+};
+export declare const IDL: FbnftRewards;