@provablehq/aleo-bridge-sdk 0.1.0

package/dist/solana-D5Qr6SLa.d.ts

@@ -0,0 +1,725 @@
+/** Identifies the protocol that carries a bridge transfer. */
+type BridgeProtocol = 'xreserve' | 'hyperlane';
+/** Identifies the deployment environment selected by a bridge client. */
+type BridgeEnvironment = 'mainnet' | 'testnet';
+/** Identifies the transaction model used by a chain. */
+type BridgeChainFamily = 'aleo' | 'evm' | 'solana';
+/**
+ * Describes a chain known to the protocol bridge registry.
+ *
+ * @property id Stable SDK identifier used by assets and routes.
+ * @property displayName Human-readable chain name.
+ * @property family Transaction model used to prepare transfer steps.
+ * @property environment Deployment environment containing the chain.
+ * @property nativeCurrencySymbol Symbol used to pay transaction fees.
+ * @property protocolDomains Protocol-specific domain identifiers when known.
+ */
+type ProtocolBridgeChain = {
+    id: string;
+    displayName: string;
+    family: BridgeChainFamily;
+    environment: BridgeEnvironment;
+    nativeCurrencySymbol: string;
+    protocolDomains?: Partial<Record<BridgeProtocol, string | number>> | undefined;
+};
+/** Identifies how an asset exists on its chain. */
+type BridgeAssetKind = 'native' | 'token';
+/**
+ * Locates a token on its chain.
+ *
+ * @property kind Namespace containing the identifier.
+ * @property value Contract, program, mint, or native-denom identifier.
+ * @property tokenId Optional token identifier within a shared token program.
+ */
+type BridgeAssetLocator = {
+    kind: 'aleo-program' | 'evm-contract' | 'solana-mint' | 'native';
+    value: string;
+    tokenId?: string | undefined;
+};
+/** Identifies the Aleo transition family used to convert an asset between public and private state. */
+type AleoPrivacyKind = 'arc20' | 'arc22';
+/**
+ * Describes how an Aleo asset converts between public balances and private records.
+ *
+ * @property kind ABI family that determines the transition names and input order.
+ * @property program Program containing the public balance and private `Token` record.
+ */
+type AleoPrivacyCapability = {
+    kind: AleoPrivacyKind;
+    program: string;
+};
+/**
+ * Describes one chain-specific representation of a bridgeable asset.
+ *
+ * @property id Stable registry identifier, scoped to one chain.
+ * @property key Stable caller-facing asset identifier within the chain.
+ * @property chainId Chain carrying this representation.
+ * @property symbol Display symbol.
+ * @property name Human-readable asset name.
+ * @property decimals Number of decimal places accepted in display amounts.
+ * @property kind Whether the representation is native currency or a token.
+ * @property locator Onchain identifier when the deployment is known.
+ * @property addressValidationRegex Optional recipient validation expression.
+ * @property privacy Optional Aleo public/private conversion capability.
+ */
+type ProtocolBridgeAsset = {
+    id: string;
+    key: string;
+    chainId: string;
+    symbol: string;
+    name: string;
+    decimals: number;
+    kind: BridgeAssetKind;
+    locator?: BridgeAssetLocator | undefined;
+    addressValidationRegex?: string | undefined;
+    privacy?: AleoPrivacyCapability | undefined;
+};
+/** Reports whether a route has enough reviewed metadata for execution. */
+type BridgeRouteAvailability = 'active' | 'metadata-required' | 'disabled';
+/**
+ * Describes one directional protocol route.
+ *
+ * @property id Stable route identifier.
+ * @property protocol Protocol responsible for delivery.
+ * @property environment Deployment environment containing both endpoints.
+ * @property sourceAssetId Registry id of the debited asset.
+ * @property destinationAssetId Registry id of the delivered asset.
+ * @property availability Readiness for transaction execution.
+ * @property deploymentId Upstream protocol deployment identifier when known.
+ * @property source Reference used to audit the route metadata.
+ * @property metadata Protocol-specific non-secret configuration.
+ */
+type ProtocolBridgeRoute = {
+    id: string;
+    protocol: BridgeProtocol;
+    environment: BridgeEnvironment;
+    sourceAssetId: string;
+    destinationAssetId: string;
+    availability: BridgeRouteAvailability;
+    deploymentId?: string | undefined;
+    source?: string | undefined;
+    metadata?: Readonly<Record<string, string | number | boolean>> | undefined;
+};
+/**
+ * Selects chain-specific assets from a bridge registry.
+ *
+ * @property environment Optional mainnet or testnet filter. Defaults to both environments.
+ * @property chainId Optional registry chain identifier filter. Defaults to all chains.
+ * @property symbol Optional case-insensitive token symbol filter. Defaults to all symbols.
+ */
+type GetAssetsParameters = {
+    environment?: BridgeEnvironment | undefined;
+    chainId?: string | undefined;
+    symbol?: string | undefined;
+};
+/**
+ * Selects directional routes from a bridge registry.
+ *
+ * @property environment Optional mainnet or testnet filter. Defaults to both environments.
+ * @property protocol Optional bridge provider filter. Defaults to all providers.
+ * @property sourceChainId Optional source registry chain identifier. Defaults to all source chains.
+ * @property destinationChainId Optional destination registry chain identifier. Defaults to all destination chains.
+ * @property symbol Optional case-insensitive source or destination token symbol. Defaults to all symbols.
+ * @property includeUnavailable Includes disabled routes when true. Defaults to false; routes awaiting metadata remain visible.
+ */
+type GetRoutesParameters = {
+    environment?: BridgeEnvironment | undefined;
+    protocol?: BridgeProtocol | undefined;
+    sourceChainId?: string | undefined;
+    destinationChainId?: string | undefined;
+    symbol?: string | undefined;
+    includeUnavailable?: boolean | undefined;
+};
+/**
+ * Stores reviewed bridge chains, assets, and directional routes.
+ *
+ * @property version Caller-visible version used to pin and audit configuration.
+ * @property chains Chain metadata referenced by assets.
+ * @property assets Chain-specific assets referenced by routes.
+ * @property routes Directional protocol routes.
+ * @property sources Upstream registries and documentation used to build the snapshot.
+ * @property getAssets Lists matching chain-specific assets without contacting a chain or wallet.
+ * @property getRoutes Lists matching directional routes without contacting a chain or wallet.
+ */
+type BridgeRegistry = {
+    version: string;
+    chains: readonly ProtocolBridgeChain[];
+    assets: readonly ProtocolBridgeAsset[];
+    routes: readonly ProtocolBridgeRoute[];
+    sources?: readonly string[] | undefined;
+    getAssets: (params?: GetAssetsParameters) => ProtocolBridgeAsset[];
+    getRoutes: (params?: GetRoutesParameters) => ProtocolBridgeRoute[];
+};
+/** Identifies the signer or service responsible for a transfer step. */
+type BridgeStepExecutor = 'aleo-wallet' | 'evm-wallet' | 'solana-wallet' | 'protocol';
+/** Identifies a resumable operation in a protocol transfer. */
+type BridgeExecutionStepKind = 'approve' | 'deposit' | 'burn' | 'dispatch' | 'wait-attestation' | 'mint' | 'withdraw' | 'wait-delivery' | 'confirm-delivery';
+/**
+ * Describes one stage required to move an asset between two chains.
+ *
+ * @property key Stable step key within the plan.
+ * @property kind Operation the executor performs.
+ * @property chainId Chain on which the operation occurs, when applicable.
+ * @property executor Wallet or protocol service responsible for the operation.
+ * @property description Human-readable consequence of the step.
+ * @property irreversible Whether submitting the step commits funds to the protocol flow.
+ */
+type BridgeExecutionStep = {
+    key: string;
+    kind: BridgeExecutionStepKind;
+    chainId?: string | undefined;
+    executor: BridgeStepExecutor;
+    description: string;
+    irreversible: boolean;
+};
+/**
+ * Describes a fee associated with a transfer plan.
+ *
+ * @property kind Fee category.
+ * @property chainId Chain charging the fee.
+ * @property assetId Asset used to pay the fee when known.
+ * @property amount Decimal fee amount when available.
+ * @property estimated Whether the amount can change before submission.
+ */
+type BridgeFee = {
+    kind: 'network' | 'protocol' | 'relayer';
+    chainId: string;
+    assetId?: string | undefined;
+    amount?: string | undefined;
+    estimated: boolean;
+};
+/** Selects the Aleo destination transition used for an xReserve mint. */
+type AleoMintMode = 'public' | 'record' | 'private';
+/**
+ * Selects one chain-specific bridge asset without exposing registry route ids.
+ *
+ * @property chain Stable registry chain identifier.
+ * @property asset Stable asset key within the selected chain.
+ */
+type BridgeEndpoint = {
+    chain: string;
+    asset: string;
+};
+/**
+ * Parameters for preparing a protocol bridge transfer.
+ *
+ * @property source Chain and asset debited by the transfer.
+ * @property destination Chain and asset delivered by the transfer.
+ * @property bridgeProtocol Optional protocol constraint. Omit when exactly one route matches the endpoints.
+ * @property amount Decimal source amount in display units.
+ * @property recipient Destination-chain recipient.
+ * @property sender Optional source-chain sender used by future fee and approval planning.
+ * @property mintMode Aleo mint transition selected for xReserve delivery. Defaults to `public`.
+ * @property privateRecipient Deprecated alias for `mintMode: 'private'`. Defaults to false.
+ */
+type PrepareParameters = {
+    source: BridgeEndpoint;
+    destination: BridgeEndpoint;
+    bridgeProtocol?: BridgeProtocol | undefined;
+    amount: string;
+    recipient: string;
+    sender?: string | undefined;
+    mintMode?: AleoMintMode | undefined;
+    /** @deprecated Use `mintMode: 'private'`; retained for compatibility through the next major release. */
+    privateRecipient?: boolean | undefined;
+};
+/**
+ * Records the route, assets, amount, recipient, and stages of a cross-chain transfer.
+ *
+ * This information can be quoted before any wallet authorization is requested
+ * or funds move.
+ *
+ * @property registryVersion Registry snapshot used to build the plan.
+ * @property protocol Protocol responsible for delivery.
+ * @property route Directional route selected by the caller.
+ * @property sourceAsset Asset debited by the source transaction.
+ * @property destinationAsset Asset delivered on the destination chain.
+ * @property amountIn Decimal source amount.
+ * @property amountOut Expected decimal destination amount when determinable without a live fee query.
+ * @property recipient Destination-chain recipient.
+ * @property sender Optional source-chain sender.
+ * @property mintMode Aleo destination transition selected by the caller.
+ * @property privateRecipient Whether the destination requests private Aleo delivery.
+ * @property fees Known fee categories; amounts remain absent until protocol quoting is implemented.
+ * @property steps Ordered operations required to complete the transfer.
+ */
+type BridgePlan = {
+    registryVersion: string;
+    protocol: BridgeProtocol;
+    route: ProtocolBridgeRoute;
+    sourceAsset: ProtocolBridgeAsset;
+    destinationAsset: ProtocolBridgeAsset;
+    amountIn: string;
+    amountOut?: string | undefined;
+    recipient: string;
+    sender?: string | undefined;
+    mintMode: AleoMintMode;
+    privateRecipient: boolean;
+    fees: BridgeFee[];
+    steps: BridgeExecutionStep[];
+};
+/**
+ * Records the public inputs needed to reconstruct a cross-chain transfer.
+ *
+ * Private keys, records, proofs, and private-mint nonces are deliberately
+ * excluded so this value can be stored with transaction identifiers.
+ *
+ * @property source Chain and asset debited by the transfer.
+ * @property destination Chain and asset delivered by the transfer.
+ * @property bridgeProtocol Resolved protocol selected during preparation.
+ * @property amount Decimal source amount in display units.
+ * @property recipient Destination-chain recipient.
+ * @property sender Source-chain sender when the plan or executing wallet resolved one.
+ * @property mintMode Aleo destination transition selected by the caller.
+ */
+type BridgeIntent = {
+    source: BridgeEndpoint;
+    destination: BridgeEndpoint;
+    bridgeProtocol: BridgeProtocol;
+    amount: string;
+    recipient: string;
+    sender?: string | undefined;
+    mintMode?: AleoMintMode | undefined;
+};
+/** Identifies the normalized lifecycle state of a protocol transfer. */
+type BridgeStatus = 'PREPARED' | 'SOURCE_APPROVAL_PENDING' | 'SOURCE_SUBMISSION_PENDING' | 'SOURCE_CONFIRMING' | 'ATTESTATION_PENDING' | 'DESTINATION_ACTION_REQUIRED' | 'DELIVERY_PENDING' | 'DESTINATION_CONFIRMING' | 'COMPLETED' | 'FAILED' | 'EXPIRED';
+/**
+ * Describes the next caller-authorized bridge operation.
+ *
+ * @property kind Protocol operation ready for wallet submission.
+ * @property chainId Registry chain on which the wallet will submit it.
+ */
+type BridgeNextAction = {
+    kind: 'xreserve-private-mint';
+    chainId: string;
+};
+/**
+ * Captures protocol-neutral transfer progress and protocol-native state.
+ *
+ * @property id Stable transfer or message identifier.
+ * @property protocol Protocol responsible for delivery.
+ * @property status Normalized lifecycle state.
+ * @property sourceTxId Source-chain transaction identifier when submitted.
+ * @property destinationTxId Destination-chain transaction identifier when submitted.
+ * @property messageId Hyperlane message identifier when applicable.
+ * @property nextAction Caller-authorized operation available at the current status.
+ * @property protocolState Protocol-native progress fields retained for diagnostics and resumption.
+ */
+type BridgeReceipt = {
+    id: string;
+    protocol: BridgeProtocol;
+    status: BridgeStatus;
+    sourceTxId?: string | undefined;
+    destinationTxId?: string | undefined;
+    messageId?: string | undefined;
+    nextAction?: BridgeNextAction | undefined;
+    protocolState: Readonly<Record<string, unknown>>;
+};
+/**
+ * Records prepared or submitted transaction data needed to recover a bridge transfer.
+ *
+ * The checkpoint excludes expanded registry objects, secrets, and protocol
+ * response bodies, except serialized Aleo transactions that become public on
+ * broadcast. The caller stores it only for interrupted-process recovery.
+ *
+ * @property version Serialization format version, currently `1`.
+ * @property intent Public inputs used to reconstruct the runtime plan.
+ * @property route Canonical route and registry version that bound execution.
+ * @property source Prepared or submitted source transactions.
+ * @property source.approvalTransactionIds Source token approval transaction identifiers in submission order.
+ * @property source.transactionId Irreversible source transfer transaction when submitted.
+ * @property source.preparedTransaction Fully proved Aleo transaction retained before broadcast for idempotent recovery.
+ * @property source.hookData Public xReserve hook committed by a submitted approval sequence.
+ * @property source.blockhash Solana blockhash that bounded the submitted source transaction.
+ * @property source.lastValidBlockHeight Final Solana block height at which the source transaction can land.
+ * @property destination Caller-authorized destination transaction when submitted.
+ * @property destination.transactionId Destination-chain transaction identifier.
+ * @property destination.preparedTransaction Fully proved Aleo destination transaction retained before broadcast for idempotent recovery.
+ * @property deliveryVerification Destination balance snapshot used when the protocol explorer does not index Aleo origins.
+ */
+type BridgeCheckpoint = {
+    version: 1;
+    intent: BridgeIntent;
+    route: {
+        id: string;
+        registryVersion: string;
+    };
+    source?: {
+        approvalTransactionIds?: readonly string[] | undefined;
+        transactionId?: string | undefined;
+        hookData?: string | undefined;
+        blockhash?: string | undefined;
+        lastValidBlockHeight?: string | undefined;
+        preparedTransaction?: {
+            transactionId: string;
+            serializedTransaction: string;
+        } | undefined;
+    } | undefined;
+    destination?: {
+        transactionId?: string | undefined;
+        preparedTransaction?: {
+            transactionId: string;
+            serializedTransaction: string;
+        } | undefined;
+    } | undefined;
+    deliveryVerification?: {
+        balanceBeforeAtomic: string;
+        expectedIncreaseAtomic: string;
+    } | undefined;
+};
+/**
+ * Identifies the operation available after bridge progress is reconstructed.
+ *
+ * `wait` requires only reads, while `resume` and `complete` mark explicit
+ * wallet authorization boundaries.
+ */
+type BridgeProgressNext = 'wait' | 'resume' | 'complete' | 'done' | 'failed';
+type BridgeProgressState = {
+    plan: BridgePlan;
+    receipt: BridgeReceipt;
+};
+/**
+ * Carries reconstructed runtime state and tells the caller what can happen next.
+ *
+ * @property next Read-only observation, source resumption, destination completion, or terminal outcome.
+ * @property plan Runtime plan rebuilt from the checkpoint's public intent.
+ * @property receipt Latest protocol-neutral lifecycle receipt.
+ * @property error Failure description when `next` is `failed`.
+ */
+type BridgeProgress = (BridgeProgressState & {
+    next: 'wait';
+}) | (BridgeProgressState & {
+    next: 'resume';
+}) | (BridgeProgressState & {
+    next: 'complete';
+}) | (BridgeProgressState & {
+    next: 'done';
+}) | (BridgeProgressState & {
+    next: 'failed';
+    error: string;
+});
+
+/**
+ * Sends a Solana JSON-RPC POST request without coupling the bridge client to a runtime global.
+ *
+ * Matches the subset of the Fetch API needed for JSON-RPC calls, so
+ * `globalThis.fetch` satisfies this type without an adapter.
+ */
+type SolanaRpcHttpTransport = (url: string, init: {
+    method: 'POST';
+    headers: Record<string, string>;
+    body: string;
+    cache?: 'no-store' | undefined;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    json: () => Promise<unknown>;
+}>;
+/**
+ * Configures the Solana JSON-RPC endpoint used for reads such as blockhash and
+ * transaction-confirmation lookups.
+ *
+ * @property url Solana JSON-RPC HTTP endpoint.
+ * @property transport Optional fetch-compatible transport used for RPC requests. Defaults to `globalThis.fetch`.
+ */
+type SolanaRpcConfig = {
+    url: string;
+    transport?: SolanaRpcHttpTransport | undefined;
+};
+/**
+ * Captures the reviewed metadata required to dispatch a Solana Hyperlane Warp Route transfer.
+ *
+ * @property warpProgramAddress Deployed Solana Warp Route program handling the transfer instruction.
+ * @property tokenPda Program-derived address holding the route's token configuration.
+ * @property nativeCollateralPda Program-derived address holding locked native SOL collateral.
+ * @property dispatchAuthorityPda Program-derived address authorizing Mailbox dispatch on behalf of the Warp Route.
+ * @property mailboxProgramAddress Solana Hyperlane Mailbox program used by the reviewed deployment.
+ * @property mailboxOutboxPda Program-derived address holding the Mailbox's outbox state.
+ * @property igpProgramAddress Solana interchain gas paymaster program used by the reviewed deployment.
+ * @property igpProgramDataPda Program-derived address holding the gas paymaster's program data.
+ * @property igpAccount Terminal gas-oracle account actually debited for destination delivery; read
+ * directly off the token's configuration when the route points at a plain IGP, or off the configured
+ * `igpOverheadAccount`'s own `inner` field when the route wraps its IGP in an `OverheadIgp`.
+ * @property igpOverheadAccount Optional `OverheadIgp` wrapper account configured as the token's gas
+ * paymaster. Present only when the reviewed deployment wraps its IGP in an `OverheadIgp` layer;
+ * `buildTransferRemoteInstruction` appends it ahead of `igpAccount` when set, and omits it otherwise.
+ * @property splNoopProgramAddress SPL no-op program used to emit Hyperlane message logs.
+ * @property destinationDomain Hyperlane domain passed to the transfer instruction.
+ * @property destinationGasAmount Destination gas amount quoted for delivery, as a base-10 string.
+ * @property registryCommit Hyperlane Registry commit containing the deployment snapshot.
+ * @property solanaReviewedAt ISO 8601 timestamp of the last manual review of this deployment.
+ * @property solanaConfigSource Identifies where the reviewed configuration values were sourced from.
+ */
+type SolanaHyperlaneRouteMetadata = {
+    warpProgramAddress: string;
+    tokenPda: string;
+    nativeCollateralPda: string;
+    dispatchAuthorityPda: string;
+    mailboxProgramAddress: string;
+    mailboxOutboxPda: string;
+    igpProgramAddress: string;
+    igpProgramDataPda: string;
+    igpAccount: string;
+    igpOverheadAccount?: string | undefined;
+    splNoopProgramAddress: string;
+    destinationDomain: number;
+    destinationGasAmount: string;
+    registryCommit: string;
+    solanaReviewedAt: string;
+    solanaConfigSource: string;
+};
+/**
+ * Supplies a Solana-to-Aleo Hyperlane transfer for current fee calculation.
+ *
+ * @property plan Route, amount, and recipient selected for the transfer.
+ */
+type QuoteSolanaHyperlaneTransferParameters = {
+    plan: BridgePlan;
+};
+/**
+ * Captures one live fee quote for a Solana-to-Aleo Hyperlane transfer.
+ *
+ * All amounts are denominated in lamports.
+ *
+ * @property routeId Route the quote applies to.
+ * @property amountLamports Amount to be transferred, in lamports.
+ * @property igpPaymentLamports Interchain gas paymaster payment required for destination delivery, in lamports.
+ * @property networkFeeLamports Solana network fee estimated for the transaction, in lamports.
+ * @property rentLamports Rent-exempt funding for the gas-payment account, dispatched-message account, and fee payer, in lamports.
+ * @property totalLamports Executable balance requirement: amount, gas payment, network fee, and rent, in lamports.
+ */
+type SolanaHyperlaneTransferQuote = {
+    routeId: string;
+    amountLamports: bigint;
+    igpPaymentLamports: bigint;
+    networkFeeLamports: bigint;
+    rentLamports: bigint;
+    totalLamports: bigint;
+};
+/**
+ * Configures submission of a Solana Hyperlane transfer.
+ *
+ * The action signs and sends the transaction through the Solana client's
+ * wallet client, then polls its public client for confirmation.
+ *
+ * @property plan Route, amount, and recipient selected for the transfer.
+ * @property pollingIntervalMs Delay between confirmation checks. Defaults to 1,000 milliseconds; floored at 100 milliseconds so a small or zero value cannot busy-poll the RPC endpoint.
+ * @property confirmationTimeoutMs Maximum time to wait for confirmation. Defaults to 120,000 milliseconds; a timeout returns resumable pending state.
+ * @property resume Previously checkpointed receipt. When supplied, the action
+ *   verifies the existing signature without signing or broadcasting again.
+ * @property onSubmitted Durable checkpoint hook called immediately after broadcast
+ *   and before confirmation polling begins.
+ */
+type ExecuteSolanaHyperlaneTransferParameters = {
+    plan: BridgePlan;
+    pollingIntervalMs?: number | undefined;
+    confirmationTimeoutMs?: number | undefined;
+    resume?: BridgeReceipt | undefined;
+    onSubmitted?: ((receipt: BridgeReceipt) => void | Promise<void>) | undefined;
+};
+/**
+ * Captures the resumable Hyperlane progress after a Solana transfer is submitted.
+ *
+ * @property receipt Protocol-neutral transfer state, including the source signature and message id when confirmed.
+ */
+type SolanaHyperlaneTransferExecution = {
+    receipt: BridgeReceipt;
+};
+
+/**
+ * Confirmation state Solana reports for a submitted transaction signature.
+ *
+ * `'failed'` is synthesized locally from a non-null `err` field on the
+ * `getSignatureStatuses` result; Solana itself only ever reports a
+ * `confirmationStatus`, never a failure status.
+ */
+type SolanaSignatureConfirmationStatus = 'processed' | 'confirmed' | 'finalized' | 'failed';
+/**
+ * Reads live Solana chain state needed to prepare, submit, and confirm a
+ * Hyperlane Warp Route transfer.
+ *
+ * Every method hits the configured Solana JSON-RPC endpoint over the network;
+ * none of them sign or submit a transaction.
+ *
+ * @property getLatestBlockhash Reads the current blockhash and the block height it remains valid through.
+ * @property getBlockHeight Reads the current block height used to detect transaction expiry.
+ * @property isBlockhashValid Reports whether a recent blockhash remains valid at confirmed commitment.
+ * @property getBalance Reads an account's lamport balance.
+ * @property getAccountData Reads an account's raw data, or `null` when the account does not exist.
+ * @property getFeeForMessage Reads the network fee for a compiled transaction message, in lamports.
+ * @property getMinimumBalanceForRentExemption Reads the rent-exempt minimum for an account data length, in lamports.
+ * @property getSignatureStatus Reads a submitted transaction's confirmation state, or `null` when the signature is unknown to the node.
+ * @property getTransactionLogs Reads a confirmed transaction's program logs, or `null` when the transaction is not found.
+ */
+type SolanaRpcClient = {
+    getLatestBlockhash: () => Promise<{
+        blockhash: string;
+        lastValidBlockHeight: bigint;
+    }>;
+    getBlockHeight: () => Promise<bigint>;
+    isBlockhashValid: (blockhash: string) => Promise<boolean>;
+    getBalance: (address: string) => Promise<bigint>;
+    getAccountData: (address: string) => Promise<Uint8Array | null>;
+    getFeeForMessage: (message: Uint8Array) => Promise<bigint>;
+    getMinimumBalanceForRentExemption: (dataLength: number) => Promise<bigint>;
+    getSignatureStatus: (signature: string) => Promise<SolanaSignatureConfirmationStatus | null>;
+    getTransactionLogs: (signature: string) => Promise<string[] | null>;
+};
+/**
+ * Creates the Solana network reader used to quote and follow Hyperlane transfers.
+ *
+ * Every method sends one JSON-RPC request through the supplied transport and
+ * validates the response before returning it. No method requests a wallet
+ * signature or submits a transaction.
+ *
+ * @param config Solana JSON-RPC endpoint and optional Fetch API replacement. The transport defaults to `globalThis.fetch`.
+ * @returns Network reads for blockhashes, balances, fees, rent, accounts, signatures, and logs.
+ *
+ * @example
+ * const rpc = createSolanaRpcClient({ url: 'https://api.mainnet-beta.solana.com' })
+ * const { blockhash } = await rpc.getLatestBlockhash()
+ */
+declare function createSolanaRpcClient(config: SolanaRpcConfig): SolanaRpcClient;
+
+/** Provides Solana's public mainnet endpoint as the default for examples and low-volume reads. */
+declare const DEFAULT_SOLANA_RPC_URL = "https://api.mainnet-beta.solana.com";
+/**
+ * Sends one Solana JSON-RPC method through an application transport.
+ * @param method JSON-RPC method name.
+ * @param params Positional JSON-RPC parameters.
+ * @returns The decoded method result.
+ */
+type SolanaRequest = (method: string, params: unknown[]) => Promise<unknown>;
+/**
+ * Configures Fetch API behavior for a Solana HTTP transport.
+ * @property fetch Optional fetch-compatible JSON-RPC transport.
+ */
+type SolanaHttpOptions = {
+    fetch?: SolanaRpcHttpTransport | undefined;
+};
+/** Stores an HTTP endpoint or custom JSON-RPC function without contacting Solana. */
+type SolanaTransport = {
+    type: 'http';
+    url: string;
+    fetch?: SolanaRpcHttpTransport | undefined;
+} | {
+    type: 'custom';
+    request: SolanaRequest;
+};
+/** Selects whether a Wallet Standard account or application-held key authorizes transactions. */
+type SolanaAccount = {
+    type: 'wallet';
+    wallet: {
+        features: Record<string, unknown>;
+    };
+    account: {
+        address: string;
+        publicKey: Uint8Array;
+    };
+    chain: string;
+} | {
+    type: 'local';
+    secretKeyBytes: Uint8Array;
+};
+/**
+ * Configures Solana network and optional wallet access for one named bridge chain.
+ * @property transport Required public JSON-RPC transport.
+ * @property account Optional Wallet Standard or local-key signing authority.
+ */
+type SolanaClientConfig = {
+    transport: SolanaTransport;
+    account?: SolanaAccount | undefined;
+};
+/**
+ * Exposes account-free Solana operations used by bridge actions.
+ * @property sendTransaction Broadcasts a fully signed wire transaction.
+ */
+type SolanaPublicClient = SolanaRpcClient & {
+    sendTransaction: (signedTransaction: Uint8Array) => Promise<{
+        signature: string;
+    }>;
+};
+/**
+ * Exposes account-authorized Solana operations used by bridge actions.
+ * @property getAddress Resolves the fee payer address.
+ * @property sendTransaction Adds the fee-payer signature and broadcasts or delegates both operations to a wallet.
+ */
+type SolanaWalletClient = {
+    getAddress: () => Promise<string>;
+    sendTransaction: (wireTransaction: Uint8Array) => Promise<{
+        signature: string;
+    }>;
+};
+/**
+ * Holds materialized Solana public and wallet capabilities.
+ * @property family Prevents this client from being used for an EVM or Aleo route stored under the wrong chain identifier.
+ * @property publicClient Read and broadcast capability.
+ * @property walletClient Optional signing capability.
+ */
+type SolanaClient = {
+    family: 'solana';
+    publicClient: SolanaPublicClient;
+    walletClient?: SolanaWalletClient | undefined;
+};
+/**
+ * Defines the Solana JSON-RPC endpoint used when a bridge action reads or submits.
+ *
+ * Creating the transport does not contact the endpoint.
+ *
+ * @param url Solana JSON-RPC endpoint contacted by the resulting client.
+ * @param options Optional Fetch API implementation. Defaults to `globalThis.fetch` when the client is created.
+ * @returns Deferred HTTP configuration accepted by `createSolanaClient`.
+ * @example const transport = solanaHttp('https://api.mainnet-beta.solana.com')
+ */
+declare function solanaHttp(url: string, options?: SolanaHttpOptions): SolanaTransport;
+/**
+ * Defines Solana network access through an application-supplied JSON-RPC function.
+ *
+ * Creating the transport does not call the request function.
+ *
+ * @param request Function that sends JSON-RPC methods when a bridge action needs network access.
+ * @returns Deferred custom transport configuration accepted by `createSolanaClient`.
+ * @example const transport = solanaCustom((method, params) => rpc.request(method, params))
+ */
+declare function solanaCustom(request: SolanaRequest): SolanaTransport;
+/**
+ * Selects a Wallet Standard account to authorize Solana bridge transactions.
+ *
+ * The wallet retains custody of the account and controls signing and broadcast.
+ * This helper does not connect to the wallet or request a signature.
+ *
+ * @param params Wallet, selected account, and Wallet Standard chain identifier used for later authorization.
+ * @returns Deferred wallet configuration accepted by `createSolanaClient`.
+ * @example const account = solanaWallet({ wallet, account: wallet.accounts[0], chain: 'solana:mainnet' })
+ */
+declare function solanaWallet(params: Omit<Extract<SolanaAccount, {
+    type: 'wallet';
+}>, 'type'>): SolanaAccount;
+/**
+ * Selects an application-held Solana keypair for unattended bridge transactions.
+ *
+ * The keypair signs on the caller's device or server. This helper copies the
+ * key bytes but does not contact Solana or submit a transaction; the application
+ * remains responsible for keeping the key secret.
+ *
+ * @param secretKeyBytes Secret Solana CLI-format 64-byte keypair held by the application.
+ * @returns Deferred local signing configuration accepted by `createSolanaClient`.
+ * @throws BridgeError When the key is not exactly 64 bytes.
+ * @example const account = solanaKeyPair(secretKeyBytes)
+ */
+declare function solanaKeyPair(secretKeyBytes: Uint8Array): SolanaAccount;
+/**
+ * Creates the Solana client used to read bridge state and optionally authorize transactions.
+ *
+ * Construction wires the transport and optional account without making an RPC
+ * request. Read-only actions need only the transport; fund-moving actions also
+ * require a Wallet Standard account or local keypair.
+ *
+ * @param config Solana network access and optional wallet authorization supplied by the application.
+ * @returns Solana read, broadcast, and optional wallet capabilities used by bridge actions.
+ * @throws BridgeError When the transport is absent.
+ * @example const client = createSolanaClient({ transport: solanaHttp(rpcUrl), account: solanaKeyPair(key) })
+ */
+declare function createSolanaClient(config: SolanaClientConfig): SolanaClient;
+
+export { type AleoMintMode as A, type BridgeRegistry as B, type ProtocolBridgeChain as C, DEFAULT_SOLANA_RPC_URL as D, type ExecuteSolanaHyperlaneTransferParameters as E, type ProtocolBridgeRoute as F, type GetAssetsParameters as G, type SolanaAccount as H, type SolanaClientConfig as I, type SolanaHttpOptions as J, type SolanaHyperlaneRouteMetadata as K, type SolanaPublicClient as L, type SolanaRequest as M, type SolanaTransport as N, createSolanaClient as O, type PrepareParameters as P, type QuoteSolanaHyperlaneTransferParameters as Q, solanaCustom as R, type SolanaClient as S, solanaHttp as T, solanaKeyPair as U, solanaWallet as V, type SolanaRpcClient as W, createSolanaRpcClient as X, type BridgeReceipt as a, type BridgeProgress as b, type BridgePlan as c, type BridgeCheckpoint as d, type SolanaHyperlaneTransferQuote as e, type SolanaWalletClient as f, type SolanaHyperlaneTransferExecution as g, type BridgeEnvironment as h, type AleoPrivacyCapability as i, type AleoPrivacyKind as j, type BridgeAssetKind as k, type BridgeAssetLocator as l, type BridgeChainFamily as m, type BridgeEndpoint as n, type BridgeExecutionStep as o, type BridgeExecutionStepKind as p, type BridgeFee as q, type BridgeIntent as r, type BridgeNextAction as s, type BridgeProgressNext as t, type BridgeProtocol as u, type BridgeRouteAvailability as v, type BridgeStatus as w, type BridgeStepExecutor as x, type GetRoutesParameters as y, type ProtocolBridgeAsset as z };