@solana/client 1.0.0 → 1.1.1

package/dist/index.browser.cjs

@@ -2,9 +2,11 @@
 
 var kit = require('@solana/kit');
 var transactionConfirmation = require('@solana/transaction-confirmation');
-var codecsStrings = require('@solana/codecs-strings');
+var addressLookupTable = require('@solana-program/address-lookup-table');
 var system = require('@solana-program/system');
+var codecsStrings = require('@solana/codecs-strings');
 var token = require('@solana-program/token');
+var stake = require('@solana-program/stake');
 var computeBudget = require('@solana-program/compute-budget');
 var vanilla = require('zustand/vanilla');
 var app = require('@wallet-standard/app');
@@ -32,6 +34,18 @@ function fetchBalance(client, params) {
   return client.actions.fetchBalance(params.address, params.commitment);
 }
 __name(fetchBalance, "fetchBalance");
+function fetchLookupTable(client, params) {
+  return client.actions.fetchLookupTable(params.address, params.commitment);
+}
+__name(fetchLookupTable, "fetchLookupTable");
+function fetchLookupTables(client, params) {
+  return client.actions.fetchLookupTables(params.addresses, params.commitment);
+}
+__name(fetchLookupTables, "fetchLookupTables");
+function fetchNonceAccount(client, params) {
+  return client.actions.fetchNonceAccount(params.address, params.commitment);
+}
+__name(fetchNonceAccount, "fetchNonceAccount");
 function requestAirdrop(client, params) {
   return client.actions.requestAirdrop(params.address, params.lamports);
 }
