Class SolanaAgentKit

constructor

• new SolanaAgentKit(
      private_key: string,
      rpc_url: string,
      openai_api_key: null | string,
  ): SolanaAgentKit

• Parameters

  • private_key: string
  • rpc_url: string
  • openai_api_key: null | string

  Returns SolanaAgentKit

  Deprecated

  Using openai_api_key directly in constructor is deprecated. Please use the new constructor with Config object instead:

  Example

  const agent = new SolanaAgentKit(privateKey, rpcUrl, {
    OPENAI_API_KEY: 'your-key'
  });
  Copy

• new SolanaAgentKit(
      private_key: string,
      rpc_url: string,
      config: Config,
  ): SolanaAgentKit

• Parameters

  • private_key: string
  • rpc_url: string
  • config: Config

  Returns SolanaAgentKit

config

connection

wallet

wallet_address

approveMultisigProposal

• approveMultisigProposal(transactionIndex?: number | bigint): Promise<string>

• Parameters

  • OptionaltransactionIndex: number | bigint

  Returns Promise<string>

batchOrder

• batchOrder(marketId: PublicKey, orders: OrderParams[]): Promise<string>

• Parameters

  • marketId: PublicKey
  • orders: OrderParams[]

  Returns Promise<string>

burnTokens

• burnTokens(mints: string[]): Promise<string[]>

• Parameters

  • mints: string[]

  Returns Promise<string[]>

cancelAllOrders

• cancelAllOrders(marketId: PublicKey): Promise<string>

• Parameters

  • marketId: PublicKey

  Returns Promise<string>

checkDebridgeTransactionStatus

• checkDebridgeTransactionStatus(
      txHashOrOrderId: string,
  ): Promise<deBridgeOrderStatusResponse[]>

• Parameters

  • txHashOrOrderId: string

  Returns Promise<deBridgeOrderStatusResponse[]>

closeAccounts

• closeAccounts(mints: string[]): Promise<string[]>

• Parameters

  • mints: string[]

  Returns Promise<string[]>

closeEmptyTokenAccounts

• closeEmptyTokenAccounts(): Promise<{ signature: string; size: number }>

• Returns Promise<{ signature: string; size: number }>

closePerpTradeLong

• closePerpTradeLong(
      args: Omit<
          { agent: SolanaAgentKit; price: number; tradeMint: PublicKey },
          "agent",
      >,
  ): Promise<string>

• Parameters

  • args: Omit<{ agent: SolanaAgentKit; price: number; tradeMint: PublicKey }, "agent">

  Returns Promise<string>

closePerpTradeShort

• closePerpTradeShort(
      args: Omit<
          { agent: SolanaAgentKit; price: number; tradeMint: PublicKey },
          "agent",
      >,
  ): Promise<string>

• Parameters

  • args: Omit<{ agent: SolanaAgentKit; price: number; tradeMint: PublicKey }, "agent">

  Returns Promise<string>

create3LandCollection

• create3LandCollection(
      collectionOpts: CreateCollectionOptions,
      isDevnet?: boolean,
      priorityFeeParam?: number,
  ): Promise<string>

• Parameters

  • collectionOpts: CreateCollectionOptions
  • isDevnet: boolean = false
  • OptionalpriorityFeeParam: number

  Returns Promise<string>

create3LandNft

• create3LandNft(
      collectionAccount: string,
      createItemOptions: CreateSingleOptions,
      isDevnet?: boolean,
      withPool?: boolean,
      priorityFeeParam?: number,
  ): Promise<string>

• Parameters

  • collectionAccount: string
  • createItemOptions: CreateSingleOptions
  • isDevnet: boolean = false
  • withPool: boolean = false
  • OptionalpriorityFeeParam: number

  Returns Promise<string>

createDebridgeOrder

• createDebridgeOrder(
      orderInput: deBridgeOrderInput,
  ): Promise<deBridgeOrderResponse>

• Parameters

  • orderInput: deBridgeOrderInput

  Returns Promise<deBridgeOrderResponse>

createDriftUserAccount

• createDriftUserAccount(
      depositAmount: number,
      depositSymbol: string,
  ): Promise<
      | { account: PublicKey; message?: undefined; txSignature: string }
      | { account: PublicKey; message: string; txSignature?: undefined },
  >

