Network.Solana.SolanaWeb3

Builds, signs, and submits a transaction that executes the given instructions, returning its signature.

Fetches the latest blockhash from the cluster, compiles the instructions with newTransactionIntentWithPayer naming the first key as the fee payer (forced into account 0 as a writable signer, even if no instruction marks it writable -- e.g. a memo-only or SPL authority-only transaction -- or references it at all), signs with the given keys (any order; signatures are placed in message order automatically), and broadcasts the result with sendTransaction.

Throws userError "newTransaction: no signers given" if the key list is empty, and a CompileException if an instruction references an account key that cannot be resolved in the compiled message, if a required signer has no corresponding key, or if a given key signs nothing.

Configuration used to fetch the nonce account in newNonceTransaction: base64 encoding (needed to decode the account's data, same as getAccountInfo) plus an explicit confirmed commitment, so a recently created or recently advanced nonce account is not missed by the node's default finalized commitment.

Configuration used to submit the transaction in newNonceTransaction: defaultRpcSendTransactionConfig with the preflight simulation pinned at the commitment the nonce account is read at (cfgNonceAccountConfirmed). The node's default finalized preflight bank may not yet hold the nonce value the transaction was built against (or the account at all) right after creation or an advance, and rejects the send with BlockhashNotFound.

Builds, signs, and submits a durable-nonce transaction with an explicitly named fee payer that executes the given instructions, returning its signature.

Reads the given nonce account at confirmed commitment to avoid stale-nonce races (a nonce account fetched at the node's default finalized commitment may appear not-found or stale immediately after creation or after being advanced), then builds the transaction with newDurableNonceTransactionIntentWithPayer, which prepends the nonce-advance instruction ahead of the given instructions and uses the nonce account's durable nonce in place of a recent block hash (so the transaction never expires, unlike newTransaction), and submits it with sendTransaction' under cfgNonceSendConfirmed, so the node's preflight simulation runs at that same confirmed commitment instead of its default finalized bank (which may not yet contain the nonce value used, or the account at all, immediately after creation or an advance). The fee payer is always account 0 (sponsored fees are supported), and the given signers may be listed in any order — they must include private keys corresponding to both the payer and the nonce account's authority (nsAuthority), or the resulting transaction will be rejected on submission. Requires a reachable RPC node.

Throws userError "newNonceTransaction: nonce account not found" if the account does not exist, and userError "newNonceTransaction: nonce account not initialized" if it exists but has not been initialized as a nonce account -- distinct from each other and from the CompileException thrown if an instruction references an account key that cannot be resolved in the compiled message.

Estimates a priority fee (in micro-lamports per compute unit) for landing a transaction that writes to the given accounts, as the p-th percentile of recent per-compute-unit fees observed for them (via getRecentPrioritizationFees and percentilePriorityFee).

Heuristic only: recent fees are no guarantee of what is needed to land the next transaction. Returns 0 if no recent priority fees were observed for the given accounts. Requires a reachable RPC node.

Prints the balance of each of the given accounts to standard output using printBalance.

Fetches the balance of the given account with getBalance and prints it to standard output.

Suspends execution for the given number of seconds, printing a notice first. A crude way to wait for transaction confirmation; prefer polling getSignatureStatuses in real applications.

Polls getSignatureStatuses once a second, up to 30 times, until the given signature reaches confirmed or finalized status.

Returns True only if the status reaches the target commitment and the node reports no on-chain error for it (its err field is Nothing); a transaction that landed but failed on-chain (e.g. a program error) yields False, not True. Also returns False if it does not confirm within the poll budget. See confirmFinalized to wait for finalization instead.

Polls getSignatureStatuses once a second, up to 60 times, until the given signature reaches finalized status.

Throws a userError if the transaction finalizes with an on-chain error, or if it does not finalize within the poll budget (naming the signature in both cases). Use it before reading state through helpers that use the node's default commitment (printBalances, getBalance, getTokenAccount, ...): a transaction that confirmTransaction reports at confirmed is not yet visible there.

Extracts the raw bytes backing an account's data field. Every fetch helper in this module requests base64 encoding (see getAccountInfo), so AccountDataJSON should never occur in practice; if it does, it is reported the same way as any other decode failure.

Fetches the given account with getAccountInfo and decodes its data with the given decoder, prefixing any failure message with the given label.

Returns Nothing if the account does not exist. Propagates the underlying JSON-RPC exception on RPC failure, same as every other RPC-backed helper in this module. Throws userError (label <> ": state decode failed: " <> err) if the account exists but its data cannot be decoded -- distinct from the not-found case.

Fetches the given account and decodes it as an SPL Token account with decodeTokenAccount.

Returns Nothing if the account does not exist. Throws on RPC failure, per fetchAccountState. Throws userError ("getTokenAccount: state decode failed: " <> err) if the account exists but is not a well-formed SPL Token account -- distinct from the not-found case.

Fetches the given account and decodes it as an SPL Token mint with decodeMint.

Returns Nothing if the account does not exist. Throws on RPC failure, per fetchAccountState. Throws userError ("getMint: state decode failed: " <> err) if the account exists but is not a well-formed mint -- distinct from the not-found case.

Fetches the given address lookup table account, decodes it with decodeLookupTable, and bridges it into the AddressLookupTableAccount shape compileV0Message expects (via lookupTableToAccount), using the queried address as the table's own key.

Returns Nothing if the account does not exist. Throws on RPC failure, per fetchAccountState. Throws userError ("getLookupTable: state decode failed: " <> err) if the account exists but is not a well-formed lookup table -- distinct from the not-found case.

Fetches the given account and decodes it as a stake account with decodeStakeAccount.

Returns Nothing if the account does not exist. Throws on RPC failure, per fetchAccountState. Throws userError ("getStakeAccount: state decode failed: " <> err) if the account exists but is not a well-formed stake account -- distinct from the not-found case.

Fetches the given account and decodes it as a nonce account with decodeNonceAccount.

Returns Nothing if the account does not exist. Throws on RPC failure, per fetchAccountState. Throws userError ("getNonceAccount: state decode failed: " <> err) if the account exists but is not a well-formed nonce account -- distinct from the not-found case.

Fetches the Metaplex metadata account for the given mint (deriving its PDA with deriveMetadataAddress) and decodes it with decodeMetadata.

Calls error if the metadata PDA cannot be derived, matching the precedent set by createMetadataAccountV3 (practically unreachable: requires every bump candidate to land on-curve). Otherwise, returns Nothing if the metadata account does not exist. Throws on RPC failure, per fetchAccountState. Throws userError ("getMetadataAccount: state decode failed: " <> err) if the account exists but is not well-formed metadata -- distinct from the not-found case.