@frakters/nft-lending-v2/lib/index.d.ts

Client library for interacting with nft lenging solana program

/// <reference types="bn.js" />
/// <reference types="node" />
import * as anchor from '@project-serum/anchor';
export { AllAccounts, CollectionInfoView, TimeBasedLiquidityPoolView, DepositView, LoanView, PriceBasedLiquidityPoolView, LiquidationLotView, LotTicketView, NftAttemptView, LendingStakeView, } from './accounts';
import { GemFarm } from './idl/types/idl-gem-farm';
export * as onAccountsChange from './accountsChanged/onAccountsChanged';
import { CollectionInfoView, TimeBasedLiquidityPoolView, DepositView, LoanView, PriceBasedLiquidityPoolView, LiquidationLotView, LotTicketView, NftAttemptView, LendingStakeView } from './accounts';
import { PublicKey, Connection, Keypair, Transaction } from '@solana/web3.js';
import * as accounts from './accounts';
export { returnAnchorProgram } from './utils';
export * as utils from './utils';
export * as accounts from './accounts';
export declare const METADATA_PROGRAM_PUBKEY: anchor.web3.PublicKey;
export declare function approveLoanByAdmin({ programId, connection, admin, loan, liquidityPool, collectionInfo, nftPrice, discount, user, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    admin: PublicKey;
    loan: PublicKey;
    liquidityPool: PublicKey;
    collectionInfo: PublicKey;
    nftPrice: number | anchor.BN;
    discount: number | anchor.BN;
    user: PublicKey;
    sendTxn: (transaction: Transaction) => Promise<void>;
}): Promise<void>;
export declare function depositLiquidity({ programId, connection, liquidityPool, user, amount, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    liquidityPool: PublicKey;
    user: PublicKey;
    amount: number;
    sendTxn: (transaction: Transaction) => Promise<void>;
}): Promise<PublicKey>;
export declare function unstakeLiquidity({ programId, connection, liquidityPool, user, amount, admin, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    liquidityPool: PublicKey;
    user: PublicKey;
    amount: anchor.BN | number;
    admin: PublicKey;
    sendTxn: (transaction: Transaction) => Promise<void>;
}): Promise<void>;
export declare function harvestLiquidity({ programId, connection, liquidityPool, user, admin, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    liquidityPool: PublicKey;
    user: PublicKey;
    admin: PublicKey;
    sendTxn: (transaction: Transaction) => Promise<void>;
}): Promise<void>;
export declare function updateCollectionInfo({ programId, connection, liquidityPool, admin, creatorAddress, pricingLookupAddress, loanToValue, collaterizationRate, royaltyAddress, collectionInfo, royaltyFeeTime, royaltyFeePrice, expirationTime, isPriceBased, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    liquidityPool: PublicKey;
    admin: PublicKey;
    creatorAddress: PublicKey;
    collectionInfo: PublicKey;
    pricingLookupAddress: PublicKey;
    loanToValue: number | anchor.BN;
    collaterizationRate: number | anchor.BN;
    royaltyAddress: PublicKey;
    royaltyFeeTime: number | anchor.BN;
    royaltyFeePrice: number | anchor.BN;
    expirationTime: number | anchor.BN;
    isPriceBased: boolean;
    sendTxn: (transaction: Transaction) => Promise<void>;
}): Promise<void>;
export declare function initializeCollectionInfo({ programId, connection, liquidityPool, admin, creatorAddress, pricingLookupAddress, loanToValue, collaterizationRate, royaltyAddress, royaltyFeeTime, royaltyFeePrice, expirationTime, isPriceBased, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    liquidityPool: PublicKey;
    admin: PublicKey;
    creatorAddress: PublicKey;
    pricingLookupAddress: PublicKey;
    loanToValue: number | anchor.BN;
    collaterizationRate: number | anchor.BN;
    royaltyAddress: PublicKey;
    royaltyFeeTime: number | anchor.BN;
    royaltyFeePrice: number | anchor.BN;
    expirationTime: number | anchor.BN;
    isPriceBased: boolean;
    sendTxn: (transaction: Transaction, signers: Keypair[]) => Promise<void>;
}): Promise<anchor.web3.PublicKey>;
export declare function updateTimeBasedLiquidityPool({ programId, connection, admin, liquidityPool, rewardInterestRateTime, rewardInterestRatePrice, feeInterestRateTime, feeInterestRatePrice, id, period, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    admin: PublicKey;
    liquidityPool: PublicKey;
    rewardInterestRateTime: number | anchor.BN;
    feeInterestRateTime: number | anchor.BN;
    rewardInterestRatePrice: number | anchor.BN;
    feeInterestRatePrice: number | anchor.BN;
    id: number | anchor.BN;
    period: number | anchor.BN;
    sendTxn: (transaction: Transaction) => Promise<void>;
}): Promise<void>;
export declare function initializePriceBasedLiquidityPool({ programId, connection, admin, baseBorrowRate, variableSlope1, variableSlope2, utilizationRateOptimal, reserveFactor, depositCommission, borrowCommission, id, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    admin: PublicKey;
    baseBorrowRate: number;
    variableSlope1: number;
    variableSlope2: number;
    utilizationRateOptimal: number;
    reserveFactor: number;
    depositCommission: number;
    borrowCommission: number;
    id: number;
    sendTxn: (transaction: Transaction, signers: Keypair[]) => Promise<void>;
}): Promise<anchor.web3.PublicKey>;
export declare function updatePriceBasedLiquidityPool({ programId, liquidityPool, connection, admin, baseBorrowRate, variableSlope1, variableSlope2, utilizationRateOptimal, reserveFactor, depositCommission, borrowCommission, id, sendTxn, }: {
    programId: PublicKey;
    liquidityPool: PublicKey;
    connection: Connection;
    admin: PublicKey;
    baseBorrowRate: number;
    variableSlope1: number;
    variableSlope2: number;
    utilizationRateOptimal: number;
    reserveFactor: number;
    depositCommission: number;
    borrowCommission: number;
    id: number;
    sendTxn: (transaction: Transaction) => Promise<void>;
}): Promise<void>;
export declare function paybackLoan({ programId, connection, user, admin, loan, nftMint, liquidityPool, collectionInfo, royaltyAddress, amount, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    user: PublicKey;
    admin: PublicKey;
    loan: PublicKey;
    nftMint: PublicKey;
    liquidityPool: PublicKey;
    collectionInfo: PublicKey;
    royaltyAddress: PublicKey;
    amount: anchor.BN;
    sendTxn: (transaction: Transaction) => Promise<void>;
}): Promise<void>;
export declare function proposeLoan({ proposedNftPrice, programId, connection, user, nftMint, isPriceBased, loanToValue, admin, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    user: PublicKey;
    nftMint: PublicKey;
    proposedNftPrice: anchor.BN;
    isPriceBased: boolean;
    loanToValue: anchor.BN;
    admin: PublicKey;
    sendTxn: (transaction: Transaction, signers: Keypair[]) => Promise<void>;
}): Promise<{
    loanPubkey: anchor.web3.PublicKey;
}>;
export declare function rejectLoanByAdmin({ programId, connection, loan, nftUserTokenAccount, admin, user, nftMint, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    loan: PublicKey;
    nftUserTokenAccount: PublicKey;
    admin: PublicKey;
    user: PublicKey;
    nftMint: PublicKey;
    sendTxn: (transaction: Transaction) => Promise<void>;
}): Promise<void>;
export declare function withdrawFromReserveFund({ programId, connection, priceBasedLiquidityPool, admin, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    priceBasedLiquidityPool: PublicKey;
    admin: PublicKey;
    sendTxn: (transaction: Transaction) => Promise<void>;
}): Promise<void>;
export declare function initializeNftAttempts({ programId, connection, attemptsNftMint, user, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    attemptsNftMint: PublicKey;
    user: PublicKey;
    sendTxn: (transaction: Transaction) => Promise<void>;
}): Promise<anchor.web3.PublicKey>;
export declare function liquidateNftToRaffles({ programId, connection, user, liquidator, gracePeriod, loan, nftMint, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    user: PublicKey;
    liquidator: PublicKey;
    gracePeriod: number;
    loan: PublicKey;
    nftMint: PublicKey;
    sendTxn: (transaction: Transaction, signers: Keypair[]) => Promise<void>;
}): Promise<anchor.web3.PublicKey>;
export declare function paybackLoanWithGrace({ programId, connection, user, admin, liquidationLot, loan, nftMint, liquidityPool, collectionInfo, royaltyAddress, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    user: PublicKey;
    admin: PublicKey;
    liquidationLot: PublicKey;
    loan: PublicKey;
    nftMint: PublicKey;
    liquidityPool: PublicKey;
    collectionInfo: PublicKey;
    royaltyAddress: PublicKey;
    sendTxn: (transaction: Transaction) => Promise<void>;
}): Promise<void>;
export declare function redeemWinningLotTicket({ programId, connection, user, liquidationLot, liquidityPool, collectionInfo, loan, admin, lotTicket, royaltyAddress, nftMint, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    user: PublicKey;
    admin: PublicKey;
    liquidityPool: PublicKey;
    royaltyAddress: PublicKey;
    lotTicket: PublicKey;
    collectionInfo: PublicKey;
    liquidationLot: PublicKey;
    loan: PublicKey;
    nftMint: PublicKey;
    sendTxn: (transaction: Transaction) => Promise<void>;
}): Promise<void>;
export declare function rejectLotTicketByAdmin({ programId, connection, admin, lotTicket, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    admin: PublicKey;
    lotTicket: PublicKey;
    sendTxn: (transaction: Transaction) => Promise<void>;
}): Promise<void>;
export declare function revealLotTicketByAdmin({ programId, connection, admin, lotTicket, isWinning, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    admin: PublicKey;
    lotTicket: PublicKey;
    isWinning: boolean;
    sendTxn: (transaction: Transaction) => Promise<void>;
}): Promise<void>;
export declare function getAllProgramAccounts(programId: PublicKey, connection: Connection): Promise<{
    collectionInfos: CollectionInfoView[];
    deposits: DepositView[];
    timeBasedLiquidityPools: TimeBasedLiquidityPoolView[];
    priceBasedLiquidityPools: PriceBasedLiquidityPoolView[];
    loans: LoanView[];
    liquidationLots: LiquidationLotView[];
    lotTickets: LotTicketView[];
    nftAttempts: NftAttemptView[];
    lendingStakes: LendingStakeView[];
}>;
export declare function stakeGemFarmStaking({ programId, connection, user, gemFarm, farm, bank, gemBank, feeAcc, nftMint, loan, isDegod, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    user: PublicKey;
    gemFarm: PublicKey;
    farm: PublicKey;
    bank: PublicKey;
    gemBank: PublicKey;
    feeAcc: PublicKey;
    nftMint: PublicKey;
    isDegod: boolean;
    loan: PublicKey;
    sendTxn: (transaction: Transaction) => Promise<void>;
}): Promise<void>;
export declare function unstakeGemFarmStaking({ programId, connection, user, gemFarm, farm, bank, gemBank, feeAcc, nftMint, isDegod, loan, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    user: PublicKey;
    gemFarm: PublicKey;
    farm: PublicKey;
    bank: PublicKey;
    gemBank: PublicKey;
    feeAcc: PublicKey;
    nftMint: PublicKey;
    isDegod: boolean;
    loan: PublicKey;
    sendTxn: (transaction: Transaction) => Promise<void>;
}): Promise<void>;
export declare function unstakeGemFarmStakingByAdmin({ programId, connection, admin, gemFarm, farm, bank, gemBank, feeAcc, nftMint, isDegod, loan, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    admin: PublicKey;
    gemFarm: PublicKey;
    farm: PublicKey;
    bank: PublicKey;
    gemBank: PublicKey;
    feeAcc: PublicKey;
    nftMint: PublicKey;
    isDegod: boolean;
    loan: PublicKey;
    sendTxn: (transaction: Transaction) => Promise<void>;
}): Promise<void>;
export declare function claimGemFarmStaking({ programId, connection, user, gemFarm, farm, nftMint, loan, isDegod, rewardAMint, rewardBMint, sendTxn, }: {
    programId: PublicKey;
    connection: Connection;
    user: PublicKey;
    gemFarm: PublicKey;
    farm: PublicKey;
    nftMint: PublicKey;
    loan: PublicKey;
    isDegod: boolean;
    rewardAMint: PublicKey;
    rewardBMint: PublicKey;
    sendTxn: (transaction: Transaction) => Promise<void>;
}): Promise<void>;
export declare function getSpecificAccountInfo({ degodPubkey, connection, identity, }: {
    degodPubkey: any;
    connection: any;
    identity: any;
}): Promise<anchor.ProgramAccount<import("@project-serum/anchor/dist/cjs/program/namespace/types").TypeDef<{
    name: "authorizationProof";
    type: {
        kind: "struct";
        fields: [{
            name: "authorizedFunder";
            type: "publicKey";
        }, {
            name: "farm";
            type: "publicKey";
        }];
    };
} | {
    name: "farm";
    type: {
        kind: "struct";
        fields: [{
            name: "version";
            type: "u16";
        }, {
            name: "farmManager";
            type: "publicKey";
        }, {
            name: "farmTreasury";
            type: "publicKey";
        }, {
            name: "farmAuthority";
            type: "publicKey";
        }, {
            name: "farmAuthoritySeed";
            type: "publicKey";
        }, {
            name: "farmAuthorityBumpSeed";
            type: {
                array: ["u8", 1];
            };
        }, {
            name: "bank";
            type: "publicKey";
        }, {
            name: "config";
            type: {
                defined: "FarmConfig";
            };
        }, {
            name: "farmerCount";
            type: "u64";
        }, {
            name: "stakedFarmerCount";
            type: "u64";
        }, {
            name: "gemsStaked";
            type: "u64";
        }, {
            name: "rarityPointsStaked";
            type: "u64";
        }, {
            name: "authorizedFunderCount";
            type: "u64";
        }, {
            name: "rewardA";
            type: {
                defined: "FarmReward";
            };
        }, {
            name: "rewardB";
            type: {
                defined: "FarmReward";
            };
        }];
    };
} | {
    name: "farmer";
    type: {
        kind: "struct";
        fields: [{
            name: "farm";
            type: "publicKey";
        }, {
            name: "identity";
            type: "publicKey";
        }, {
            name: "vault";
            type: "publicKey";
        }, {
            name: "state";
            type: {
                defined: "FarmerState";
            };
        }, {
            name: "gemsStaked";
            type: "u64";
        }, {
            name: "minStakingEndsTs";
            type: "u64";
        }, {
            name: "cooldownEndsTs";
            type: "u64";
        }, {
            name: "rewardA";
            type: {
                defined: "FarmerReward";
            };
        }, {
            name: "rewardB";
            type: {
                defined: "FarmerReward";
            };
        }];
    };
}, anchor.IdlTypes<GemFarm>>> | undefined>;
export declare function objectBNsToNums(obj: any): any;
export declare function decodeLoan(buffer: Buffer, connection: Connection, programId: PublicKey): any;
export declare function CalculateStatFromAccounts(allAccounts: accounts.AllAccounts): {
    lockedNftsInLoans: number;
    loansVolumeAllTime: number;
    loansVolume7Days: number;
    TVL: number;
    issuedIn24Hours: number;
    liquidatedIn24Hours: number;
    paidBackIn24Hours: number;
    totalIssued: number;
};
export declare function objectBNsAndPubkeysToNums(obj: any): any;
export * as anchor from '@project-serum/anchor';