• Parameters

  • depositAmount: number
  • depositSymbol: string

  Returns Promise<
      | { account: PublicKey; message?: undefined; txSignature: string }
      | { account: PublicKey; message: string; txSignature?: undefined },
  >

createDriftVault

• createDriftVault(
      params: {
          hurdleRate?: number;
          managementFee: number;
          marketName: `${string}-${string}`;
          maxTokens: number;
          minDepositAmount: number;
          name: string;
          permissioned?: boolean;
          profitShare: number;
          redeemPeriod: number;
      },
  ): Promise<string>

• Parameters

  • params: {
        hurdleRate?: number;
        managementFee: number;
        marketName: `${string}-${string}`;
        maxTokens: number;
        minDepositAmount: number;
        name: string;
        permissioned?: boolean;
        profitShare: number;
        redeemPeriod: number;
    }

  Returns Promise<string>

createGibworkTask

• createGibworkTask(
      title: string,
      content: string,
      requirements: string,
      tags: string[],
      tokenMintAddress: string,
      tokenAmount: number,
      payer?: string,
  ): Promise<GibworkCreateTaskReponse>

• Parameters

  • title: string
  • content: string
  • requirements: string
  • tags: string[]
  • tokenMintAddress: string
  • tokenAmount: number
  • Optionalpayer: string

  Returns Promise<GibworkCreateTaskReponse>

createMultisigProposal

• createMultisigProposal(transactionIndex?: number | bigint): Promise<string>

• Parameters

  • OptionaltransactionIndex: number | bigint

  Returns Promise<string>

createSquadsMultisig

• createSquadsMultisig(creator: PublicKey): Promise<string>

• Parameters

  • creator: PublicKey

  Returns Promise<string>

createTiplink

• createTiplink(
      amount: number,
      splmintAddress?: PublicKey,
  ): Promise<{ signature: string; url: string }>

• Parameters

  • amount: number
  • OptionalsplmintAddress: PublicKey

  Returns Promise<{ signature: string; url: string }>

CreateWebhook

• CreateWebhook(
      accountAddresses: string[],
      webhookURL: string,
  ): Promise<HeliusWebhookResponse>

• Parameters

  • accountAddresses: string[]
  • webhookURL: string

  Returns Promise<HeliusWebhookResponse>

deleteWebhook

• deleteWebhook(webhookID: string): Promise<any>

• Parameters

  • webhookID: string

  Returns Promise<any>

deployCollection

• deployCollection(options: CollectionOptions): Promise<CollectionDeployment>

• Parameters

  • options: CollectionOptions

  Returns Promise<CollectionDeployment>

deployToken

• deployToken(
      name: string,
      uri: string,
      symbol: string,
      decimals?: number,
      initialSupply?: number,
  ): Promise<{ mint: PublicKey }>

• Parameters

  • name: string
  • uri: string
  • symbol: string
  • decimals: number = DEFAULT_OPTIONS.TOKEN_DECIMALS
  • OptionalinitialSupply: number

  Returns Promise<{ mint: PublicKey }>

depositIntoDriftVault

• depositIntoDriftVault(amount: number, vault: string): Promise<string>

• Parameters

  • amount: number
  • vault: string

  Returns Promise<string>

depositToDriftUserAccount

• depositToDriftUserAccount(
      amount: number,
      symbol: string,
      isRepayment?: boolean,
  ): Promise<TxSigAndSlot>

• Parameters

  • amount: number
  • symbol: string
  • OptionalisRepayment: boolean

  Returns Promise<TxSigAndSlot>

depositToMultisig

• depositToMultisig(
      amount: number,
      vaultIndex?: number,
      mint?: PublicKey,
  ): Promise<string>

• Parameters

  • amount: number
  • vaultIndex: number = 0
  • Optionalmint: PublicKey

  Returns Promise<string>

deriveDriftVaultAddress

• deriveDriftVaultAddress(name: string): Promise<PublicKey>

• Parameters

  • name: string

  Returns Promise<PublicKey>

doesUserHaveDriftAccount

• doesUserHaveDriftAccount(): Promise<{ account: PublicKey; hasAccount: boolean }>

• Returns Promise<{ account: PublicKey; hasAccount: boolean }>

driftSpotTokenSwap

