@usearete/adapter-web3js 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arete
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,123 @@
+# @usearete/adapter-web3js
+
+An Arete [`WalletAdapter`](https://www.npmjs.com/package/@usearete/sdk) backed by [`@solana/web3.js`](https://github.com/solana-labs/solana-web3.js).
+
+The adapter compiles static-key v0 transactions, signs once, submits once, and confirms without rebuilding or resubmitting. It also supports unsigned fee estimation and simulation for Arete operation inspection.
+
+See the [transaction guide](../../../docs/src/content/docs/using-stacks/transactions.mdx)
+for complete application setup, scopes, failure handling, and troubleshooting.
+
+`transport: 'auto'` uses the connected Arete client's authenticated transaction transport per invocation. Standalone auto mode uses `connection` when provided. Use `transport: 'direct'` to require direct Solana RPC, or pass a `TransactionTransport` object. A resolved Arete operation never falls back to direct RPC after an error.
+
+```ts
+const wallet = createWalletAdapter({ signer, transport: 'auto' })
+const client = await Arete.connect(stack, { wallet })
+await client.transaction(instructions)
+```
+
+## Install
+
+```bash
+npm install @usearete/adapter-web3js @solana/web3.js @usearete/sdk
+```
+
+Node.js 18 or newer is supported. ESM and CommonJS entry points are included. Browser builds do not require an ambient `Buffer` global; the package imports its browser-compatible implementation explicitly.
+
+## Node Signer
+
+```ts
+import { Connection, Keypair } from '@solana/web3.js';
+import { Arete } from '@usearete/sdk';
+import { createKeypairWalletAdapter } from '@usearete/adapter-web3js';
+import { MY_STACK } from './generated/my-stack';
+
+const connection = new Connection('https://api.devnet.solana.com', 'confirmed');
+const keypair = Keypair.fromSecretKey(/* secret key bytes */);
+const wallet = createKeypairWalletAdapter({ connection, keypair });
+const client = await Arete.connect(MY_STACK, { wallet });
+
+const { signature, slot } = await client.instructions.buy({
+  amount: 1_000_000n,
+  maxSolCost: 100_000_000n,
+  mint: 'So11111111111111111111111111111111111111112',
+});
+```
+
+Configured `additionalSigners` are used when their addresses are required and are all published through `wallet.signerAddresses`. Per-send signers can be supplied through `send.signers` or `send.additionalSigners`.
+
+## Browser Wallets
+
+`createWalletAdapter` accepts a wallet-adapter-style signer whose `signTransaction` method receives and returns a web3.js `VersionedTransaction`:
+
+```ts
+const wallet = createWalletAdapter({
+  connection,
+  signer: {
+    publicKey,
+    signTransaction,
+    supportedTransactionVersions: walletAdapter.supportedTransactionVersions,
+  },
+});
+```
+
+In a React app using `@solana/wallet-adapter-react`, the `./react` subpath does this bridging for you:
+
+```tsx
+import { useSolanaWalletAdapter } from '@usearete/adapter-web3js/react';
+import { AreteProvider } from '@usearete/react';
+import { APP_STREAM_STACK } from './generated/app-stack';
+
+const publishableKey = import.meta.env.VITE_ARETE_PUBLISHABLE_KEY;
+if (!publishableKey) throw new Error('VITE_ARETE_PUBLISHABLE_KEY is required');
+
+function Shell({ children }) {
+  const wallet = useSolanaWalletAdapter(); // undefined until a wallet connects
+  return (
+    <AreteProvider
+      stack={APP_STREAM_STACK}
+      auth={{ publishableKey }}
+      wallet={wallet}
+    >
+      {children}
+    </AreteProvider>
+  );
+}
+```
+
+Hosted browser access requires the publishable key even when the app is only reading data. A wallet is required for signed operations, not for read-only viewing. `autoConnect` is omitted because its default is `true`; it controls only the initial connection, while `autoReconnect` independently defaults to `true` for recovery after an established connection is lost.
+
+The wallet must be connected, expose a non-null `PublicKey`, and support transaction version `0`. If `supportedTransactionVersions` is `null` or excludes `0`, the adapter rejects before prompting or sending. If that property is omitted, the supplied `signTransaction` implementation is responsible for accepting v0 transactions.
+
+Raw Wallet Standard `solana:signTransaction` features operate on byte-array request and response objects; they do not directly satisfy this interface. Bridge those feature calls to web3.js `VersionedTransaction` serialization/deserialization, or use a wallet-adapter integration that already exposes `signTransaction`.
+
+Address lookup tables are not currently accepted by this adapter. Transactions use a v0 message with static account keys.
+
+## Inspection
+
+Arete can inspect a prepared instruction or single-transaction operation without signing, submission, or a wallet prompt:
+
+```ts
+const prepared = await client.operations.deploy.prepare(params);
+const inspection = await client.inspectOperation(prepared, {
+  commitment: 'confirmed',
+  minContextSlot,
+});
+
+console.log(inspection.transaction.feeLamports);
+console.log(inspection.transaction.logs);
+console.log(inspection.transaction.computeUnitsConsumed);
+console.log(inspection.transaction.contextSlot);
+console.log(inspection.programError);
+```
+
+Inspection compiles an unsigned v0 transaction, calls `getFeeForMessage`, and simulates with signature verification disabled. Arete core enriches simulation failures with the prepared operation's IDL error metadata. Multi-transaction flows are rejected by core rather than partially simulated.
+
+## Failure Outcomes
+
+Adapter failures expose the structured outcome consumed by `getTransactionFailureOutcome`:
+
+- `not-submitted`: build, missing signer, wallet rejection, unsupported v0 wallet, or definite preflight rejection.
+- `submitted-unknown`: a signed transaction may have been submitted, but one status lookup could not prove the requested commitment.
+- `chain-failed`: confirmation or the status lookup reports an on-chain error.
+
+Known signatures and landed slots are preserved. After an uncertain send or confirmation error, the adapter performs one signature-status lookup and never sends the transaction again.

package/dist/index.cjs

@@ -0,0 +1,539 @@
+'use strict';
+
+var bs58 = require('bs58');
+var web3_js = require('@solana/web3.js');
+var sdk = require('@usearete/sdk');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var bs58__default = /*#__PURE__*/_interopDefault(bs58);
+
+/**
+ * @usearete/adapter-web3js
+ *
+ * An Arete WalletAdapter backed by @solana/web3.js. Transactions are compiled
+ * as v0 messages, signed once, submitted once, and then confirmed or
+ * classified without resubmission.
+ */
+function connectionAccountLoader(connection) {
+    return {
+        async getAccount(address) {
+            const account = await connection.getAccountInfo(new web3_js.PublicKey(address), 'confirmed');
+            return account ? { data: new Uint8Array(account.data) } : null;
+        },
+    };
+}
+function toCommitment(level, fallback) {
+    return level ?? fallback;
+}
+function signerAddress(signer) {
+    return signer.publicKey.toBase58();
+}
+function collectRequiredSignerAddresses(instructions, feePayer) {
+    const required = new Set([feePayer.toBase58()]);
+    for (const instruction of instructions) {
+        for (const key of instruction.keys) {
+            if (key.isSigner) {
+                required.add(key.pubkey);
+            }
+        }
+    }
+    return required;
+}
+function indexLocalSigners(signers) {
+    const indexed = new Map();
+    for (const signer of signers) {
+        indexed.set(signerAddress(signer), signer);
+    }
+    return indexed;
+}
+function outcomeMessage(outcome) {
+    if (outcome.status === 'not-submitted') {
+        return `Transaction was not submitted during ${outcome.phase}`;
+    }
+    if (outcome.status === 'submitted-unknown') {
+        return `Transaction ${outcome.signature} was submitted but its status is unknown`;
+    }
+    return outcome.signature
+        ? `Transaction ${outcome.signature} failed on chain`
+        : 'Transaction failed on chain';
+}
+function transactionError(outcome, programError) {
+    const causeMessage = outcome.cause instanceof Error ? outcome.cause.message : undefined;
+    const error = new Error(causeMessage || outcomeMessage(outcome));
+    Object.defineProperties(error, {
+        name: { value: 'TransactionExecutionError', configurable: true },
+        cause: { value: outcome.cause, enumerable: true },
+        outcome: { value: outcome, enumerable: true },
+        signature: {
+            value: 'signature' in outcome ? outcome.signature : undefined,
+            enumerable: true,
+        },
+        slot: {
+            value: 'slot' in outcome ? outcome.slot : undefined,
+            enumerable: true,
+        },
+        programError: { value: programError, enumerable: true },
+    });
+    return error;
+}
+function customErrorCode(value, seen = new Set()) {
+    if (typeof value === 'string') {
+        const match = /custom program error:\s*0x([\da-f]+)/i.exec(value);
+        return match?.[1] ? Number.parseInt(match[1], 16) : undefined;
+    }
+    if (typeof value !== 'object' || value === null || seen.has(value)) {
+        return undefined;
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const code = customErrorCode(item, seen);
+            if (code !== undefined) {
+                return code;
+            }
+        }
+        return undefined;
+    }
+    const candidate = value;
+    if (Array.isArray(candidate.InstructionError)) {
+        const detail = candidate.InstructionError[1];
+        if (typeof detail === 'object' && detail !== null) {
+            const code = detail.Custom;
+            if (typeof code === 'number') {
+                return code;
+            }
+        }
+    }
+    if (typeof candidate.code === 'number') {
+        return candidate.code;
+    }
+    for (const key of [
+        'cause',
+        'error',
+        'err',
+        'value',
+        'data',
+        'message',
+        'transactionMessage',
+        'transactionLogs',
+        'logs',
+    ]) {
+        const code = customErrorCode(candidate[key], seen);
+        if (code !== undefined) {
+            return code;
+        }
+    }
+    return undefined;
+}
+function parseProgramError(error) {
+    const code = customErrorCode(error);
+    return code === undefined
+        ? undefined
+        : {
+            code,
+            name: `CustomError${code}`,
+            message: `Unknown error with code ${code}`,
+        };
+}
+function signatureFromTransaction(transaction) {
+    const signature = transaction.signatures[0];
+    if (!signature || signature.every((byte) => byte === 0)) {
+        return undefined;
+    }
+    return bs58__default.default.encode(signature);
+}
+function hasAllRequiredSignatures(transaction) {
+    const required = transaction.message.header.numRequiredSignatures;
+    return transaction.signatures
+        .slice(0, required)
+        .every((signature) => signature.some((byte) => byte !== 0));
+}
+function commitmentRank(commitment) {
+    if (commitment === 'finalized' || commitment === 'max' || commitment === 'root') {
+        return 2;
+    }
+    if (commitment === 'confirmed'
+        || commitment === 'single'
+        || commitment === 'singleGossip') {
+        return 1;
+    }
+    return 0;
+}
+function statusRank(status) {
+    if (status.confirmationStatus === 'finalized' || status.confirmations === null) {
+        return 2;
+    }
+    if (status.confirmationStatus === 'confirmed' || (status.confirmations ?? 0) > 0) {
+        return 1;
+    }
+    return 0;
+}
+function encodeBase64(bytes) {
+    const bufferCtor = globalThis.Buffer;
+    if (bufferCtor)
+        return bufferCtor.from(bytes).toString('base64');
+    let binary = '';
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary);
+}
+function resolveTransport(selection, connection, context) {
+    if (typeof selection === 'object')
+        return { kind: 'arete', transport: selection };
+    if (selection === 'direct') {
+        if (!connection)
+            throw new Error('Web3.js direct transaction transport requires a Connection');
+        return { kind: 'direct', connection };
+    }
+    if (context?.transactionTransport)
+        return { kind: 'arete', transport: context.transactionTransport };
+    if (connection)
+        return { kind: 'direct', connection };
+    throw new Error('No transaction transport is available; connect through Arete or configure direct RPC');
+}
+async function pollAreteStatus(transport, signature, commitment, lastValidBlockHeight, options) {
+    const timeoutMs = options?.confirmationTimeoutMs ?? 60000;
+    const intervalMs = options?.statusPollIntervalMs ?? 500;
+    const deadline = Date.now() + timeoutMs;
+    let emptyStatusPolls = 0;
+    while (Date.now() <= deadline) {
+        const status = await transport.getSignatureStatus(signature, {
+            commitment: commitment,
+            searchTransactionHistory: true,
+        });
+        if (status?.err) {
+            throw transactionError({
+                status: 'chain-failed', phase: 'chain', signature,
+                slot: status.slot === null ? undefined : Number(status.slot),
+                programError: parseProgramError(status.err), cause: status.err,
+            });
+        }
+        if (status && commitmentRank(status.confirmationStatus) >= commitmentRank(commitment)) {
+            return { signature, slot: status.slot === null ? undefined : Number(status.slot) };
+        }
+        if (await transport.getBlockHeight({ commitment: commitment }) > lastValidBlockHeight) {
+            throw transactionError({
+                status: 'submitted-unknown', phase: 'confirmation', signature,
+                slot: status?.slot === null ? undefined : Number(status?.slot),
+                cause: new Error('Transaction blockhash expired before confirmation'),
+            });
+        }
+        emptyStatusPolls = status ? 0 : emptyStatusPolls + 1;
+        const delayMs = Math.min(intervalMs * (2 ** Math.min(emptyStatusPolls, 3)), 4000);
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+    throw transactionError({
+        status: 'submitted-unknown', phase: 'confirmation', signature,
+        cause: new Error('Transaction confirmation timed out'),
+    });
+}
+async function resolveUncertainSubmission(connection, signature, commitment, phase, cause) {
+    let status = null;
+    try {
+        const response = await connection.getSignatureStatuses([signature], { searchTransactionHistory: true });
+        status = response.value[0] ?? null;
+    }
+    catch {
+        // The original submission/confirmation error remains the useful cause.
+    }
+    if (status?.err) {
+        throw transactionError({
+            status: 'chain-failed',
+            phase: 'chain',
+            signature,
+            slot: status.slot,
+            programError: parseProgramError(status.err),
+            cause,
+        });
+    }
+    if (status && statusRank(status) >= commitmentRank(commitment)) {
+        return { signature, slot: status.slot };
+    }
+    throw transactionError({
+        status: 'submitted-unknown',
+        phase,
+        signature,
+        slot: status?.slot,
+        cause,
+    });
+}
+/** Convert an Arete BuiltInstruction to a web3.js TransactionInstruction. */
+function toTransactionInstruction(ix) {
+    return new web3_js.TransactionInstruction({
+        programId: new web3_js.PublicKey(ix.programId),
+        keys: ix.keys.map((key) => ({
+            pubkey: new web3_js.PublicKey(key.pubkey),
+            isSigner: key.isSigner,
+            isWritable: key.isWritable,
+        })),
+        // web3.js types this field as Buffer, but its transaction compiler consumes
+        // Uint8Array. Avoid importing the Node `buffer` builtin into browser apps.
+        data: Uint8Array.from(ix.data),
+    });
+}
+/** Convert a web3.js TransactionInstruction to an Arete BuiltInstruction. */
+function fromTransactionInstruction(ix) {
+    return {
+        programId: ix.programId.toBase58(),
+        keys: ix.keys.map((key) => ({
+            pubkey: key.pubkey.toBase58(),
+            isSigner: key.isSigner,
+            isWritable: key.isWritable,
+        })),
+        data: new Uint8Array(ix.data),
+    };
+}
+/** Create a WalletAdapter from a connection and a v0-capable signer. */
+function createWalletAdapter(config) {
+    const { signer } = config;
+    const configuredLocalSigners = config.additionalSigners ?? [];
+    const fallbackCommitment = config.defaultCommitment ?? 'confirmed';
+    const signerAddresses = [
+        signer.publicKey.toBase58(),
+        ...configuredLocalSigners.map(signerAddress),
+    ];
+    return {
+        publicKey: signer.publicKey.toBase58(),
+        signerAddresses: [...new Set(signerAddresses)],
+        async inspectTransaction(instructions, options, context) {
+            if (instructions.length === 0) {
+                throw new Error('inspectTransaction requires at least one instruction');
+            }
+            const commitment = options?.commitment ?? fallbackCommitment;
+            const feePayer = options?.feePayer ?? signer.publicKey;
+            const resolved = resolveTransport(config.transport, config.connection, context);
+            if (resolved.kind === 'arete') {
+                const latest = await resolved.transport.getLatestBlockhash({
+                    commitment: commitment,
+                    minContextSlot: options?.minContextSlot === undefined ? undefined : BigInt(options.minContextSlot),
+                });
+                const message = new web3_js.TransactionMessage({
+                    payerKey: feePayer,
+                    recentBlockhash: latest.blockhash,
+                    instructions: instructions.map(toTransactionInstruction),
+                }).compileToV0Message();
+                const transaction = new web3_js.VersionedTransaction(message);
+                const [fee, simulation] = await Promise.all([
+                    resolved.transport.getFeeForMessage(encodeBase64(message.serialize()), {
+                        commitment: commitment,
+                        minContextSlot: options?.minContextSlot === undefined ? undefined : BigInt(options.minContextSlot),
+                    }),
+                    resolved.transport.simulateTransaction(encodeBase64(transaction.serialize()), {
+                        commitment: commitment,
+                        minContextSlot: options?.minContextSlot === undefined ? undefined : BigInt(options.minContextSlot),
+                        accounts: options?.accounts,
+                        innerInstructions: options?.innerInstructions,
+                    }),
+                ]);
+                return {
+                    feeLamports: fee.feeLamports === null ? undefined : Number(fee.feeLamports),
+                    feeContextSlot: Number(fee.contextSlot), logs: simulation.logs ?? undefined,
+                    computeUnitsConsumed: simulation.unitsConsumed === undefined ? undefined : Number(simulation.unitsConsumed),
+                    contextSlot: Number(simulation.contextSlot), error: simulation.err ?? undefined,
+                    programError: parseProgramError(simulation.err),
+                };
+            }
+            const connection = resolved.connection;
+            const { blockhash } = await connection.getLatestBlockhash(commitment);
+            const message = new web3_js.TransactionMessage({
+                payerKey: feePayer,
+                recentBlockhash: blockhash,
+                instructions: instructions.map(toTransactionInstruction),
+            }).compileToV0Message();
+            const transaction = new web3_js.VersionedTransaction(message);
+            const [fee, simulation] = await Promise.all([
+                connection.getFeeForMessage(message, commitment),
+                connection.simulateTransaction(transaction, {
+                    commitment,
+                    sigVerify: false,
+                    replaceRecentBlockhash: false,
+                    minContextSlot: options?.minContextSlot,
+                    innerInstructions: options?.innerInstructions,
+                    accounts: options?.accounts
+                        ? { encoding: 'base64', addresses: [...options.accounts] }
+                        : undefined,
+                }),
+            ]);
+            return {
+                feeLamports: fee.value ?? undefined,
+                feeContextSlot: fee.context.slot,
+                logs: simulation.value.logs ?? undefined,
+                computeUnitsConsumed: simulation.value.unitsConsumed,
+                contextSlot: simulation.context.slot,
+                error: simulation.value.err ?? undefined,
+                programError: parseProgramError(simulation.value.err),
+            };
+        },
+        async signAndSend(instructions, options, context) {
+            const sendOptions = options;
+            let transaction;
+            let blockhash;
+            let lastValidBlockHeight;
+            let requiredSignerAddresses;
+            let localSigners;
+            const commitment = toCommitment(options?.confirmationLevel, fallbackCommitment);
+            let resolved;
+            try {
+                resolved = resolveTransport(config.transport, config.connection, context);
+            }
+            catch (cause) {
+                throw transactionError({ status: 'not-submitted', phase: 'build', cause });
+            }
+            const feePayer = sendOptions?.feePayer ?? signer;
+            const primarySignerAddress = signerAddress(signer);
+            try {
+                if (instructions.length === 0) {
+                    throw new Error('signAndSend requires at least one instruction');
+                }
+                requiredSignerAddresses = collectRequiredSignerAddresses(instructions, feePayer.publicKey);
+                const localSignerMap = indexLocalSigners([
+                    ...configuredLocalSigners,
+                    ...(sendOptions?.signers ?? []),
+                    ...(sendOptions?.additionalSigners ?? []),
+                    ...(sendOptions?.feePayer ? [sendOptions.feePayer] : []),
+                ]);
+                const missingSignerAddresses = [...requiredSignerAddresses].filter((address) => address !== primarySignerAddress && !localSignerMap.has(address));
+                if (missingSignerAddresses.length > 0) {
+                    throw new Error(`Missing signer(s) for transaction: ${missingSignerAddresses.join(', ')}`);
+                }
+                localSigners = [...requiredSignerAddresses]
+                    .filter((address) => address !== primarySignerAddress)
+                    .map((address) => localSignerMap.get(address))
+                    .filter((candidate, index, all) => all.indexOf(candidate) === index);
+                const latestBlockhash = resolved.kind === 'arete'
+                    ? await resolved.transport.getLatestBlockhash({ commitment: commitment })
+                    : await resolved.connection.getLatestBlockhash(commitment);
+                blockhash = latestBlockhash.blockhash;
+                lastValidBlockHeight = Number(latestBlockhash.lastValidBlockHeight);
+                const message = new web3_js.TransactionMessage({
+                    payerKey: feePayer.publicKey,
+                    recentBlockhash: blockhash,
+                    instructions: instructions.map(toTransactionInstruction),
+                }).compileToV0Message();
+                transaction = new web3_js.VersionedTransaction(message);
+            }
+            catch (cause) {
+                throw transactionError({ status: 'not-submitted', phase: 'build', cause });
+            }
+            try {
+                if (localSigners.length > 0) {
+                    transaction.sign(localSigners);
+                }
+                if (requiredSignerAddresses.has(primarySignerAddress)) {
+                    const supportedVersions = signer.supportedTransactionVersions;
+                    if (supportedVersions === null || (supportedVersions && !supportedVersions.has(0))) {
+                        throw new Error('The configured wallet does not support v0 VersionedTransaction signing');
+                    }
+                    const signed = await signer.signTransaction(transaction);
+                    if (!signed || typeof signed.serialize !== 'function') {
+                        throw new Error('The configured wallet did not return a signed v0 VersionedTransaction');
+                    }
+                    // Wallet adapters can use a different web3.js module instance, making
+                    // instanceof checks reject otherwise valid signed transactions.
+                    transaction = web3_js.VersionedTransaction.deserialize(signed.serialize());
+                }
+                if (!hasAllRequiredSignatures(transaction)) {
+                    throw new Error('The configured signers did not provide every required signature');
+                }
+            }
+            catch (cause) {
+                throw transactionError({ status: 'not-submitted', phase: 'wallet', cause });
+            }
+            const localSignature = signatureFromTransaction(transaction);
+            if (resolved.kind === 'arete') {
+                let signature;
+                try {
+                    const sent = await resolved.transport.sendTransaction(encodeBase64(transaction.serialize()), {
+                        skipPreflight: options?.skipPreflight ?? false,
+                        preflightCommitment: commitment,
+                    });
+                    signature = sent.signature;
+                }
+                catch (cause) {
+                    if (cause instanceof sdk.TransactionTransportError && cause.submissionState === 'not_submitted') {
+                        throw transactionError({ status: 'not-submitted', phase: 'send', cause });
+                    }
+                    throw transactionError({
+                        status: 'submitted-unknown', phase: 'send',
+                        signature: cause instanceof sdk.TransactionTransportError && cause.signature
+                            ? cause.signature : localSignature,
+                        cause,
+                    });
+                }
+                try {
+                    return await pollAreteStatus(resolved.transport, signature, commitment, BigInt(lastValidBlockHeight), options);
+                }
+                catch (cause) {
+                    if (typeof cause === 'object' && cause !== null && 'outcome' in cause)
+                        throw cause;
+                    throw transactionError({
+                        status: 'submitted-unknown', phase: 'confirmation', signature, cause,
+                    });
+                }
+            }
+            const connection = resolved.connection;
+            let signature;
+            try {
+                signature = await connection.sendRawTransaction(transaction.serialize(), {
+                    skipPreflight: options?.skipPreflight ?? false,
+                    preflightCommitment: commitment,
+                });
+            }
+            catch (cause) {
+                if (cause instanceof web3_js.SendTransactionError) {
+                    throw transactionError({ status: 'not-submitted', phase: 'send', cause }, parseProgramError(cause));
+                }
+                return resolveUncertainSubmission(connection, localSignature, commitment, 'send', cause);
+            }
+            try {
+                const confirmation = await connection.confirmTransaction({ signature, blockhash, lastValidBlockHeight }, commitment);
+                if (confirmation.value.err) {
+                    throw transactionError({
+                        status: 'chain-failed',
+                        phase: 'chain',
+                        signature,
+                        slot: confirmation.context.slot,
+                        programError: parseProgramError(confirmation.value.err),
+                        cause: confirmation.value.err,
+                    });
+                }
+                return { signature, slot: confirmation.context.slot };
+            }
+            catch (cause) {
+                if (typeof cause === 'object'
+                    && cause !== null
+                    && 'outcome' in cause
+                    && cause.outcome?.status === 'chain-failed') {
+                    throw cause;
+                }
+                return resolveUncertainSubmission(connection, signature, commitment, 'confirmation', cause);
+            }
+        },
+    };
+}
+/** Create a WalletAdapter backed by a local Keypair. */
+function createKeypairWalletAdapter(config) {
+    const { connection, transport, keypair, additionalSigners, defaultCommitment } = config;
+    return createWalletAdapter({
+        connection,
+        transport,
+        additionalSigners,
+        defaultCommitment,
+        signer: {
+            publicKey: keypair.publicKey,
+            supportedTransactionVersions: new Set([0]),
+            async signTransaction(tx) {
+                tx.sign([keypair]);
+                return tx;
+            },
+        },
+    });
+}
+
+exports.connectionAccountLoader = connectionAccountLoader;
+exports.createKeypairWalletAdapter = createKeypairWalletAdapter;
+exports.createWalletAdapter = createWalletAdapter;
+exports.fromTransactionInstruction = fromTransactionInstruction;
+exports.toTransactionInstruction = toTransactionInstruction;
+//# sourceMappingURL=index.cjs.map