Class SolanaTransactionService

constructor

• new SolanaTransactionService(
      __namedParameters: {
          backofficeWalletQueryService: BackofficeWalletQueryService;
          heliusRpcClient: HeliusRpcClient;
      },
  ): SolanaTransactionService

  Parameters

  • __namedParameters: {
        backofficeWalletQueryService: BackofficeWalletQueryService;
        heliusRpcClient: HeliusRpcClient;
    }

  Returns SolanaTransactionService

Staticinstance

getMinimumBalanceForRentExemption

• getMinimumBalanceForRentExemption(dataLength: number): Promise<number>

  Get the minimum lamport balance needed for rent exemption at a given data size.

  Parameters

  • dataLength: number

  Returns Promise<number>

getNonce

• getNonce(__namedParameters: { nonceAccount: Address }): Promise<Nonce>

  The current on-chain value of one nonce account. Throws when the account is missing: a nonce in use always exists.

  Parameters

  • __namedParameters: { nonceAccount: Address }

  Returns Promise<Nonce>

getNonces

• getNonces(
      __namedParameters: { nonceAccounts: Address[] },
  ): Promise<(Nonce | null)[]>

  The current on-chain value of each nonce account, in the order given, read in one RPC call per MAX_MULTIPLE_ACCOUNTS accounts. null for an account that does not exist or is not an initialized nonce account.

  Parameters

  • __namedParameters: { nonceAccounts: Address[] }

  Returns Promise<(Nonce | null)[]>

latestBlockhash

• latestBlockhash(): Promise<{ blockhash: string; lastValidBlockHeight: number }>

  Fetch a blockhash without building anything with it.

  For a caller that builds many messages against one lifetime — a bulk writer sending hundreds of independent transactions — and needs the lifetime as a value so did this generation land stays a single question with a single answer. Pass the result back in as lifetime below.

  Returns Promise<{ blockhash: string; lastValidBlockHeight: number }>

simulateTransaction

• simulateTransaction(
      transaction: Transaction,
      opts?: { sigVerify?: boolean },
  ): Promise<
      {
          response: {
              accounts: object[]
              | null;
              err: string | object | null;
              logs: string[] | null;
              unitsConsumed: number | undefined;
          };
          success: boolean;
      },
  >

  Simulate a Solana transaction by sending it to the RPC.

  Parameters

  • transaction: Transaction
  • opts: { sigVerify?: boolean } = {}

  Returns Promise<
      {
          response: {
              accounts: object[]
              | null;
              err: string | object | null;
              logs: string[] | null;
              unitsConsumed: number | undefined;
          };
          success: boolean;
      },
  >

transactionWithBlockhash

• transactionWithBlockhash(
      __namedParameters: {
          cuLimit?: number | "UNSET";
          cuPrice?: number | bigint | "UNSET";
          instructions: Instruction<
              string,
              readonly (AccountLookupMeta<string, string> | AccountMeta<string>)[],
          >[];
          lifetime?: { blockhash: string; lastValidBlockHeight: number };
          payer: Address;
      },
  ): Promise<
      {
          lastValidBlockHeight: number;
          message: SolanaBlockhashTransactionMessage;
      },
  >

  Parameters

  • __namedParameters: {
        cuLimit?: number | "UNSET";
        cuPrice?: number | bigint | "UNSET";
        instructions: Instruction<
            string,
            readonly (AccountLookupMeta<string, string> | AccountMeta<string>)[],
        >[];
        lifetime?: { blockhash: string; lastValidBlockHeight: number };
        payer: Address;
    }

    • OptionalcuLimit?: number | "UNSET"

    • OptionalcuPrice?: number | bigint | "UNSET"

    • instructions: Instruction<
          string,
          readonly (AccountLookupMeta<string, string> | AccountMeta<string>)[],
      >[]

    • Optionallifetime?: { blockhash: string; lastValidBlockHeight: number }

      Reuse a blockhash from latestBlockhash instead of fetching one. Without it every message costs its own getLatestBlockhash round trip and lands on its own lifetime, so a batch has no shared expiry to reason about.

    • payer: Address

  Returns Promise<
      {
          lastValidBlockHeight: number;
          message: SolanaBlockhashTransactionMessage;
      },
  >

transactionWithNonce

• transactionWithNonce(
      __namedParameters: {
          cuLimit?: number | "UNSET";
          cuPrice?: number | bigint | "UNSET";
          instructions: Instruction<
              string,
              readonly (AccountLookupMeta<string, string> | AccountMeta<string>)[],
          >[];
          nonce: Nonce;
          nonceAccount: Address;
          payer: Address;
      },
  ): Promise<SolanaNonceTransactionMessage>

  Parameters

  • __namedParameters: {
        cuLimit?: number | "UNSET";
        cuPrice?: number | bigint | "UNSET";
        instructions: Instruction<
            string,
            readonly (AccountLookupMeta<string, string> | AccountMeta<string>)[],
        >[];
        nonce: Nonce;
        nonceAccount: Address;
        payer: Address;
    }

    • OptionalcuLimit?: number | "UNSET"

    • OptionalcuPrice?: number | bigint | "UNSET"

    • instructions: Instruction<
          string,
          readonly (AccountLookupMeta<string, string> | AccountMeta<string>)[],
      >[]

    • nonce: Nonce

      The account's current value, as handed out by SolanaNonceService.reserve.

    • nonceAccount: Address

    • payer: Address

  Returns Promise<SolanaNonceTransactionMessage>

  Transaction message for the given instructions, using a durable nonce for the lifetime. Kit prepends the advance-nonce instruction automatically. Caller must sign (PAYER + NONCE_AUTHORITY + any others) before broadcast.