• driftSpotTokenSwap(
      params: { fromSymbol: string; slippage?: number; toSymbol: string } & (
          { toAmount: number }
          | { fromAmount: number }
      ),
  ): Promise<string>

• Parameters

  • params: { fromSymbol: string; slippage?: number; toSymbol: string } & (
        { toAmount: number }
        | { fromAmount: number }
    )

  Returns Promise<string>

driftUserAccountInfo

• driftUserAccountInfo(): Promise<
      {
          accountAddress: string;
          authority: PublicKey;
          lastActiveSlot: number;
          name: number[];
          overallBalance: number;
          perpPositions: {
              baseAssetAmount: number;
              market: string;
              openAsks: number;
              openBids: number;
              openOrders: number;
              positionType: string;
              quoteAssetAmount: number;
              quoteBreakEvenAmount: number;
              quoteEntryAmount: number;
              settledPnl: number;
          }[];
          settledPerpPnl: string;
          spotPositions: (
              | undefined
              | {
                  availableBalance: number;
                  openAsks: number;
                  openBids: number;
                  openOrders: number;
                  symbol: string;
                  type: string;
              }
          )[];
      },
  >

• Returns Promise<
      {
          accountAddress: string;
          authority: PublicKey;
          lastActiveSlot: number;
          name: number[];
          overallBalance: number;
          perpPositions: {
              baseAssetAmount: number;
              market: string;
              openAsks: number;
              openBids: number;
              openOrders: number;
              positionType: string;
              quoteAssetAmount: number;
              quoteBreakEvenAmount: number;
              quoteEntryAmount: number;
              settledPnl: number;
          }[];
          settledPerpPnl: string;
          spotPositions: (
              | undefined
              | {
                  availableBalance: number;
                  openAsks: number;
                  openBids: number;
                  openOrders: number;
                  symbol: string;
                  type: string;
              }
          )[];
      },
  >

executeDebridgeOrder

• executeDebridgeOrder(transactionData: string): Promise<string>

• Parameters

  • transactionData: string

  Returns Promise<string>

executeMultisigTransaction

• executeMultisigTransaction(transactionIndex?: number | bigint): Promise<string>

• Parameters

  • OptionaltransactionIndex: number | bigint

  Returns Promise<string>

fetchTokenDetailedReport

• fetchTokenDetailedReport(mint: string): Promise<TokenCheck>

• Parameters

  • mint: string

  Returns Promise<TokenCheck>

fetchTokenPrice

• fetchTokenPrice(mint: string): Promise<string>

• Parameters

  • mint: string

  Returns Promise<string>

fetchTokenReportSummary

• fetchTokenReportSummary(mint: string): Promise<TokenCheck>

• Parameters

  • mint: string

  Returns Promise<TokenCheck>

flashCloseTrade

• flashCloseTrade(params: FlashCloseTradeParams): Promise<string>

• Closes an existing trading position on Flash.Trade

  Parameters

  • params: FlashCloseTradeParams

    Flash trade close parameters

  Returns Promise<string>

  Transaction signature

flashOpenTrade

• flashOpenTrade(params: FlashTradeParams): Promise<string>

• Opens a new trading position on Flash.Trade

  Parameters

  • params: FlashTradeParams

    Flash trade parameters including market, side, collateral, leverage, and pool name

  Returns Promise<string>

  Transaction signature

fluxbeamCreatePool

• fluxbeamCreatePool(
      token_a: PublicKey,
      token_a_amount: number,
      token_b: PublicKey,
      token_b_amount: number,
  ): Promise<string>

• Parameters

  • token_a: PublicKey
  • token_a_amount: number
  • token_b: PublicKey
  • token_b_amount: number

  Returns Promise<string>

getAllAssetsbyOwner

• getAllAssetsbyOwner(owner: PublicKey, limit: number): Promise<any>

• Parameters

  • owner: PublicKey
  • limit: number

  Returns Promise<any>

getAllDomainsTLDs

• getAllDomainsTLDs(): Promise<string[]>

• Returns Promise<string[]>

getAllRegisteredAllDomains

• getAllRegisteredAllDomains(): Promise<string[]>

• Returns Promise<string[]>

getAllTopics

• getAllTopics(): Promise<AlloraTopic[]>

• Returns Promise<AlloraTopic[]>

getAsset

• getAsset(assetId: string): Promise<DasApiAsset>