@@ -379,6 +393,7 @@ function updateState(store, update) {
 __name(updateState, "updateState");
 function createActions({ connectors, logger: inputLogger, runtime, store }) {
   const logger = inputLogger ?? createLogger();
+  let walletEventsCleanup;
   function getCommitment(commitment) {
     return commitment ?? store.getState().cluster.commitment;
   }
@@ -451,6 +466,8 @@ function createActions({ connectors, logger: inputLogger, runtime, store }) {
   }
   __name(setCluster2, "setCluster");
   async function connectWallet2(connectorId, options = {}) {
+    walletEventsCleanup?.();
+    walletEventsCleanup = void 0;
     const connector = connectors.get(connectorId);
     if (!connector) {
       throw new Error(`No wallet connector registered for id "${connectorId}".`);
@@ -458,7 +475,7 @@ function createActions({ connectors, logger: inputLogger, runtime, store }) {
     if (!connector.isSupported()) {
       throw new Error(`Wallet connector "${connectorId}" is not supported in this environment.`);
     }
-    const autoConnectPreference = options.autoConnect ?? true;
+    const autoConnectPreference = options.autoConnect ?? false;
     store.setState((state) => ({
       ...state,
       lastUpdatedAt: now(),
@@ -471,6 +488,15 @@ function createActions({ connectors, logger: inputLogger, runtime, store }) {
         lastUpdatedAt: now(),
         wallet: { autoConnect: autoConnectPreference, connectorId, session, status: "connected" }
       }));
+      if (session.onAccountsChanged) {
+        walletEventsCleanup = session.onAccountsChanged((accounts) => {
+          if (accounts.length === 0) {
+            walletEventsCleanup?.();
+            walletEventsCleanup = void 0;
+            void disconnectWallet3();
+          }
+        });
+      }
       logger({
         data: { address: session.account.address.toString(), connectorId },
         level: "info",
@@ -496,6 +522,8 @@ function createActions({ connectors, logger: inputLogger, runtime, store }) {
     if (wallet.status === "disconnected") {
       return;
     }
+    walletEventsCleanup?.();
+    walletEventsCleanup = void 0;
     try {
       if (wallet.status === "connected") {
         await wallet.session.disconnect();
@@ -514,14 +542,14 @@ function createActions({ connectors, logger: inputLogger, runtime, store }) {
     }
   }
   __name(disconnectWallet3, "disconnectWallet");
-  async function fetchBalance2(address4, commitment) {
-    const key = address4.toString();
+  async function fetchBalance2(address5, commitment) {
+    const key = address5.toString();
     store.setState((state) => ({
       ...state,
       accounts: {
         ...state.accounts,
         [key]: {
-          address: address4,
+          address: address5,
           data: state.accounts[key]?.data,
           error: void 0,
           fetching: true,
@@ -533,14 +561,14 @@ function createActions({ connectors, logger: inputLogger, runtime, store }) {
       lastUpdatedAt: now()
     }));
     try {
-      const response = await runtime.rpc.getBalance(address4, { commitment: getCommitment(commitment) }).send({ abortSignal: AbortSignal.timeout(1e4) });
+      const response = await runtime.rpc.getBalance(address5, { commitment: getCommitment(commitment) }).send({ abortSignal: AbortSignal.timeout(1e4) });
       const lamports2 = response.value;
       store.setState((state) => ({
         ...state,
         accounts: {
           ...state.accounts,
           [key]: {
-            address: address4,
+            address: address5,
             data: state.accounts[key]?.data,
             error: void 0,
             fetching: false,
@@ -558,7 +586,7 @@ function createActions({ connectors, logger: inputLogger, runtime, store }) {
         accounts: {
           ...state.accounts,
           [key]: {
-            address: address4,
+            address: address5,
             data: state.accounts[key]?.data,
             error,
             fetching: false,
@@ -578,14 +606,14 @@ function createActions({ connectors, logger: inputLogger, runtime, store }) {
     }
   }
   __name(fetchBalance2, "fetchBalance");
-  async function fetchAccount2(address4, commitment) {
-    const key = address4.toString();
+  async function fetchAccount2(address5, commitment) {
+    const key = address5.toString();
     store.setState((state) => ({
       ...state,
       accounts: {
         ...state.accounts,
         [key]: {
-          address: address4,
+          address: address5,
           data: state.accounts[key]?.data,
           error: void 0,
           fetching: true,
@@ -597,7 +625,7 @@ function createActions({ connectors, logger: inputLogger, runtime, store }) {
       lastUpdatedAt: now()
     }));
     try {
-      const response = await runtime.rpc.getAccountInfo(address4, { commitment: getCommitment(commitment), encoding: "base64" }).send({ abortSignal: AbortSignal.timeout(1e4) });
+      const response = await runtime.rpc.getAccountInfo(address5, { commitment: getCommitment(commitment), encoding: "base64" }).send({ abortSignal: AbortSignal.timeout(1e4) });
       const value = response.value;
       const lamports2 = value?.lamports ?? null;
       store.setState((state) => ({
@@ -605,7 +633,7 @@ function createActions({ connectors, logger: inputLogger, runtime, store }) {
         accounts: {
           ...state.accounts,
           [key]: {
-            address: address4,
+            address: address5,
             data: value,
             error: void 0,
             fetching: false,
@@ -623,7 +651,7 @@ function createActions({ connectors, logger: inputLogger, runtime, store }) {
         accounts: {
           ...state.accounts,
           [key]: {
-            address: address4,
+            address: address5,
             data: state.accounts[key]?.data,
             error,
             fetching: false,
@@ -643,14 +671,49 @@ function createActions({ connectors, logger: inputLogger, runtime, store }) {
     }
   }
   __name(fetchAccount2, "fetchAccount");
+  async function fetchLookupTable2(addr, commitment) {
+    const account = await addressLookupTable.fetchAddressLookupTable(runtime.rpc, addr, {
+      commitment: getCommitment(commitment)
+    });
+    const { addresses, authority, deactivationSlot, lastExtendedSlot, lastExtendedSlotStartIndex } = account.data;
+    return {
+      addresses,
+      authority: kit.isSome(authority) ? authority.value : void 0,
+      deactivationSlot,
+      lastExtendedSlot,
+      lastExtendedSlotStartIndex
+    };
+  }
+  __name(fetchLookupTable2, "fetchLookupTable");
+  async function fetchLookupTables2(addresses, commitment) {
+    if (addresses.length === 0) return [];
+    const accounts = await addressLookupTable.fetchAllAddressLookupTable(runtime.rpc, addresses, {
+      commitment: getCommitment(commitment)
+    });
+    return accounts.map(({ data }) => ({
+      addresses: data.addresses,
+      authority: kit.isSome(data.authority) ? data.authority.value : void 0,
+      deactivationSlot: data.deactivationSlot,
+      lastExtendedSlot: data.lastExtendedSlot,
+      lastExtendedSlotStartIndex: data.lastExtendedSlotStartIndex
+    }));
+  }
+  __name(fetchLookupTables2, "fetchLookupTables");
+  async function fetchNonceAccount2(addr, commitment) {
+    const account = await system.fetchNonce(runtime.rpc, addr, {
+      commitment: getCommitment(commitment)
+    });
+    return { authority: account.data.authority, blockhash: account.data.blockhash };
+  }
+  __name(fetchNonceAccount2, "fetchNonceAccount");
   async function sendTransaction2(transaction, commitment) {
     const targetCommitment = getCommitment(commitment);
     const abortController = new AbortController();
-    const signature4 = await runtime.rpc.sendTransaction(kit.getBase64EncodedWireTransaction(transaction), {
+    const signature5 = await runtime.rpc.sendTransaction(kit.getBase64EncodedWireTransaction(transaction), {
       encoding: "base64",
       preflightCommitment: targetCommitment
     }).send({ abortSignal: abortController.signal });
-    const key = signature4.toString();
+    const key = signature5.toString();
     store.setState((state) => ({
       ...state,
       lastUpdatedAt: now(),
@@ -658,7 +721,7 @@ function createActions({ connectors, logger: inputLogger, runtime, store }) {
         ...state.transactions,
         [key]: {
           lastUpdatedAt: now(),
-          signature: signature4,
+          signature: signature5,
           status: "sending"
         }
       }
@@ -686,12 +749,12 @@ function createActions({ connectors, logger: inputLogger, runtime, store }) {
           ...state.transactions,
           [key]: {
             lastUpdatedAt: now(),
-            signature: signature4,
+            signature: signature5,
             status: "confirmed"
           }
         }
       }));
-      return signature4;
+      return signature5;
     } catch (error) {
       store.setState((state) => ({
         ...state,
@@ -701,7 +764,7 @@ function createActions({ connectors, logger: inputLogger, runtime, store }) {
           [key]: {
             error,
             lastUpdatedAt: now(),
-            signature: signature4,
+            signature: signature5,
             status: "failed"
           }
         }
@@ -715,26 +778,26 @@ function createActions({ connectors, logger: inputLogger, runtime, store }) {
     }
   }
   __name(sendTransaction2, "sendTransaction");
-  async function requestAirdrop2(address4, lamports2) {
+  async function requestAirdrop2(address5, lamports2) {
     try {
       const factory = kit.airdropFactory({
         rpc: runtime.rpc,
         rpcSubscriptions: runtime.rpcSubscriptions
       });
-      const signature4 = await factory({
+      const signature5 = await factory({
         commitment: getCommitment("confirmed"),
         lamports: lamports2,
-        recipientAddress: address4
+        recipientAddress: address5
       });
       logger({
-        data: { address: address4.toString(), lamports: lamports2.toString(), signature: signature4 },
+        data: { address: address5.toString(), lamports: lamports2.toString(), signature: signature5 },
         level: "info",
         message: "airdrop requested"
       });
-      return signature4;
+      return signature5;
     } catch (error) {
       logger({
-        data: { address: address4.toString(), lamports: lamports2.toString(), ...formatError(error) },
+        data: { address: address5.toString(), lamports: lamports2.toString(), ...formatError(error) },
         level: "error",
         message: "airdrop request failed"
       });
@@ -747,6 +810,9 @@ function createActions({ connectors, logger: inputLogger, runtime, store }) {
     disconnectWallet: disconnectWallet3,
     fetchAccount: fetchAccount2,
     fetchBalance: fetchBalance2,
+    fetchLookupTable: fetchLookupTable2,
+    fetchLookupTables: fetchLookupTables2,
+    fetchNonceAccount: fetchNonceAccount2,
     requestAirdrop: requestAirdrop2,
     sendTransaction: sendTransaction2,
     setCluster: setCluster2
@@ -1135,11 +1201,11 @@ function isWalletSession(value) {
 __name(isWalletSession, "isWalletSession");
 function createWalletTransactionSigner(session, config = {}) {
   const { commitment } = config;
-  const address4 = session.account.address;
+  const address5 = session.account.address;
   if (session.signTransaction) {
     const signTransaction = session.signTransaction.bind(session);
     const modifyingSigner = Object.freeze({
-      address: address4,
+      address: address5,
       async modifyAndSignTransactions(transactions) {
         const signedTransactions = [];
         for (const transaction of transactions) {
@@ -1147,8 +1213,8 @@ function createWalletTransactionSigner(session, config = {}) {
           const signed = await signTransaction(
             castTransaction
           );
-          const signature4 = signed.signatures[address4];
-          if (!signature4) {
+          const signature5 = signed.signatures[address5];
+          if (!signature5) {
             throw new Error("Wallet did not populate the expected fee payer signature.");
           }
           const mergedTransaction = Object.freeze({
@@ -1167,11 +1233,11 @@ function createWalletTransactionSigner(session, config = {}) {
         const signedTransactions = await this.modifyAndSignTransactions(transactions);
         return Object.freeze(
           signedTransactions.map((signedTransaction) => {
-            const signature4 = signedTransaction.signatures[address4];
-            if (!signature4) {
+            const signature5 = signedTransaction.signatures[address5];
+            if (!signature5) {
               throw new Error("Expected signer to produce a signature for the provided address.");
             }
-            return Object.freeze({ [address4]: signature4 });
+            return Object.freeze({ [address5]: signature5 });
           })
         );
       }
@@ -1185,7 +1251,7 @@ function createWalletTransactionSigner(session, config = {}) {
     const base58Encoder = codecsStrings.getBase58Encoder();
     const sendTransaction2 = session.sendTransaction.bind(session);
     const sendingSigner = Object.freeze({
-      address: address4,
+      address: address5,
       async signAndSendTransactions(transactions) {
         const signatures = [];
         for (const transaction of transactions) {
@@ -1524,6 +1590,310 @@ function createSplTokenHelper(runtime, config) {
   };
 }
 __name(createSplTokenHelper, "createSplTokenHelper");
+var STAKE_PROGRAM_ID = "Stake11111111111111111111111111111111111111";
+var SYSVAR_CLOCK = "SysvarC1ock11111111111111111111111111111111";
+var SYSVAR_STAKE_HISTORY = "SysvarStakeHistory1111111111111111111111111";
+var UNUSED_STAKE_CONFIG_ACC = "StakeConfig11111111111111111111111111111111";
+var STAKE_STATE_LEN = 200;
+function ensureAddress3(value) {
+  return typeof value === "string" ? kit.address(value) : value;
+}
+__name(ensureAddress3, "ensureAddress");
+async function resolveLifetime3(runtime, commitment, fallback) {
+  if (fallback) {
+    return fallback;
+  }
+  const { value } = await runtime.rpc.getLatestBlockhash({ commitment }).send();
+  return value;
+}
+__name(resolveLifetime3, "resolveLifetime");
+function resolveSigner3(authority, commitment) {
+  if (isWalletSession(authority)) {
+    const { signer, mode } = createWalletTransactionSigner(authority, { commitment });
+    return { mode, signer };
+  }
+  return { mode: resolveSignerMode(authority), signer: authority };
+}
+__name(resolveSigner3, "resolveSigner");
+function toLamportAmount2(input) {
+  return lamportsMath.fromLamports(input);
+}
+__name(toLamportAmount2, "toLamportAmount");
+function createStakeHelper(runtime) {
+  async function prepareStake(config) {
+    const commitment = config.commitment;
+    const lifetime = await resolveLifetime3(runtime, commitment, config.lifetime);
+    const { signer, mode } = resolveSigner3(config.authority, commitment);
+    const validatorAddress = ensureAddress3(config.validatorId);
+    const amount = toLamportAmount2(config.amount);
+    const rentExempt = await runtime.rpc.getMinimumBalanceForRentExemption(BigInt(STAKE_STATE_LEN)).send();
+    const totalLamports = rentExempt + amount;
+    const stakeAccount = await kit.generateKeyPairSigner();
+    const createIx = system.getCreateAccountInstruction({
+      payer: signer,
+      newAccount: stakeAccount,
+      lamports: totalLamports,
+      space: BigInt(STAKE_STATE_LEN),
+      programAddress: STAKE_PROGRAM_ID
+    });
+    const initializeIx = stake.getInitializeInstruction({
+      stake: stakeAccount.address,
+      arg0: {
+        staker: signer.address,
+        withdrawer: signer.address
+      },
+      arg1: {
+        unixTimestamp: 0n,
+        epoch: 0n,
+        custodian: signer.address
+      }
+    });
+    const delegateIx = stake.getDelegateStakeInstruction({
+      stake: stakeAccount.address,
+      vote: validatorAddress,
+      stakeHistory: SYSVAR_STAKE_HISTORY,
+      unused: UNUSED_STAKE_CONFIG_ACC,
+      stakeAuthority: signer
+    });
+    const message = kit.pipe(
+      kit.createTransactionMessage({ version: config.transactionVersion ?? 0 }),
+      (m) => kit.setTransactionMessageFeePayer(signer.address, m),
+      (m) => kit.setTransactionMessageLifetimeUsingBlockhash(lifetime, m),
+      (m) => kit.appendTransactionMessageInstructions([createIx, initializeIx, delegateIx], m)
+    );
+    return {
+      commitment,
+      lifetime,
+      message,
+      mode,
+      signer,
+      stakeAccount,
+      plan: kit.singleTransactionPlan(message)
+    };
+  }
+  __name(prepareStake, "prepareStake");
+  async function sendPreparedStake(prepared, options = {}) {
+    if (prepared.mode === "send" && kit.isTransactionSendingSigner(prepared.signer)) {
+      const signatureBytes2 = await kit.signAndSendTransactionMessageWithSigners(prepared.message, {
+        abortSignal: options.abortSignal,
+        minContextSlot: options.minContextSlot
+      });
+      const base58Decoder2 = codecsStrings.getBase58Decoder();
+      return kit.signature(base58Decoder2.decode(signatureBytes2));
+    }
+    const commitment = options.commitment ?? prepared.commitment;
+    const maxRetries = options.maxRetries === void 0 ? void 0 : typeof options.maxRetries === "bigint" ? options.maxRetries : BigInt(options.maxRetries);
+    let latestSignature = null;
+    const executor = kit.createTransactionPlanExecutor({
+      async executeTransactionMessage(message, config = {}) {
+        const signed = await kit.signTransactionMessageWithSigners(message, {
+          abortSignal: config.abortSignal ?? options.abortSignal,
+          minContextSlot: options.minContextSlot
+        });
+        const wire = kit.getBase64EncodedWireTransaction(signed);
+        const response = await runtime.rpc.sendTransaction(wire, {
+          encoding: "base64",
+          maxRetries,
+          preflightCommitment: commitment,
+          skipPreflight: options.skipPreflight
+        }).send({ abortSignal: config.abortSignal ?? options.abortSignal });
+        latestSignature = kit.signature(response);
+        return { transaction: signed };
+      }
+    });
+    await executor(prepared.plan ?? kit.singleTransactionPlan(prepared.message), { abortSignal: options.abortSignal });
+    if (!latestSignature) {
+      throw new Error("Failed to resolve transaction signature.");
+    }
+    return latestSignature;
+  }
+  __name(sendPreparedStake, "sendPreparedStake");
+  async function sendStake(config, options) {
+    const prepared = await prepareStake(config);
+    return await sendPreparedStake(prepared, options);
+  }
+  __name(sendStake, "sendStake");
+  async function prepareUnstake(config) {
+    const commitment = config.commitment;
+    const lifetime = await resolveLifetime3(runtime, commitment, config.lifetime);
+    const { signer, mode } = resolveSigner3(config.authority, commitment);
+    const stakeAccountAddress = ensureAddress3(config.stakeAccount);
+    const deactivateIx = stake.getDeactivateInstruction({
+      stake: stakeAccountAddress,
+      clockSysvar: SYSVAR_CLOCK,
+      stakeAuthority: signer
+    });
+    const message = kit.pipe(
+      kit.createTransactionMessage({ version: config.transactionVersion ?? 0 }),
+      (m) => kit.setTransactionMessageFeePayer(signer.address, m),
+      (m) => kit.setTransactionMessageLifetimeUsingBlockhash(lifetime, m),
+      (m) => kit.appendTransactionMessageInstructions([deactivateIx], m)
+    );
+    return {
+      commitment,
+      lifetime,
+      message,
+      mode,
+      signer,
+      plan: kit.singleTransactionPlan(message)
+    };
+  }
+  __name(prepareUnstake, "prepareUnstake");
+  async function sendPreparedUnstake(prepared, options = {}) {
+    if (prepared.mode === "send" && kit.isTransactionSendingSigner(prepared.signer)) {
+      const signatureBytes2 = await kit.signAndSendTransactionMessageWithSigners(prepared.message, {
+        abortSignal: options.abortSignal,
+        minContextSlot: options.minContextSlot
+      });
+      const base58Decoder2 = codecsStrings.getBase58Decoder();
+      return kit.signature(base58Decoder2.decode(signatureBytes2));
+    }
+    const commitment = options.commitment ?? prepared.commitment;
+    const maxRetries = options.maxRetries === void 0 ? void 0 : typeof options.maxRetries === "bigint" ? options.maxRetries : BigInt(options.maxRetries);
+    let latestSignature = null;
+    const executor = kit.createTransactionPlanExecutor({
+      async executeTransactionMessage(message, config = {}) {
+        const signed = await kit.signTransactionMessageWithSigners(message, {
+          abortSignal: config.abortSignal ?? options.abortSignal,
+          minContextSlot: options.minContextSlot
+        });
+        const wire = kit.getBase64EncodedWireTransaction(signed);
+        const response = await runtime.rpc.sendTransaction(wire, {
+          encoding: "base64",
+          maxRetries,
+          preflightCommitment: commitment,
+          skipPreflight: options.skipPreflight
+        }).send({ abortSignal: config.abortSignal ?? options.abortSignal });
+        latestSignature = kit.signature(response);
+        return { transaction: signed };
+      }
+    });
+    await executor(prepared.plan);
+    if (!latestSignature) {
+      throw new Error("Failed to resolve transaction signature.");
+    }
+    return latestSignature;
+  }
+  __name(sendPreparedUnstake, "sendPreparedUnstake");
+  async function sendUnstake(config, options) {
+    const prepared = await prepareUnstake(config);
+    return await sendPreparedUnstake(prepared, options);
+  }
+  __name(sendUnstake, "sendUnstake");
+  async function prepareWithdraw(config) {
+    const commitment = config.commitment;
+    const lifetime = await resolveLifetime3(runtime, commitment, config.lifetime);
+    const { signer, mode } = resolveSigner3(config.authority, commitment);
+    const stakeAccountAddress = ensureAddress3(config.stakeAccount);
+    const destinationAddress = ensureAddress3(config.destination);
+    const amount = toLamportAmount2(config.amount);
+    const withdrawIx = stake.getWithdrawInstruction({
+      stake: stakeAccountAddress,
+      recipient: destinationAddress,
+      clockSysvar: SYSVAR_CLOCK,
+      stakeHistory: SYSVAR_STAKE_HISTORY,
+      withdrawAuthority: signer,
+      args: amount
+    });
+    const message = kit.pipe(
+      kit.createTransactionMessage({ version: config.transactionVersion ?? 0 }),
+      (m) => kit.setTransactionMessageFeePayer(signer.address, m),
+      (m) => kit.setTransactionMessageLifetimeUsingBlockhash(lifetime, m),
+      (m) => kit.appendTransactionMessageInstructions([withdrawIx], m)
+    );
+    return {
+      commitment,
+      lifetime,
+      message,
+      mode,
+      signer,
+      plan: kit.singleTransactionPlan(message)
+    };
+  }
+  __name(prepareWithdraw, "prepareWithdraw");
+  async function sendPreparedWithdraw(prepared, options = {}) {
+    if (prepared.mode === "send" && kit.isTransactionSendingSigner(prepared.signer)) {
+      const signatureBytes2 = await kit.signAndSendTransactionMessageWithSigners(prepared.message, {
+        abortSignal: options.abortSignal,
+        minContextSlot: options.minContextSlot
+      });
+      const base58Decoder2 = codecsStrings.getBase58Decoder();
+      return kit.signature(base58Decoder2.decode(signatureBytes2));
+    }
+    const commitment = options.commitment ?? prepared.commitment;
+    const maxRetries = options.maxRetries === void 0 ? void 0 : typeof options.maxRetries === "bigint" ? options.maxRetries : BigInt(options.maxRetries);
+    let latestSignature = null;
+    const executor = kit.createTransactionPlanExecutor({
+      async executeTransactionMessage(message, config = {}) {
+        const signed = await kit.signTransactionMessageWithSigners(message, {
+          abortSignal: config.abortSignal ?? options.abortSignal,
+          minContextSlot: options.minContextSlot
+        });
+        const wire = kit.getBase64EncodedWireTransaction(signed);
+        const response = await runtime.rpc.sendTransaction(wire, {
+          encoding: "base64",
+          maxRetries,
+          preflightCommitment: commitment,
+          skipPreflight: options.skipPreflight
+        }).send({ abortSignal: config.abortSignal ?? options.abortSignal });
+        latestSignature = kit.signature(response);
+        return { transaction: signed };
+      }
+    });
+    await executor(prepared.plan);
+    if (!latestSignature) {
+      throw new Error("Failed to resolve transaction signature.");
+    }
+    return latestSignature;
+  }
+  __name(sendPreparedWithdraw, "sendPreparedWithdraw");
+  async function sendWithdraw(config, options) {
+    const prepared = await prepareWithdraw(config);
+    return await sendPreparedWithdraw(prepared, options);
+  }
+  __name(sendWithdraw, "sendWithdraw");
+  async function getStakeAccounts(wallet, validatorId) {
+    const walletAddress = typeof wallet === "string" ? wallet : String(wallet);
+    const accounts = await runtime.rpc.getProgramAccounts(STAKE_PROGRAM_ID, {
+      encoding: "jsonParsed",
+      filters: [
+        {
+          memcmp: {
+            offset: 44n,
+            bytes: walletAddress,
+            encoding: "base58"
+          }
+        }
+      ]
+    }).send();
+    if (!validatorId) {
+      return accounts;
+    }
+    const validatorIdStr = typeof validatorId === "string" ? validatorId : String(validatorId);
+    return accounts.filter((acc) => {
+      const data = acc.account?.data;
+      if (data && "parsed" in data) {
+        const info = data.parsed?.info;
+        return info?.stake?.delegation?.voter === validatorIdStr;
+      }
+      return false;
+    });
+  }
+  __name(getStakeAccounts, "getStakeAccounts");
+  return {
+    getStakeAccounts,
+    prepareStake,
+    prepareUnstake,
+    prepareWithdraw,
+    sendPreparedStake,
+    sendPreparedUnstake,
+    sendPreparedWithdraw,
+    sendStake,
+    sendUnstake,
+    sendWithdraw
+  };
+}
+__name(createStakeHelper, "createStakeHelper");
 function transactionToBase64(tx) {
   if ("messageBytes" in tx) {
     return kit.getBase64EncodedWireTransaction(tx);
@@ -1676,11 +2046,11 @@ function resolveFeePayerAddress(feePayer, authoritySigner) {
     return { address: feePayer.address, signer: feePayer };
   }
   if (feePayer) {
-    const address4 = toAddress(feePayer);
-    if (authoritySigner && authoritySigner.address === address4) {
-      return { address: address4, signer: authoritySigner };
+    const address5 = toAddress(feePayer);
+    if (authoritySigner && authoritySigner.address === address5) {
+      return { address: address5, signer: authoritySigner };
     }
-    return { address: address4 };
+    return { address: address5 };
   }
   if (!authoritySigner) {
     throw new Error("Unable to resolve authority signer for the fee payer.");
@@ -1932,6 +2302,21 @@ function wrapSplTokenHelper(helper, getFallback, baseCommitment) {
   };
 }
 __name(wrapSplTokenHelper, "wrapSplTokenHelper");
+function wrapStakeHelper(helper, getFallback) {
+  return {
+    getStakeAccounts: helper.getStakeAccounts,
+    prepareStake: /* @__PURE__ */ __name((config) => helper.prepareStake(withDefaultCommitment(config, getFallback)), "prepareStake"),
+    prepareUnstake: /* @__PURE__ */ __name((config) => helper.prepareUnstake(withDefaultCommitment(config, getFallback)), "prepareUnstake"),
+    prepareWithdraw: /* @__PURE__ */ __name((config) => helper.prepareWithdraw(withDefaultCommitment(config, getFallback)), "prepareWithdraw"),
+    sendPreparedStake: helper.sendPreparedStake,
+    sendPreparedUnstake: helper.sendPreparedUnstake,
+    sendPreparedWithdraw: helper.sendPreparedWithdraw,
+    sendStake: /* @__PURE__ */ __name((config, options) => helper.sendStake(withDefaultCommitment(config, getFallback), options), "sendStake"),
+    sendUnstake: /* @__PURE__ */ __name((config, options) => helper.sendUnstake(withDefaultCommitment(config, getFallback), options), "sendUnstake"),
+    sendWithdraw: /* @__PURE__ */ __name((config, options) => helper.sendWithdraw(withDefaultCommitment(config, getFallback), options), "sendWithdraw")
+  };
+}
+__name(wrapStakeHelper, "wrapStakeHelper");
 function normaliseConfigValue(value) {
   if (value === null || value === void 0) {
     return void 0;
@@ -1959,6 +2344,7 @@ function createClientHelpers(runtime, store) {
   const getFallbackCommitment = /* @__PURE__ */ __name(() => store.getState().cluster.commitment, "getFallbackCommitment");
   const splTokenCache = /* @__PURE__ */ new Map();
   let solTransfer;
+  let stake;
   let transaction;
   const getSolTransfer = /* @__PURE__ */ __name(() => {
     if (!solTransfer) {
@@ -1966,6 +2352,12 @@ function createClientHelpers(runtime, store) {
     }
     return solTransfer;
   }, "getSolTransfer");
+  const getStake = /* @__PURE__ */ __name(() => {
+    if (!stake) {
+      stake = wrapStakeHelper(createStakeHelper(runtime), getFallbackCommitment);
+    }
+    return stake;
+  }, "getStake");
   const getTransaction = /* @__PURE__ */ __name(() => {
     if (!transaction) {
       transaction = createTransactionHelper(runtime, getFallbackCommitment);
@@ -1996,6 +2388,9 @@ function createClientHelpers(runtime, store) {
       return getSolTransfer();
     },
     splToken: getSplTokenHelper,
+    get stake() {
+      return getStake();
+    },
     get transaction() {
       return getTransaction();
     },
@@ -2263,6 +2658,9 @@ function createClient(config) {
     splToken: helpers.splToken,
     SplToken: helpers.splToken,
     SplHelper: helpers.splToken,
+    get stake() {
+      return helpers.stake;
+    },
     get transaction() {
       return helpers.transaction;
     },
@@ -2325,25 +2723,38 @@ function createWalletStandardConnector(wallet, options = {}) {
   };
   async function connect(connectionOptions = {}) {
     const connectFeature = wallet.features[features.StandardConnect];
+    const eventsFeature = wallet.features[features.StandardEvents];
     const shouldConnectSilently = Boolean(connectionOptions.autoConnect);
+    const allowInteractiveFallback = connectionOptions.allowInteractiveFallback ?? true;
     let walletAccounts = wallet.accounts;
     if (connectFeature) {
-      const { accounts } = await connectFeature.connect({
-        silent: shouldConnectSilently || void 0
-      });
-      if (accounts.length) {
-        walletAccounts = accounts;
+      const connectWithMode = /* @__PURE__ */ __name(async (silent) => connectFeature.connect({
+        silent
+      }), "connectWithMode");
+      try {
+        const { accounts } = await connectWithMode(shouldConnectSilently);
+        if (accounts.length) {
+          walletAccounts = accounts;
+        }
+      } catch (error) {
+        if (!shouldConnectSilently || !allowInteractiveFallback) {
+          throw error;
+        }
+        const { accounts } = await connectWithMode(false);
+        if (accounts.length) {
+          walletAccounts = accounts;
+        }
       }
     }
-    const primaryAccount = getPrimaryAccount(walletAccounts);
-    const sessionAccount = toSessionAccount(primaryAccount);
+    let currentAccount = getPrimaryAccount(walletAccounts);
+    let sessionAccount = toSessionAccount(currentAccount);
     const signMessageFeature = wallet.features[walletStandardFeatures.SolanaSignMessage];
     const signTransactionFeature = wallet.features[walletStandardFeatures.SolanaSignTransaction];
     const signAndSendFeature = wallet.features[walletStandardFeatures.SolanaSignAndSendTransaction];
-    const resolvedChain = options.defaultChain ?? getChain(primaryAccount);
+    const resolvedChain = options.defaultChain ?? getChain(currentAccount);
     const signMessage = signMessageFeature ? async (message) => {
       const [output] = await signMessageFeature.signMessage({
-        account: primaryAccount,
+        account: currentAccount,
         message
       });
       return output.signature;
@@ -2351,11 +2762,11 @@ function createWalletStandardConnector(wallet, options = {}) {
     const signTransaction = signTransactionFeature ? async (transaction) => {
       const wireBytes = new Uint8Array(transactionEncoder.encode(transaction));
       const request = resolvedChain ? {
-        account: primaryAccount,
+        account: currentAccount,
         chain: resolvedChain,
         transaction: wireBytes
       } : {
-        account: primaryAccount,
+        account: currentAccount,
         transaction: wireBytes
       };
       const [output] = await signTransactionFeature.signTransaction(request);
@@ -2363,9 +2774,9 @@ function createWalletStandardConnector(wallet, options = {}) {
     } : void 0;
     const sendTransaction2 = signAndSendFeature ? async (transaction, config) => {
       const wireBytes = new Uint8Array(transactionEncoder.encode(transaction));
-      const chain = options.defaultChain ?? getChain(primaryAccount) ?? "solana:mainnet-beta";
+      const chain = options.defaultChain ?? getChain(currentAccount) ?? "solana:mainnet-beta";
       const [output] = await signAndSendFeature.signAndSendTransaction({
-        account: primaryAccount,
+        account: currentAccount,
         chain,
         options: {
           commitment: mapCommitment(config?.commitment)
@@ -2375,13 +2786,35 @@ function createWalletStandardConnector(wallet, options = {}) {
       return base58Decoder.decode(output.signature);
     } : void 0;
     async function disconnectSession() {
+      changeUnsubscribe?.();
       await disconnectWallet2(wallet);
     }
     __name(disconnectSession, "disconnectSession");
+    let changeUnsubscribe;
+    const onAccountsChanged = eventsFeature ? (listener) => {
+      const off = eventsFeature.on("change", ({ accounts }) => {
+        if (!accounts) return;
+        if (!accounts.length) {
+          listener([]);
+          return;
+        }
+        currentAccount = accounts[0];
+        sessionAccount = toSessionAccount(currentAccount);
+        listener(accounts.map(toSessionAccount));
+      });
+      return off;
+    } : void 0;
     return {
       account: sessionAccount,
       connector: metadata,
       disconnect: disconnectSession,
+      onAccountsChanged: onAccountsChanged ? (listener) => {
+        changeUnsubscribe = onAccountsChanged(listener);
+        return () => {
+          changeUnsubscribe?.();
+          changeUnsubscribe = void 0;
+        };
+      } : void 0,
       sendTransaction: sendTransaction2,
       signMessage,
       signTransaction
@@ -2596,9 +3029,9 @@ function createSolTransferController(config) {
     const request = ensureAuthority(config2, authorityProvider);
     setState(createAsyncState("loading"));
     try {
-      const signature4 = await helper.sendTransfer(request, options);
-      setState(createAsyncState("success", { data: signature4 }));
-      return signature4;
+      const signature5 = await helper.sendTransfer(request, options);
+      setState(createAsyncState("success", { data: signature5 }));
+      return signature5;
     } catch (error) {
       setState(createAsyncState("error", { error }));
       throw error;
@@ -2668,9 +3101,9 @@ function createSplTransferController(config) {
     );
     setState(createAsyncState("loading"));
     try {
-      const signature4 = await helper.sendTransfer(resolvedConfig, options);
-      setState(createAsyncState("success", { data: signature4 }));
-      return signature4;
+      const signature5 = await helper.sendTransfer(resolvedConfig, options);
+      setState(createAsyncState("success", { data: signature5 }));
+      return signature5;
     } catch (error) {
       setState(createAsyncState("error", { error }));
       throw error;
@@ -2698,6 +3131,172 @@ function createSplTransferController(config) {
 }
 __name(createSplTransferController, "createSplTransferController");
 
+// src/controllers/stakeController.ts
+function ensureAuthority2(input, resolveDefault) {
+  const authority = input.authority ?? resolveDefault?.();
+  if (!authority) {
+    throw new Error("Connect a wallet or supply an `authority` before staking SOL.");
+  }
+  return {
+    ...input,
+    authority
+  };
+}
+__name(ensureAuthority2, "ensureAuthority");
+function ensureUnstakeAuthority(input, resolveDefault) {
+  const authority = input.authority ?? resolveDefault?.();
+  if (!authority) {
+    throw new Error("Connect a wallet or supply an `authority` before unstaking SOL.");
+  }
+  return {
+    ...input,
+    authority
+  };
+}
+__name(ensureUnstakeAuthority, "ensureUnstakeAuthority");
+function ensureWithdrawAuthority(input, resolveDefault) {
+  const authority = input.authority ?? resolveDefault?.();
+  if (!authority) {
+    throw new Error("Connect a wallet or supply an `authority` before withdrawing SOL.");
+  }
+  return {
+    ...input,
+    authority
+  };
+}
+__name(ensureWithdrawAuthority, "ensureWithdrawAuthority");
+function createStakeController(config) {
+  const listeners = /* @__PURE__ */ new Set();
+  const unstakeListeners = /* @__PURE__ */ new Set();
+  const withdrawListeners = /* @__PURE__ */ new Set();
+  const helper = config.helper;
+  const authorityProvider = config.authorityProvider;
+  let state = createInitialAsyncState();
+  let unstakeState = createInitialAsyncState();
+  let withdrawState = createInitialAsyncState();
+  function notify() {
+    for (const listener of listeners) {
+      listener();
+    }
+  }
+  __name(notify, "notify");
+  function notifyUnstake() {
+    for (const listener of unstakeListeners) {
+      listener();
+    }
+  }
+  __name(notifyUnstake, "notifyUnstake");
+  function notifyWithdraw() {
+    for (const listener of withdrawListeners) {
+      listener();
+    }
+  }
+  __name(notifyWithdraw, "notifyWithdraw");
+  function setState(next) {
+    state = next;
+    notify();
+  }
+  __name(setState, "setState");
+  function setUnstakeState(next) {
+    unstakeState = next;
+    notifyUnstake();
+  }
+  __name(setUnstakeState, "setUnstakeState");
+  function setWithdrawState(next) {
+    withdrawState = next;
+    notifyWithdraw();
+  }
+  __name(setWithdrawState, "setWithdrawState");
+  async function stake(config2, options) {
+    const request = ensureAuthority2(config2, authorityProvider);
+    setState(createAsyncState("loading"));
+    try {
+      const signature5 = await helper.sendStake(request, options);
+      setState(createAsyncState("success", { data: signature5 }));
+      return signature5;
+    } catch (error) {
+      setState(createAsyncState("error", { error }));
+      throw error;
+    }
+  }
+  __name(stake, "stake");
+  async function unstake(config2, options) {
+    const request = ensureUnstakeAuthority(config2, authorityProvider);
+    setUnstakeState(createAsyncState("loading"));
+    try {
+      const signature5 = await helper.sendUnstake(request, options);
+      setUnstakeState(createAsyncState("success", { data: signature5 }));
+      return signature5;
+    } catch (error) {
+      setUnstakeState(createAsyncState("error", { error }));
+      throw error;
+    }
+  }
+  __name(unstake, "unstake");
+  async function withdraw(config2, options) {
+    const request = ensureWithdrawAuthority(config2, authorityProvider);
+    setWithdrawState(createAsyncState("loading"));
+    try {
+      const signature5 = await helper.sendWithdraw(request, options);
+      setWithdrawState(createAsyncState("success", { data: signature5 }));
+      return signature5;
+    } catch (error) {
+      setWithdrawState(createAsyncState("error", { error }));
+      throw error;
+    }
+  }
+  __name(withdraw, "withdraw");
+  function subscribe(listener) {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  }
+  __name(subscribe, "subscribe");
+  function subscribeUnstake(listener) {
+    unstakeListeners.add(listener);
+    return () => {
+      unstakeListeners.delete(listener);
+    };
+  }
+  __name(subscribeUnstake, "subscribeUnstake");
+  function subscribeWithdraw(listener) {
+    withdrawListeners.add(listener);
+    return () => {
+      withdrawListeners.delete(listener);
+    };
+  }
+  __name(subscribeWithdraw, "subscribeWithdraw");
+  function reset() {
+    setState(createInitialAsyncState());
+  }
+  __name(reset, "reset");
+  function resetUnstake() {
+    setUnstakeState(createInitialAsyncState());
+  }
+  __name(resetUnstake, "resetUnstake");
+  function resetWithdraw() {
+    setWithdrawState(createInitialAsyncState());
+  }
+  __name(resetWithdraw, "resetWithdraw");
+  return {
+    getHelper: /* @__PURE__ */ __name(() => helper, "getHelper"),
+    getState: /* @__PURE__ */ __name(() => state, "getState"),
+    getUnstakeState: /* @__PURE__ */ __name(() => unstakeState, "getUnstakeState"),
+    getWithdrawState: /* @__PURE__ */ __name(() => withdrawState, "getWithdrawState"),
+    reset,
+    resetUnstake,
+    resetWithdraw,
+    stake,
+    unstake,
+    withdraw,
+    subscribe,
+    subscribeUnstake,
+    subscribeWithdraw
+  };
+}
+__name(createStakeController, "createStakeController");
+
 // src/serialization/json.ts
 function bigintToJson(value) {
   return value.toString();
@@ -2772,7 +3371,7 @@ function insertReferenceKeys(references, transaction) {
   const targetInstruction = transaction.instructions[index];
   const accounts = [
     ...targetInstruction.accounts ?? [],
-    ...references.map((address4) => ({ address: address4, role: kit.AccountRole.READONLY }))
+    ...references.map((address5) => ({ address: address5, role: kit.AccountRole.READONLY }))
   ];
   const updatedInstructions = [...transaction.instructions];
   updatedInstructions.splice(index, 1, { ...targetInstruction, accounts });
@@ -2927,9 +3526,9 @@ function createTransactionPoolController(config) {
     const target = resolvePrepared(overridePrepared);
     sendStateStore.setSnapshot(createAsyncState("loading"));
     try {
-      const signature4 = await helper.send(target, rest);
-      sendStateStore.setSnapshot(createAsyncState("success", { data: signature4 }));
-      return signature4;
+      const signature5 = await helper.send(target, rest);
+      sendStateStore.setSnapshot(createAsyncState("success", { data: signature5 }));
+      return signature5;
     } catch (error) {
       sendStateStore.setSnapshot(createAsyncState("error", { error }));
       throw error;
@@ -2943,15 +3542,15 @@ function createTransactionPoolController(config) {
     sendStateStore.setSnapshot(createAsyncState("loading"));
     try {
       const restWithLifetime = resolveLifetimeOptions(rest);
-      const signature4 = await helper.prepareAndSend(
+      const signature5 = await helper.prepareAndSend(
         {
           ...restWithLifetime,
           instructions: nextInstructions
         },
         sendOptions
       );
-      sendStateStore.setSnapshot(createAsyncState("success", { data: signature4 }));
-      return signature4;
+      sendStateStore.setSnapshot(createAsyncState("success", { data: signature5 }));
+      return signature5;
     } catch (error) {
       sendStateStore.setSnapshot(createAsyncState("error", { error }));
       throw error;
@@ -3071,6 +3670,8 @@ exports.createSolTransferHelper = createSolTransferHelper;
 exports.createSolanaRpcClient = createSolanaRpcClient;
 exports.createSplTokenHelper = createSplTokenHelper;
 exports.createSplTransferController = createSplTransferController;
+exports.createStakeController = createStakeController;
+exports.createStakeHelper = createStakeHelper;
 exports.createTokenAmount = createTokenAmount;
 exports.createTransactionHelper = createTransactionHelper;
 exports.createTransactionPoolController = createTransactionPoolController;
@@ -3083,6 +3684,9 @@ exports.deserializeSolanaState = deserializeSolanaState;
 exports.disconnectWallet = disconnectWallet;
 exports.fetchAccount = fetchAccount;
 exports.fetchBalance = fetchBalance;
+exports.fetchLookupTable = fetchLookupTable;
+exports.fetchLookupTables = fetchLookupTables;
+exports.fetchNonceAccount = fetchNonceAccount;
 exports.getInitialSerializableState = getInitialSerializableState;
 exports.getWalletStandardConnectors = getWalletStandardConnectors;
 exports.injected = injected;