• Parameters

  • assetId: string

  Returns Promise<DasApiAsset>

getAssetsByAuthority

• getAssetsByAuthority(
      params: GetAssetsByAuthorityRpcInput,
  ): Promise<DasApiAssetList>

• Parameters

  • params: GetAssetsByAuthorityRpcInput

  Returns Promise<DasApiAssetList>

getAssetsByCreator

• getAssetsByCreator(params: GetAssetsByCreatorRpcInput): Promise<DasApiAssetList>

• Parameters

  • params: GetAssetsByCreatorRpcInput

  Returns Promise<DasApiAssetList>

getAvailableDriftMarkets

• getAvailableDriftMarkets(
      type?: "spot" | "perp",
  ):
      | SpotMarketConfig[]
      | PerpMarketConfig[]
      | { perp: PerpMarketConfig[]; spot: SpotMarketConfig[] }

• Parameters

  • Optionaltype: "spot" | "perp"

  Returns
      | SpotMarketConfig[]
      | PerpMarketConfig[]
      | { perp: PerpMarketConfig[]; spot: SpotMarketConfig[] }

getBalance

• getBalance(token_address?: PublicKey): Promise<number>

• Parameters

  • Optionaltoken_address: PublicKey

  Returns Promise<number>

getBalanceOther

• getBalanceOther(
      walletAddress: PublicKey,
      tokenAddress?: PublicKey,
  ): Promise<number>

• Parameters

  • walletAddress: PublicKey
  • OptionaltokenAddress: PublicKey

  Returns Promise<number>

getDebridgeSupportedChains

• getDebridgeSupportedChains(): Promise<deBridgeSupportedChainsResponse>

• Returns Promise<deBridgeSupportedChainsResponse>

getDebridgeTokensInfo

• getDebridgeTokensInfo(
      chainId: string,
      search?: string,
  ): Promise<deBridgeTokensInfoResponse>

• Parameters

  • chainId: string
  • Optionalsearch: string

  Returns Promise<deBridgeTokensInfoResponse>

getDriftVaultInfo

• getDriftVaultInfo(
      vaultName: string,
  ): Promise<
      {
          address: string;
          balance: string;
          delegate: string;
          hurdleRate: number;
          managementFee: number;
          marketName: string;
          maxTokens: number;
          minDepositAmount: number;
          name: string;
          permissioned: boolean;
          profitShare: number;
          redeemPeriod: number;
      },
  >

• Parameters

  • vaultName: string

  Returns Promise<
      {
          address: string;
          balance: string;
          delegate: string;
          hurdleRate: number;
          managementFee: number;
          marketName: string;
          maxTokens: number;
          minDepositAmount: number;
          name: string;
          permissioned: boolean;
          profitShare: number;
          redeemPeriod: number;
      },
  >

getEntryQuoteOfPerpTrade

• getEntryQuoteOfPerpTrade(
      amount: number,
      symbol: `${string}-PERP`,
      action: "long" | "short",
  ): Promise<
      {
          bestPrice: number;
          entryPrice: number;
          priceImpact: number;
          worstPrice: number;
      },
  >

• Parameters

  • amount: number
  • symbol: `${string}-PERP`
  • action: "long" | "short"

  Returns Promise<
      {
          bestPrice: number;
          entryPrice: number;
          priceImpact: number;
          worstPrice: number;
      },
  >

getInferenceByTopicId

• getInferenceByTopicId(topicId: number): Promise<AlloraInference>

• Parameters

  • topicId: number

  Returns Promise<AlloraInference>

getLendAndBorrowAPY

• getLendAndBorrowAPY(
      symbol: string,
  ): Promise<{ borrowAPY: number; lendingAPY: number }>

• Parameters

  • symbol: string

  Returns Promise<{ borrowAPY: number; lendingAPY: number }>

getMainAllDomainsDomain

• getMainAllDomainsDomain(owner: PublicKey): Promise<null | string>

• Parameters

  • owner: PublicKey

  Returns Promise<null | string>

getOwnedAllDomains

• getOwnedAllDomains(owner: PublicKey): Promise<string[]>

• Parameters

  • owner: PublicKey

  Returns Promise<string[]>

getOwnedDomainsForTLD

• getOwnedDomainsForTLD(tld: string): Promise<string[]>

• Parameters

  • tld: string

  Returns Promise<string[]>

getPerpMarketFundingRate

• getPerpMarketFundingRate(
      symbol: `${string}-PERP`,
      period?: "year" | "hour",
  ): Promise<{ friendlyString: string; longRate: number; shortRate: number }>

• Parameters

  • symbol: `${string}-PERP`
  • period: "year" | "hour" = "year"

  Returns Promise<{ friendlyString: string; longRate: number; shortRate: number }>

getPriceInference

• getPriceInference(tokenSymbol: string, timeframe: string): Promise<string>

• Parameters

  • tokenSymbol: string
  • timeframe: string

  Returns Promise<string>

getPrimaryDomain

• getPrimaryDomain(account: PublicKey): Promise<string>

• Parameters

  • account: PublicKey

  Returns Promise<string>

getPythPrice

• getPythPrice(priceFeedID: string): Promise<string>

• Parameters

  • priceFeedID: string

  Returns Promise<string>

getPythPriceFeedID

• getPythPriceFeedID(tokenSymbol: string): Promise<string>

• Parameters

  • tokenSymbol: string

  Returns Promise<string>

getTokenBalances

• getTokenBalances(
      wallet_address?: PublicKey,
  ): Promise<
      {
          sol: number;
          tokens: {
              balance: number;
              decimals: number;
              name: string;
              symbol: string;
              tokenAddress: string;
          }[];
      },
  >

• Parameters

  • Optionalwallet_address: PublicKey

  Returns Promise<
      {
          sol: number;
          tokens: {
              balance: number;
              decimals: number;
              name: string;
              symbol: string;
              tokenAddress: string;
          }[];
      },
  >

getTokenDataByAddress

• getTokenDataByAddress(mint: string): Promise<undefined | JupiterTokenData>

• Parameters

  • mint: string

  Returns Promise<undefined | JupiterTokenData>

getTokenDataByTicker

• getTokenDataByTicker(ticker: string): Promise<undefined | JupiterTokenData>

• Parameters

  • ticker: string

  Returns Promise<undefined | JupiterTokenData>

getTPS

• getTPS(): Promise<number>

• Returns Promise<number>

getWebhook

• getWebhook(id: string): Promise<HeliusWebhookIdResponse>

• Parameters

  • id: string

  Returns Promise<HeliusWebhookIdResponse>

heliusParseTransactions

• heliusParseTransactions(transactionId: string): Promise<any>

• Parameters

  • transactionId: string

  Returns Promise<any>

launchPumpFunToken

• launchPumpFunToken(
      tokenName: string,
      tokenTicker: string,
      description: string,
      imageUrl: string,
      options?: PumpFunTokenOptions,
  ): Promise<PumpfunLaunchResponse>

• Parameters

  • tokenName: string
  • tokenTicker: string
  • description: string
  • imageUrl: string
  • Optionaloptions: PumpFunTokenOptions

  Returns Promise<PumpfunLaunchResponse>

lendAssets

• lendAssets(amount: number): Promise<string>

• Parameters

  • amount: number

  Returns Promise<string>

limitOrder

• limitOrder(
      marketId: PublicKey,
      quantity: number,
      side: string,
      price: number,
  ): Promise<string>

• Parameters

  • marketId: PublicKey
  • quantity: number
  • side: string
  • price: number

  Returns Promise<string>

luloLend

• luloLend(mintAddress: string, amount: number): Promise<string>

• Parameters

  • mintAddress: string
  • amount: number

  Returns Promise<string>

luloWithdraw

• luloWithdraw(mintAddress: string, amount: number): Promise<string>

• Parameters

  • mintAddress: string
  • amount: number

  Returns Promise<string>

manifestCreateMarket

• manifestCreateMarket(
      baseMint: PublicKey,
      quoteMint: PublicKey,
  ): Promise<string[]>

• Parameters

  • baseMint: PublicKey
  • quoteMint: PublicKey

  Returns Promise<string[]>

mergeTokens

• mergeTokens(
      inputAssets: InputAssetStruct[],
      outputMint: string,
      priorityFee: PriorityFee,
  ): Promise<string[]>

• Parameters

  • inputAssets: InputAssetStruct[]
  • outputMint: string
  • priorityFee: PriorityFee

  Returns Promise<string[]>

meteoraCreateDlmmPool

• meteoraCreateDlmmPool(
      tokenAMint: PublicKey,
      tokenBMint: PublicKey,
      binStep: number,
      initialPrice: number,
      priceRoundingUp: boolean,
      feeBps: number,
      activationType: number,
      hasAlphaVault: boolean,
      activationPoint: undefined | BN,
  ): Promise<string>

• Parameters

  • tokenAMint: PublicKey
  • tokenBMint: PublicKey
  • binStep: number
  • initialPrice: number
  • priceRoundingUp: boolean
  • feeBps: number
  • activationType: number
  • hasAlphaVault: boolean
  • activationPoint: undefined | BN

  Returns Promise<string>

meteoraCreateDynamicPool

• meteoraCreateDynamicPool(
      tokenAMint: PublicKey,
      tokenBMint: PublicKey,
      tokenAAmount: BN,
      tokenBAmount: BN,
      tradeFeeNumerator: number,
      activationPoint: null | BN,
      hasAlphaVault: boolean,
      activationType: number,
  ): Promise<string>

• Parameters

  • tokenAMint: PublicKey
  • tokenBMint: PublicKey
  • tokenAAmount: BN
  • tokenBAmount: BN
  • tradeFeeNumerator: number
  • activationPoint: null | BN
  • hasAlphaVault: boolean
  • activationType: number

  Returns Promise<string>

mintNFT

• mintNFT(
      collectionMint: PublicKey,
      metadata: {
          creators?: { address: string; share: number }[];
          name: string;
          sellerFeeBasisPoints?: number;
          uri: string;
      },
      recipient?: PublicKey,
  ): Promise<MintCollectionNFTResponse>

• Parameters

  • collectionMint: PublicKey
  • metadata: {
        creators?: { address: string; share: number }[];
        name: string;
        sellerFeeBasisPoints?: number;
        uri: string;
    }
  • Optionalrecipient: PublicKey

  Returns Promise<MintCollectionNFTResponse>

openbookCreateMarket

• openbookCreateMarket(
      baseMint: PublicKey,
      quoteMint: PublicKey,
      lotSize?: number,
      tickSize?: number,
  ): Promise<string[]>

• Parameters

  • baseMint: PublicKey
  • quoteMint: PublicKey
  • lotSize: number = 1
  • tickSize: number = 0.01

  Returns Promise<string[]>

openPerpTradeLong

• openPerpTradeLong(
      args: Omit<
          {
              agent: SolanaAgentKit;
              collateralAmount: number;
              collateralMint?: PublicKey;
              leverage?: number;
              price: number;
              slippage?: number;
              tradeMint?: PublicKey;
          },
          "agent",
      >,
  ): Promise<string>

• Parameters

  • args: Omit<
        {
            agent: SolanaAgentKit;
            collateralAmount: number;
            collateralMint?: PublicKey;
            leverage?: number;
            price: number;
            slippage?: number;
            tradeMint?: PublicKey;
        },
        "agent",
    >

  Returns Promise<string>

openPerpTradeShort

• openPerpTradeShort(
      args: Omit<
          {
              agent: SolanaAgentKit;
              collateralAmount: number;
              collateralMint?: PublicKey;
              leverage?: number;
              price: number;
              slippage?: number;
              tradeMint?: PublicKey;
          },
          "agent",
      >,
  ): Promise<string>

• Parameters

  • args: Omit<
        {
            agent: SolanaAgentKit;
            collateralAmount: number;
            collateralMint?: PublicKey;
            leverage?: number;
            price: number;
            slippage?: number;
            tradeMint?: PublicKey;
        },
        "agent",
    >

  Returns Promise<string>

orcaClosePosition

• orcaClosePosition(positionMintAddress: PublicKey): Promise<string>

• Parameters

  • positionMintAddress: PublicKey

  Returns Promise<string>

orcaCreateCLMM

• orcaCreateCLMM(
      mintDeploy: PublicKey,
      mintPair: PublicKey,
      initialPrice: Decimal,
      feeTier: 1 | 2 | 4 | 5 | 16 | 30 | 65 | 100 | 200,
  ): Promise<string>

• Parameters

  • mintDeploy: PublicKey
  • mintPair: PublicKey
  • initialPrice: Decimal
  • feeTier: 1 | 2 | 4 | 5 | 16 | 30 | 65 | 100 | 200

  Returns Promise<string>

orcaCreateSingleSidedLiquidityPool

• orcaCreateSingleSidedLiquidityPool(
      depositTokenAmount: number,
      depositTokenMint: PublicKey,
      otherTokenMint: PublicKey,
      initialPrice: Decimal,
      maxPrice: Decimal,
      feeTier: 1 | 2 | 4 | 5 | 16 | 30 | 65 | 100 | 200,
  ): Promise<string>

• Parameters

  • depositTokenAmount: number
  • depositTokenMint: PublicKey
  • otherTokenMint: PublicKey
  • initialPrice: Decimal
  • maxPrice: Decimal
  • feeTier: 1 | 2 | 4 | 5 | 16 | 30 | 65 | 100 | 200

  Returns Promise<string>

orcaFetchPositions

• orcaFetchPositions(): Promise<string>

• Returns Promise<string>

orcaOpenCenteredPositionWithLiquidity

• orcaOpenCenteredPositionWithLiquidity(
      whirlpoolAddress: PublicKey,
      priceOffsetBps: number,
      inputTokenMint: PublicKey,
      inputAmount: Decimal,
  ): Promise<string>

• Parameters

  • whirlpoolAddress: PublicKey
  • priceOffsetBps: number
  • inputTokenMint: PublicKey
  • inputAmount: Decimal

  Returns Promise<string>

orcaOpenSingleSidedPosition

• orcaOpenSingleSidedPosition(
      whirlpoolAddress: PublicKey,
      distanceFromCurrentPriceBps: number,
      widthBps: number,
      inputTokenMint: PublicKey,
      inputAmount: Decimal,
  ): Promise<string>

• Parameters

  • whirlpoolAddress: PublicKey
  • distanceFromCurrentPriceBps: number
  • widthBps: number
  • inputTokenMint: PublicKey
  • inputAmount: Decimal

  Returns Promise<string>

raydiumCreateAmmV4

• raydiumCreateAmmV4(
      marketId: PublicKey,
      baseAmount: BN,
      quoteAmount: BN,
      startTime: BN,
  ): Promise<string>

• Parameters

  • marketId: PublicKey
  • baseAmount: BN
  • quoteAmount: BN
  • startTime: BN

  Returns Promise<string>

raydiumCreateClmm

• raydiumCreateClmm(
      mint1: PublicKey,
      mint2: PublicKey,
      configId: PublicKey,
      initialPrice: Decimal,
      startTime: BN,
  ): Promise<string>

• Parameters

  • mint1: PublicKey
  • mint2: PublicKey
  • configId: PublicKey
  • initialPrice: Decimal
  • startTime: BN

  Returns Promise<string>

raydiumCreateCpmm

• raydiumCreateCpmm(
      mint1: PublicKey,
      mint2: PublicKey,
      configId: PublicKey,
      mintAAmount: BN,
      mintBAmount: BN,
      startTime: BN,
  ): Promise<string>

• Parameters

  • mint1: PublicKey
  • mint2: PublicKey
  • configId: PublicKey
  • mintAAmount: BN
  • mintBAmount: BN
  • startTime: BN

  Returns Promise<string>

registerDomain

• registerDomain(name: string, spaceKB?: number): Promise<string>

• Parameters

  • name: string
  • OptionalspaceKB: number

  Returns Promise<string>

rejectMultisigProposal

• rejectMultisigProposal(transactionIndex?: number | bigint): Promise<string>

• Parameters

  • OptionaltransactionIndex: number | bigint

  Returns Promise<string>

requestFaucetFunds

• requestFaucetFunds(): Promise<string>

• Returns Promise<string>

requestUnstakeFromDriftInsuranceFund

• requestUnstakeFromDriftInsuranceFund(
      amount: number,
      symbol: string,
  ): Promise<string>

• Parameters

  • amount: number
  • symbol: string

  Returns Promise<string>

requestWithdrawalFromDriftVault

• requestWithdrawalFromDriftVault(amount: number, vault: string): Promise<string>

• Parameters

  • amount: number
  • vault: string

  Returns Promise<string>

resolveAllDomains

• resolveAllDomains(domain: string): Promise<undefined | PublicKey>

• Parameters

  • domain: string

  Returns Promise<undefined | PublicKey>

resolveSolDomain

• resolveSolDomain(domain: string): Promise<PublicKey>

• Parameters

  • domain: string

  Returns Promise<PublicKey>

restake

• restake(amount: number): Promise<string>

• Parameters

  • amount: number

  Returns Promise<string>

rockPaperScissors

• rockPaperScissors(
      amount: number,
      choice: "rock" | "paper" | "scissors",
  ): Promise<string>

• Parameters

  • amount: number
  • choice: "rock" | "paper" | "scissors"

  Returns Promise<string>

sendCompressedAirdrop

• sendCompressedAirdrop(
      mintAddress: string,
      amount: number,
      decimals: number,
      recipients: string[],
      priorityFeeInLamports: number,
      shouldLog: boolean,
  ): Promise<string[]>

• Parameters

  • mintAddress: string
  • amount: number
  • decimals: number
  • recipients: string[]
  • priorityFeeInLamports: number
  • shouldLog: boolean

  Returns Promise<string[]>

sendTranctionWithPriority

• sendTranctionWithPriority(
      priorityLevel: string,
      amount: number,
      to: PublicKey,
      splmintAddress?: PublicKey,
  ): Promise<{ fee: number; transactionId: string }>

• Parameters

  • priorityLevel: string
  • amount: number
  • to: PublicKey
  • OptionalsplmintAddress: PublicKey

  Returns Promise<{ fee: number; transactionId: string }>

simulateSwitchboardFeed

• simulateSwitchboardFeed(feed: string, crossbarUrl: string): Promise<string>

• Parameters

  • feed: string
  • crossbarUrl: string

  Returns Promise<string>

spreadToken

• spreadToken(
      inputAsset: InputAssetStruct,
      targetTokens: TargetTokenStruct[],
      priorityFee: PriorityFee,
  ): Promise<string[]>

• Parameters

  • inputAsset: InputAssetStruct
  • targetTokens: TargetTokenStruct[]
  • priorityFee: PriorityFee

  Returns Promise<string[]>

stake

• stake(amount: number): Promise<string>

• Parameters

  • amount: number

  Returns Promise<string>

stakeToDriftInsuranceFund

• stakeToDriftInsuranceFund(amount: number, symbol: string): Promise<string>

• Parameters

  • amount: number
  • symbol: string

  Returns Promise<string>

swap

• swap(
      amount: string,
      fromChain: string,
      fromToken: string,
      toChain: string,
      toToken: string,
      dstAddr: string,
      slippageBps?: number,
  ): Promise<string>

• Parameters

  • amount: string
  • fromChain: string
  • fromToken: string
  • toChain: string
  • toToken: string
  • dstAddr: string
  • OptionalslippageBps: number

  Returns Promise<string>

tensorCancelListing

• tensorCancelListing(nftMint: PublicKey): Promise<string>

• Parameters

  • nftMint: PublicKey

  Returns Promise<string>

tensorListNFT

• tensorListNFT(nftMint: PublicKey, price: number): Promise<string>

• Parameters

  • nftMint: PublicKey
  • price: number

  Returns Promise<string>

trade

• trade(
      outputMint: PublicKey,
      inputAmount: number,
      inputMint?: PublicKey,
      slippageBps?: number,
  ): Promise<string>

• Parameters

  • outputMint: PublicKey
  • inputAmount: number
  • OptionalinputMint: PublicKey
  • slippageBps: number = DEFAULT_OPTIONS.SLIPPAGE_BPS

  Returns Promise<string>

tradeUsingDelegatedDriftVault

• tradeUsingDelegatedDriftVault(
      vault: string,
      amount: number,
      symbol: string,
      action: "long" | "short",
      type: "market" | "limit",
      price?: number,
  ): Promise<TxSigAndSlot>

• Parameters

  • vault: string
  • amount: number
  • symbol: string
  • action: "long" | "short"
  • type: "market" | "limit"
  • Optionalprice: number

  Returns Promise<TxSigAndSlot>

tradeUsingDriftPerpAccount

• tradeUsingDriftPerpAccount(
      amount: number,
      symbol: string,
      action: "long" | "short",
      type: "market" | "limit",
      price?: number,
  ): Promise<string>

• Parameters

  • amount: number
  • symbol: string
  • action: "long" | "short"
  • type: "market" | "limit"
  • Optionalprice: number

  Returns Promise<string>