@usebutr/svm 2.0.2 → 3.0.1

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # @usebutr/svm
 
+## 3.0.1
+
+### Patch Changes
+
+- Updated dependencies [[`488fe13`](https://github.com/pedroapfilho/usebutr/commit/488fe13fe9cddb99ff6c5d60f798140e6ac4076f)]:
+  - @usebutr/core@3.0.1
+  - @usebutr/wallet-standard-shared@2.0.1
+
+## 3.0.0
+
+### Major Changes
+
+- [#203](https://github.com/pedroapfilho/usebutr/pull/203) [`1263f86`](https://github.com/pedroapfilho/usebutr/commit/1263f8666afd43b4f7dbf8df1763709c3edf09d9) Thanks [@pedroapfilho](https://github.com/pedroapfilho)! - Adapters now say what they can do by having the method: `capabilities` is gone, and an optional method (`sendTx`, `signMessage`, `getBalance`, `switchChain`, …) exists only when it works for that wallet. No adapter returns a placeholder balance or a receipt that stays pending anymore.
+
+  - `sendTx(tx, { account, chain })` replaces `sendTx` and `sendTxToChain`, and `signMessage`, `signTransaction` and `getBalance` take options objects. `chain` is a `ChainBase`. An adapter either routes the call to that chain, switches the wallet to it, or rejects; none ignores it.
+  - An `account` the wallet does not expose now rejects instead of signing with the first account. `chain.name` is the chain's name, never the wallet's.
+  - `getAccounts()` resolves the active account first. `getAccount` and `switchAccount` are removed.
+  - `getSigner()` resolves a tagged `WalletSigner` (`eip1193`, `wallet-standard`, `walletconnect`, `ledger-*`, …), so it can be narrowed with `switch (signer.kind)` instead of cast.
+  - `createWalletManager(config, { initialState })` owns discovery, hydration and persistence, and works without React. `config.sources` replaces the `discovery`, `connectors` and `createConnector` props. `fromAdapters` registers WalletConnect, Ledger and hand-built adapters, which now also appear in `useDiscoveredWallets()`.
+  - `WalletManagerProvider` takes `config` and `initialState`. `useSigner(wallet)` and `useBalance(wallet, { token, account })` take the wallet entry itself, and id-taking hooks read the active wallet only when the id is omitted (`null` reads none). The hooks are `useWalletManager`, `useWalletState`, `useConnect`, `useWallet`, `useSelectedWallet` (now typed per platform), `useAccounts`, `useConnectionStatus`, `useIsHydrated`, `useIsReconnecting`, `useDiscoveredWallets`, `useConnectedWallets`, the `…ByPlatform` groupings, `useBalance` and `useSigner`.
+  - `manager.connect()` and `useConnect().connectAsync()` resolve the `ConnectedWallet` and reject with a `ConnectionError`, now an `Error` subclass with a `kind` and a new `WalletNotFound` kind. `useConnect().connect()` never rejects: the failure lands in its `error`.
+  - `WalletPersistence` is `load()` / `save(state)`, and `createWalletStorage` replaces `new WalletStorage`. Storage keys are unchanged.
+  - Chain registries (`EVM_CHAINS`, `SVM_CHAINS`, …, `CHAINS_BY_PLATFORM`) move to `@usebutr/core`, and `BITCOIN_CHAINS` gains `testnet4`. `@usebutr/wallets` loads every platform's signer kinds, so an app that imports only it can narrow `signer.kind`.
+  - `@usebutr/react` requires React 19, which its `use()` call already needed.
+  - WalletConnect requests on Solana, Sui and Bitcoin now carry their chain, so they no longer fall through to the first namespace in a multi-namespace session. Solana takes `SVM_CHAINS` chains and maps them to the genesis-hash ids WalletConnect sessions use.
+  - Ledger's Solana `signTransaction` returns the full signed transaction, Sui signs the intent message, and Bitcoin `signMessage` returns a BIP-137 signature.
+  - `@usebutr/testing`'s fake adapter resolves a `signer` you pass instead of registering a test-only signer kind.
+  - `setAccount` selects an exposed account without changing any account's chain. Unknown accounts are ignored; chain changes come from the adapter.
+  - WalletConnect EVM events use the namespace in `session_event`, including empty account lists that end the connection. Local chain switches still update the manager.
+  - Failed persistence saves wait for every key write to finish before reporting failure, so delayed writes cannot overwrite a later disconnect.
+  - `@usebutr/svm/transaction` provides the shared legacy/v0 signing codec used by Ledger and WalletConnect, with consistent layout and signature validation.
+
+  See the migration guide at https://docs.usebutr.com/migration.
+
+### Patch Changes
+
+- Updated dependencies [[`1263f86`](https://github.com/pedroapfilho/usebutr/commit/1263f8666afd43b4f7dbf8df1763709c3edf09d9), [`5d1f234`](https://github.com/pedroapfilho/usebutr/commit/5d1f23403263f7a1f8a48be061727972fe749b5f)]:
+  - @usebutr/core@3.0.0
+  - @usebutr/wallet-standard-shared@2.0.0
+
 ## 2.0.2
 
 ### Patch Changes

package/README.md

@@ -11,22 +11,49 @@ connection-state library. Your application owns the picker UI and chain client.
 npm install @usebutr/react @usebutr/core @usebutr/svm zustand @wallet-standard/app
 ```
 
-React 18+ is a peer dependency of the provider. Discovery does not render a connect modal; add your picker as the provider child. `@wallet-standard/app` is required for Wallet Standard discovery.
+React 19 is a peer dependency of the provider. Discovery does not render a connect modal; add your picker as the provider child. `@wallet-standard/app` is required for Wallet Standard discovery.
 
 ## Usage
 
 ```tsx
 import type { ReactNode } from "react";
-import { createWalletSource } from "@usebutr/core";
+import type { WalletManagerConfig } from "@usebutr/core";
 import { discoverSvmAdapters } from "@usebutr/svm";
 import { WalletManagerProvider } from "@usebutr/react";
 
-const discovery = createWalletSource(discoverSvmAdapters);
+// Every `discover*Adapters` export is a wallet source as-is.
+const config: WalletManagerConfig = { sources: [discoverSvmAdapters] };
+
 export const WalletProvider = ({ children }: { children: ReactNode }) => (
-  <WalletManagerProvider discovery={discovery}>{children}</WalletManagerProvider>
+  <WalletManagerProvider config={config}>{children}</WalletManagerProvider>
 );
 ```
 
+Each adapter defines `sendTx` (`solana:signAndSendTransaction`, resolves the base58 signature), `signMessage`, `signTransaction` (resolves the signed transaction bytes) and `signIn` (Sign In With Solana) only when the wallet advertises the matching feature, and `switchChain` only when it advertises more than one Solana cluster. Wallet Standard carries the chain per call, so `options.chain` routes one transaction without moving the wallet. Balances and receipts need your own RPC client. Check a method's presence before calling it:
+
+```ts
+import type { ConnectedWallet } from "@usebutr/core";
+import { SVM_CHAINS } from "@usebutr/core";
+
+export const send = async (wallet: ConnectedWallet<"svm">, serializedTx: Uint8Array) => {
+  if (!wallet.connector.sendTx) {
+    throw new Error(`${wallet.connector.name} cannot send Solana transactions`);
+  }
+  return wallet.connector.sendTx(serializedTx, {
+    account: wallet.account,
+    chain: SVM_CHAINS.devnet,
+  });
+};
+```
+
+An `account` the wallet does not expose, or a chain it does not advertise, rejects. `getSigner()` resolves `{ kind: "wallet-standard", wallet }`: reach any other feature with `getFeature` from `@usebutr/wallet-standard-shared` and the feature types this package exports. Chain registries (`SVM_CHAINS`, `SVM_CHAINS_LIST`) come from `@usebutr/core`.
+
+`@usebutr/svm/transaction` exports `prepareSolanaTransaction(tx, signer)` for
+transports returning a bare signature. It exposes the serialized `message`
+and `withSignature(bytes)`, which fills the signer's slot in a copy of the
+transaction. Ledger and WalletConnect share this legacy/v0 signing codec;
+the entry point loads no discovery code.
+
 ## Documentation
 
 - [Package reference](https://docs.usebutr.com/api/svm)

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { ChainBase, PlatformDiscoverer, SignInInput, WalletAdapter, WalletCapabilities } from "@usebutr/core";
-import { WalletStandardFeature, WalletStandardModuleLoader, WalletStandardWallet, WalletStandardWalletAccount } from "@usebutr/wallet-standard-shared";
+import { PlatformDiscoverer, SignInInput, SvmAdapter, WalletAdapter } from "@usebutr/core";
+import { WalletStandardModuleLoader, WalletStandardWallet, WalletStandardWalletAccount } from "@usebutr/wallet-standard-shared";
 //#region src/wallet-standard-types.d.ts
 type SolanaSignMessageInput = {
   account: WalletStandardWalletAccount;
@@ -49,21 +49,15 @@ type SolanaSignInFeature = {
 };
 //#endregion
 //#region src/wallet-standard-adapter.d.ts
-declare const isSolanaSignMessageFeature: (feature: WalletStandardFeature) => feature is WalletStandardFeature & SolanaSignMessageFeature;
-declare const isSolanaSignAndSendTransactionFeature: (feature: WalletStandardFeature) => feature is WalletStandardFeature & SolanaSignAndSendTransactionFeature;
-declare const isSolanaSignTransactionFeature: (feature: WalletStandardFeature) => feature is WalletStandardFeature & SolanaSignTransactionFeature;
-declare const isSolanaSignInFeature: (feature: WalletStandardFeature) => feature is WalletStandardFeature & SolanaSignInFeature;
 /**
- * Wallet Standard has no switch-cluster RPC: `switchChain` re-points butr's
- * view only, and `signAndSendTransaction` takes the chain per call.
- * `requestAccounts` re-runs `standard:connect`; some wallets answer silently.
+ * Wallet Standard carries the chain per call, so `sendTx` and
+ * `signTransaction` route `options.chain` without moving the wallet.
+ * Balances and receipts need an RPC client, which butr does not ship.
  */
 declare const buildSvmAdapter: (wallet: WalletStandardWallet,
-/** Optional. Called with a function that pushes a synthetic
- *  `disconnected` event to all current subscribers. The discovery
- *  layer invokes it on Wallet Standard `unregister` so a connected
- *  pool entry tears down when its extension is removed. */
-registerDisconnector?: (emit: () => void) => void) => WalletAdapter | null;
+/** Discovery passes this so a Wallet Standard `unregister` tears down the
+ *  connected pool entry. */
+registerDisconnector?: (emit: () => void) => void) => SvmAdapter | null;
 /**
  * Requires the optional `@wallet-standard/app` peer dep; without it SVM
  * discovery silently does nothing. The returned unsubscribe is safe to call
@@ -71,46 +65,6 @@ registerDisconnector?: (emit: () => void) => void) => WalletAdapter | null;
  */
 declare const discoverSvmAdapters: (onAdapter: (adapter: WalletAdapter) => void, loadModule?: WalletStandardModuleLoader) => (() => void);
 //#endregion
-//#region src/chains.d.ts
-declare const SVM_CHAINS: {
-  readonly devnet: {
-    readonly id: "solana:devnet";
-    readonly name: "Solana Devnet";
-    readonly namespace: "solana";
-    readonly reference: "devnet";
-  };
-  readonly mainnet: {
-    readonly id: "solana:mainnet";
-    readonly name: "Solana Mainnet";
-    readonly namespace: "solana";
-    readonly reference: "mainnet";
-  };
-  readonly testnet: {
-    readonly id: "solana:testnet";
-    readonly name: "Solana Testnet";
-    readonly namespace: "solana";
-    readonly reference: "testnet";
-  };
-};
-declare const SVM_CHAINS_LIST: ReadonlyArray<ChainBase>;
-//#endregion
-//#region src/capabilities.d.ts
-type WalletStandardCapabilityInput = {
-  chainCount: number;
-  features: {
-    events: boolean;
-    signAndSendTransaction: boolean;
-    signIn: boolean;
-    signMessage: boolean;
-    signTransaction: boolean;
-  };
-};
-/**
- * Solana Wallet Standard feature → butr capability mapping. The flags that
- * hold for every namespace are documented on `buildWalletCapabilities`.
- */
-declare const resolveWalletStandardCapabilities: (input: WalletStandardCapabilityInput) => WalletCapabilities;
-//#endregion
 //#region src/discoverer.d.ts
 /**
  * No legacy fallback: Solana wallets standardised on Wallet Standard before
@@ -118,17 +72,5 @@ declare const resolveWalletStandardCapabilities: (input: WalletStandardCapabilit
  */
 declare const svmDiscoverer: PlatformDiscoverer;
 //#endregion
-//#region src/signer-augmentation.d.ts
-/**
- * Augment `@usebutr/core`'s `SignerForPlatform` registry with the SVM
- * entry. SVM's `getSigner()` returns the Wallet Standard wallet
- * object, which consumers narrow further via its `features` map.
- */
-declare module "@usebutr/core" {
-  interface SignerForPlatform {
-    svm: WalletStandardWallet;
-  }
-}
-//#endregion
-export { SVM_CHAINS, SVM_CHAINS_LIST, type SolanaSignAndSendTransactionFeature, type SolanaSignAndSendTransactionInput, type SolanaSignAndSendTransactionOutput, type SolanaSignInFeature, type SolanaSignInInput, type SolanaSignInOutput, type SolanaSignMessageFeature, type SolanaSignMessageInput, type SolanaSignMessageOutput, type WalletStandardCapabilityInput, buildSvmAdapter, discoverSvmAdapters, isSolanaSignAndSendTransactionFeature, isSolanaSignInFeature, isSolanaSignMessageFeature, isSolanaSignTransactionFeature, resolveWalletStandardCapabilities, svmDiscoverer };
+export { type SolanaSignAndSendTransactionFeature, type SolanaSignAndSendTransactionInput, type SolanaSignAndSendTransactionOutput, type SolanaSignInFeature, type SolanaSignInInput, type SolanaSignInOutput, type SolanaSignMessageFeature, type SolanaSignMessageInput, type SolanaSignMessageOutput, type SolanaSignTransactionFeature, type SolanaSignTransactionInput, type SolanaSignTransactionOutput, buildSvmAdapter, discoverSvmAdapters, svmDiscoverer };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/wallet-standard-types.ts","../src/wallet-standard-adapter.ts","../src/chains.ts","../src/capabilities.ts","../src/discoverer.ts","../src/signer-augmentation.ts"],"mappings":";;;KAQK;EACH,SAAS;EACT,SAAS;;KAGN;EACH,WAAW;EACX,eAAe;;KAGZ;EACH,iBACK,QAAQ,cAAc,4BACtB,QAAQ,cAAc;EAC3B;;KAGG;EACH,SAAS;EACT;EACA,aAAa;;KAGV;EACH,WAAW;;KAGR;EACH,4BACK,QAAQ,cAAc,uCACtB,QAAQ,cAAc;EAC3B;;KAGG;EACH,SAAS;EACT;EACA,aAAa;;KAGV;EACH,mBAAmB;;KAGhB;EACH,qBACK,QAAQ,cAAc,gCACtB,QAAQ,cAAc;EAC3B;;KAGG,oBAAoB;KAEpB;EACH,SAAS;EACT,WAAW;EACX,eAAe;;KAGZ;EACH,SAAS,QAAQ,sBAAsB,QAAQ,cAAc;EAC7D;;;;cC3CI,6BAA0B,SACrB,0BACR,WAAW,wBAAwB;cAGhC,wCAAqC,SAChC,0BACR,WAAW,wBAAwB;cAGhC,iCAA8B,SACzB,0BACR,WAAW,wBAAwB;cAGhC,wBAAqB,SAChB,0BACR,WAAW,wBAAwB;;;;;;cAQhC,kBAAe,QACX,sBAKe;;;;;AAAA,wBAAC,8BACvB;;;;;;cA+JG,sBAAmB,YACX,SAAS,wBAAsB,aAC9B;;;cCzNT;;aACM;aAAqB;aAAuB;aAAqB;;;aAEzE;aACA;aACA;aACA;;;aAGA;aACA;aACA;aACA;;;cAIE,iBAAiB,cAAc;;;KCfhC;EACH;EACA;IACE;IACA;IACA;IACA;IACA;;;;;;;cAQE,oCAAiC,OAC9B,kCACN;;;;;;;cCZG,eAAe;;;;;;;;;YCCT;IACR,KAAK"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/wallet-standard-types.ts","../src/wallet-standard-adapter.ts","../src/discoverer.ts"],"mappings":";;;KAQK;EACH,SAAS;EACT,SAAS;;KAGN;EACH,WAAW;EACX,eAAe;;KAGZ;EACH,iBACK,QAAQ,cAAc,4BACtB,QAAQ,cAAc;EAC3B;;KAGG;EACH,SAAS;EACT;EACA,aAAa;;KAGV;EACH,WAAW;;KAGR;EACH,4BACK,QAAQ,cAAc,uCACtB,QAAQ,cAAc;EAC3B;;KAGG;EACH,SAAS;EACT;EACA,aAAa;;KAGV;EACH,mBAAmB;;KAGhB;EACH,qBACK,QAAQ,cAAc,gCACtB,QAAQ,cAAc;EAC3B;;KAGG,oBAAoB;KAEpB;EACH,SAAS;EACT,WAAW;EACX,eAAe;;KAGZ;EACH,SAAS,QAAQ,sBAAsB,QAAQ,cAAc;EAC7D;;;;;;;;;cClCI,kBAAe,QACX,sBAGe;;;AAAA,wBAAC,8BACvB;;;;;;cA2FG,sBAAmB,YACX,SAAS,wBAAsB,aAC9B;;;;;;;cC7HT,eAAe"}

package/dist/index.js

@@ -1,167 +1,79 @@
-import { buildAccount, bytesToBase58 } from "@usebutr/core";
-import { buildWalletCapabilities, createWalletStandardCore, discoverWalletStandard, getFeature, slugify } from "@usebutr/wallet-standard-shared";
+import { SVM_CHAINS_LIST, buildAccount, bytesToBase58 } from "@usebutr/core";
+import { createWalletStandardCore, discoverWalletStandard, getFeature, slugify } from "@usebutr/wallet-standard-shared";
 
-//#region src/capabilities.ts
-/**
-* Solana Wallet Standard feature → butr capability mapping. The flags that
-* hold for every namespace are documented on `buildWalletCapabilities`.
-*/
-const resolveWalletStandardCapabilities = (input) => buildWalletCapabilities({
-	chainCount: input.chainCount,
-	events: input.features.events,
-	sendTransaction: input.features.signAndSendTransaction,
-	signIn: input.features.signIn,
-	signMessage: input.features.signMessage,
-	signTransaction: input.features.signTransaction
-});
-
-//#endregion
 //#region src/wallet-standard-adapter.ts
-const SOLANA_PREFIX = "solana:";
-const SOLANA_DECIMALS = 9;
-const SOLANA_MAINNETS = ["solana:mainnet", "solana:mainnet-beta"];
-const isSolanaSignMessageFeature = (feature) => "signMessage" in feature && typeof feature.signMessage === "function";
-const isSolanaSignAndSendTransactionFeature = (feature) => "signAndSendTransaction" in feature && typeof feature.signAndSendTransaction === "function";
-const isSolanaSignTransactionFeature = (feature) => "signTransaction" in feature && typeof feature.signTransaction === "function";
-const isSolanaSignInFeature = (feature) => "signIn" in feature && typeof feature.signIn === "function";
+/** Solana features take and return arrays so one call can batch; butr sends
+*  one input, so an empty result is a wallet bug, not an empty success. */
+const firstOutput = (outputs, method) => {
+	const [output] = outputs;
+	if (output === void 0) throw new Error(`${method} returned no outputs`);
+	return output;
+};
 /**
-* Wallet Standard has no switch-cluster RPC: `switchChain` re-points butr's
-* view only, and `signAndSendTransaction` takes the chain per call.
-* `requestAccounts` re-runs `standard:connect`; some wallets answer silently.
+* Wallet Standard carries the chain per call, so `sendTx` and
+* `signTransaction` route `options.chain` without moving the wallet.
+* Balances and receipts need an RPC client, which butr does not ship.
 */
 const buildSvmAdapter = (wallet, registerDisconnector) => {
 	const core = createWalletStandardCore({
-		chainPrefix: SOLANA_PREFIX,
+		chains: SVM_CHAINS_LIST,
 		id: slugify("svm", wallet.name),
-		label: "SVM",
+		label: "Solana",
 		namespace: "solana",
-		platform: "Solana",
-		preferredChainIds: SOLANA_MAINNETS,
+		preferredChainIds: ["solana:mainnet", "solana:mainnet-beta"],
 		registerDisconnector,
 		trackChainChanges: true,
 		wallet
 	});
 	if (core === null) return null;
-	const signMessage = getFeature(wallet, "solana:signMessage", isSolanaSignMessageFeature);
-	const signAndSendTx = getFeature(wallet, "solana:signAndSendTransaction", isSolanaSignAndSendTransactionFeature);
-	const signTx = getFeature(wallet, "solana:signTransaction", isSolanaSignTransactionFeature);
-	const signIn = getFeature(wallet, "solana:signIn", isSolanaSignInFeature);
-	/**
-	* Resolve a caller-supplied target into a chain the wallet advertises.
-	* Accepts both the full CAIP-2 id (`solana:devnet`) and a bare reference
-	* (`devnet`), since consumers reasonably reach for either.
-	*/
-	const resolveTargetChain = (targetChainId) => {
-		const candidate = targetChainId.startsWith(SOLANA_PREFIX) ? targetChainId : `${SOLANA_PREFIX}${targetChainId}`;
-		if (!wallet.chains.includes(candidate)) throw new Error(`Wallet ${wallet.name} does not advertise chain "${candidate}". Available: ${wallet.chains.join(", ")}`);
-		return candidate;
-	};
-	const signAndSend = async (tx, account, chain) => {
-		if (signAndSendTx === void 0) throw new Error(`Wallet ${wallet.name} does not advertise solana:signAndSendTransaction`);
-		const wsAccount = core.resolveAccount(account);
-		if (!(tx instanceof Uint8Array)) throw new TypeError("SVM sendTx expects a serialized transaction (Uint8Array)");
-		const [output] = await signAndSendTx.signAndSendTransaction({
-			account: wsAccount,
-			chain: chain ?? core.currentChainId(),
-			transaction: tx
-		});
-		if (output === void 0) throw new Error("signAndSendTransaction returned no outputs");
-		return bytesToBase58(output.signature);
-	};
-	const adapter = {
-		...core,
-		capabilities: resolveWalletStandardCapabilities({
-			chainCount: core.chainCount,
-			features: {
-				events: core.hasEvents,
-				signAndSendTransaction: Boolean(signAndSendTx),
-				signIn: Boolean(signIn),
-				signMessage: Boolean(signMessage),
-				signTransaction: Boolean(signTx)
-			}
-		}),
+	const signAndSend = getFeature(wallet, "solana:signAndSendTransaction", "signAndSendTransaction");
+	const signMessage = getFeature(wallet, "solana:signMessage", "signMessage");
+	const signTransaction = getFeature(wallet, "solana:signTransaction", "signTransaction");
+	const signIn = getFeature(wallet, "solana:signIn", "signIn");
+	return {
+		...core.base,
 		chainPlatform: "svm",
-		getBalance: () => Promise.resolve({
-			decimals: SOLANA_DECIMALS,
-			formatted: "0",
-			symbol: "SOL",
-			value: 0n
-		}),
-		getTransactionReceipt: () => Promise.resolve({ status: "Pending" }),
-		async requestAccounts() {
-			await core.connect();
-		},
-		sendTx: (tx, account) => signAndSend(tx, account),
-		async sendTxToChain(tx, targetChainId, account, cb) {
-			const target = resolveTargetChain(targetChainId);
-			if (target !== core.currentChainId()) cb?.();
-			return await signAndSend(tx, account, target);
-		},
-		async signMessage(msg, account) {
-			if (signMessage === void 0) throw new Error(`Wallet ${wallet.name} does not advertise solana:signMessage`);
-			const [output] = await signMessage.signMessage({
-				account: core.resolveAccount(account),
-				message: msg
-			});
-			if (output === void 0) throw new Error("signMessage returned no outputs");
+		...signAndSend !== void 0 && { async sendTx(tx, options) {
+			const output = firstOutput(await signAndSend.signAndSendTransaction({
+				account: core.resolveAccount(options?.account),
+				chain: core.resolveChainId(options?.chain),
+				transaction: tx
+			}), "signAndSendTransaction");
+			return bytesToBase58(output.signature);
+		} },
+		...signMessage !== void 0 && { async signMessage(message, options) {
+			const output = firstOutput(await signMessage.signMessage({
+				account: core.resolveAccount(options?.account),
+				message
+			}), "signMessage");
 			return {
 				signature: output.signature,
 				signedMessage: output.signedMessage
 			};
-		}
-	};
-	if (signTx !== void 0) adapter.signTransaction = async (tx, account) => {
-		const wsAccount = core.resolveAccount(account);
-		if (!(tx instanceof Uint8Array)) throw new TypeError("SVM signTransaction expects a serialized transaction (Uint8Array)");
-		const [output] = await signTx.signTransaction({
-			account: wsAccount,
-			chain: core.currentChainId(),
-			transaction: tx
-		});
-		if (output === void 0) throw new Error("signTransaction returned no outputs");
-		return output.signedTransaction;
-	};
-	if (signIn !== void 0) adapter.signIn = async (input) => {
-		const [output] = await signIn.signIn(input);
-		if (output === void 0) throw new Error("signIn returned no outputs");
-		return {
-			account: buildAccount(output.account.address, core.toChain()),
-			signature: output.signature,
-			signedMessage: output.signedMessage
-		};
+		} },
+		...signTransaction !== void 0 && { async signTransaction(tx, options) {
+			return firstOutput(await signTransaction.signTransaction({
+				account: core.resolveAccount(options?.account),
+				chain: core.resolveChainId(options?.chain),
+				transaction: tx
+			}), "signTransaction").signedTransaction;
+		} },
+		...signIn !== void 0 && { async signIn(input) {
+			const output = firstOutput(await signIn.signIn(input), "signIn");
+			return {
+				account: buildAccount(output.account.address, core.currentChain()),
+				signature: output.signature,
+				signedMessage: output.signedMessage
+			};
+		} }
 	};
-	return adapter;
 };
 /**
 * Requires the optional `@wallet-standard/app` peer dep; without it SVM
 * discovery silently does nothing. The returned unsubscribe is safe to call
 * before the dynamic import has resolved.
 */
-const discoverSvmAdapters = (onAdapter, loadModule) => discoverWalletStandard(onAdapter, (wallet, registerDisconnector) => buildSvmAdapter(wallet, registerDisconnector), loadModule);
-
-//#endregion
-//#region src/chains.ts
-const SVM_CHAINS = {
-	devnet: {
-		id: "solana:devnet",
-		name: "Solana Devnet",
-		namespace: "solana",
-		reference: "devnet"
-	},
-	mainnet: {
-		id: "solana:mainnet",
-		name: "Solana Mainnet",
-		namespace: "solana",
-		reference: "mainnet"
-	},
-	testnet: {
-		id: "solana:testnet",
-		name: "Solana Testnet",
-		namespace: "solana",
-		reference: "testnet"
-	}
-};
-const SVM_CHAINS_LIST = Object.values(SVM_CHAINS);
+const discoverSvmAdapters = (onAdapter, loadModule) => discoverWalletStandard(onAdapter, buildSvmAdapter, loadModule);
 
 //#endregion
 //#region src/discoverer.ts
@@ -172,5 +84,5 @@ const SVM_CHAINS_LIST = Object.values(SVM_CHAINS);
 const svmDiscoverer = { subscribe: discoverSvmAdapters };
 
 //#endregion
-export { SVM_CHAINS, SVM_CHAINS_LIST, buildSvmAdapter, discoverSvmAdapters, isSolanaSignAndSendTransactionFeature, isSolanaSignInFeature, isSolanaSignMessageFeature, isSolanaSignTransactionFeature, resolveWalletStandardCapabilities, svmDiscoverer };
+export { buildSvmAdapter, discoverSvmAdapters, svmDiscoverer };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/capabilities.ts","../src/wallet-standard-adapter.ts","../src/chains.ts","../src/discoverer.ts"],"sourcesContent":["import type { WalletCapabilities } from \"@usebutr/core\";\nimport { buildWalletCapabilities } from \"@usebutr/wallet-standard-shared\";\n\ntype WalletStandardCapabilityInput = {\n  chainCount: number;\n  features: {\n    events: boolean;\n    signAndSendTransaction: boolean;\n    signIn: boolean;\n    signMessage: boolean;\n    signTransaction: boolean;\n  };\n};\n\n/**\n * Solana Wallet Standard feature → butr capability mapping. The flags that\n * hold for every namespace are documented on `buildWalletCapabilities`.\n */\nconst resolveWalletStandardCapabilities = (\n  input: WalletStandardCapabilityInput,\n): WalletCapabilities =>\n  buildWalletCapabilities({\n    chainCount: input.chainCount,\n    events: input.features.events,\n    sendTransaction: input.features.signAndSendTransaction,\n    signIn: input.features.signIn,\n    signMessage: input.features.signMessage,\n    signTransaction: input.features.signTransaction,\n  });\n\nexport type { WalletStandardCapabilityInput };\nexport { resolveWalletStandardCapabilities };\n","import type { TransactionInput, WalletAdapter } from \"@usebutr/core\";\nimport { buildAccount, bytesToBase58 } from \"@usebutr/core\";\nimport {\n  createWalletStandardCore,\n  discoverWalletStandard,\n  getFeature,\n  slugify,\n} from \"@usebutr/wallet-standard-shared\";\nimport type {\n  WalletStandardFeature,\n  WalletStandardModuleLoader,\n  WalletStandardWallet,\n} from \"@usebutr/wallet-standard-shared\";\n\nimport { resolveWalletStandardCapabilities } from \"./capabilities\";\nimport type {\n  SolanaSignAndSendTransactionFeature,\n  SolanaSignInFeature,\n  SolanaSignMessageFeature,\n  SolanaSignTransactionFeature,\n} from \"./wallet-standard-types\";\n\nconst SOLANA_PREFIX = \"solana:\";\nconst SOLANA_DECIMALS = 9;\nconst SOLANA_MAINNETS: ReadonlyArray<string> = [\"solana:mainnet\", \"solana:mainnet-beta\"];\n\nconst isSolanaSignMessageFeature = (\n  feature: WalletStandardFeature,\n): feature is WalletStandardFeature & SolanaSignMessageFeature =>\n  \"signMessage\" in feature && typeof feature.signMessage === \"function\";\n\nconst isSolanaSignAndSendTransactionFeature = (\n  feature: WalletStandardFeature,\n): feature is WalletStandardFeature & SolanaSignAndSendTransactionFeature =>\n  \"signAndSendTransaction\" in feature && typeof feature.signAndSendTransaction === \"function\";\n\nconst isSolanaSignTransactionFeature = (\n  feature: WalletStandardFeature,\n): feature is WalletStandardFeature & SolanaSignTransactionFeature =>\n  \"signTransaction\" in feature && typeof feature.signTransaction === \"function\";\n\nconst isSolanaSignInFeature = (\n  feature: WalletStandardFeature,\n): feature is WalletStandardFeature & SolanaSignInFeature =>\n  \"signIn\" in feature && typeof feature.signIn === \"function\";\n\n/**\n * Wallet Standard has no switch-cluster RPC: `switchChain` re-points butr's\n * view only, and `signAndSendTransaction` takes the chain per call.\n * `requestAccounts` re-runs `standard:connect`; some wallets answer silently.\n */\nconst buildSvmAdapter = (\n  wallet: WalletStandardWallet,\n  /** Optional. Called with a function that pushes a synthetic\n   *  `disconnected` event to all current subscribers. The discovery\n   *  layer invokes it on Wallet Standard `unregister` so a connected\n   *  pool entry tears down when its extension is removed. */\n  registerDisconnector?: (emit: () => void) => void,\n): WalletAdapter | null => {\n  const core = createWalletStandardCore({\n    chainPrefix: SOLANA_PREFIX,\n    id: slugify(\"svm\", wallet.name),\n    label: \"SVM\",\n    namespace: \"solana\",\n    platform: \"Solana\",\n    preferredChainIds: SOLANA_MAINNETS,\n    registerDisconnector,\n    trackChainChanges: true,\n    wallet,\n  });\n  if (core === null) {\n    return null;\n  }\n\n  const signMessage = getFeature(wallet, \"solana:signMessage\", isSolanaSignMessageFeature);\n  const signAndSendTx = getFeature(\n    wallet,\n    \"solana:signAndSendTransaction\",\n    isSolanaSignAndSendTransactionFeature,\n  );\n  const signTx = getFeature(wallet, \"solana:signTransaction\", isSolanaSignTransactionFeature);\n  const signIn = getFeature(wallet, \"solana:signIn\", isSolanaSignInFeature);\n\n  /**\n   * Resolve a caller-supplied target into a chain the wallet advertises.\n   * Accepts both the full CAIP-2 id (`solana:devnet`) and a bare reference\n   * (`devnet`), since consumers reasonably reach for either.\n   */\n  const resolveTargetChain = (targetChainId: string): string => {\n    const candidate = targetChainId.startsWith(SOLANA_PREFIX)\n      ? targetChainId\n      : `${SOLANA_PREFIX}${targetChainId}`;\n    if (!wallet.chains.includes(candidate)) {\n      throw new Error(\n        `Wallet ${wallet.name} does not advertise chain \"${candidate}\". Available: ${wallet.chains.join(\", \")}`,\n      );\n    }\n    return candidate;\n  };\n\n  const signAndSend = async (\n    tx: TransactionInput,\n    account?: { walletAddress: string },\n    chain?: string,\n  ): Promise<string> => {\n    if (signAndSendTx === undefined) {\n      throw new Error(`Wallet ${wallet.name} does not advertise solana:signAndSendTransaction`);\n    }\n    const wsAccount = core.resolveAccount(account);\n    if (!(tx instanceof Uint8Array)) {\n      throw new TypeError(\"SVM sendTx expects a serialized transaction (Uint8Array)\");\n    }\n    const [output] = await signAndSendTx.signAndSendTransaction({\n      account: wsAccount,\n      chain: chain ?? core.currentChainId(),\n      transaction: tx,\n    });\n    if (output === undefined) {\n      throw new Error(\"signAndSendTransaction returned no outputs\");\n    }\n    return bytesToBase58(output.signature);\n  };\n\n  const adapter: WalletAdapter = {\n    ...core,\n    capabilities: resolveWalletStandardCapabilities({\n      chainCount: core.chainCount,\n      features: {\n        events: core.hasEvents,\n        signAndSendTransaction: Boolean(signAndSendTx),\n        signIn: Boolean(signIn),\n        signMessage: Boolean(signMessage),\n        signTransaction: Boolean(signTx),\n      },\n    }),\n    chainPlatform: \"svm\",\n\n    getBalance: () =>\n      Promise.resolve({\n        decimals: SOLANA_DECIMALS,\n        formatted: \"0\",\n        symbol: \"SOL\",\n        value: 0n,\n      }),\n\n    getTransactionReceipt: () => Promise.resolve({ status: \"Pending\" as const }),\n\n    async requestAccounts() {\n      await core.connect();\n    },\n\n    sendTx: (tx, account) => signAndSend(tx, account),\n\n    async sendTxToChain(tx, targetChainId, account, cb) {\n      const target = resolveTargetChain(targetChainId);\n      if (target !== core.currentChainId()) {\n        cb?.();\n      }\n      const signature = await signAndSend(tx, account, target);\n      return signature;\n    },\n\n    async signMessage(msg, account) {\n      if (signMessage === undefined) {\n        throw new Error(`Wallet ${wallet.name} does not advertise solana:signMessage`);\n      }\n      const [output] = await signMessage.signMessage({\n        account: core.resolveAccount(account),\n        message: msg,\n      });\n      if (output === undefined) {\n        throw new Error(\"signMessage returned no outputs\");\n      }\n      return { signature: output.signature, signedMessage: output.signedMessage };\n    },\n  };\n\n  if (signTx !== undefined) {\n    adapter.signTransaction = async (tx, account) => {\n      const wsAccount = core.resolveAccount(account);\n      if (!(tx instanceof Uint8Array)) {\n        throw new TypeError(\"SVM signTransaction expects a serialized transaction (Uint8Array)\");\n      }\n      const [output] = await signTx.signTransaction({\n        account: wsAccount,\n        chain: core.currentChainId(),\n        transaction: tx,\n      });\n      if (output === undefined) {\n        throw new Error(\"signTransaction returned no outputs\");\n      }\n      return output.signedTransaction;\n    };\n  }\n\n  if (signIn !== undefined) {\n    adapter.signIn = async (input) => {\n      const [output] = await signIn.signIn(input);\n      if (output === undefined) {\n        throw new Error(\"signIn returned no outputs\");\n      }\n      return {\n        account: buildAccount(output.account.address, core.toChain()),\n        signature: output.signature,\n        signedMessage: output.signedMessage,\n      };\n    };\n  }\n\n  return adapter;\n};\n\n/**\n * Requires the optional `@wallet-standard/app` peer dep; without it SVM\n * discovery silently does nothing. The returned unsubscribe is safe to call\n * before the dynamic import has resolved.\n */\nconst discoverSvmAdapters = (\n  onAdapter: (adapter: WalletAdapter) => void,\n  loadModule?: WalletStandardModuleLoader,\n): (() => void) =>\n  discoverWalletStandard(\n    onAdapter,\n    (wallet, registerDisconnector) => buildSvmAdapter(wallet, registerDisconnector),\n    loadModule,\n  );\n\nexport {\n  buildSvmAdapter,\n  discoverSvmAdapters,\n  isSolanaSignAndSendTransactionFeature,\n  isSolanaSignInFeature,\n  isSolanaSignMessageFeature,\n  isSolanaSignTransactionFeature,\n};\n","import type { ChainBase } from \"@usebutr/core\";\n\nconst SVM_CHAINS = {\n  devnet: { id: \"solana:devnet\", name: \"Solana Devnet\", namespace: \"solana\", reference: \"devnet\" },\n  mainnet: {\n    id: \"solana:mainnet\",\n    name: \"Solana Mainnet\",\n    namespace: \"solana\",\n    reference: \"mainnet\",\n  },\n  testnet: {\n    id: \"solana:testnet\",\n    name: \"Solana Testnet\",\n    namespace: \"solana\",\n    reference: \"testnet\",\n  },\n} as const satisfies Record<string, ChainBase>;\n\nconst SVM_CHAINS_LIST: ReadonlyArray<ChainBase> = Object.values(SVM_CHAINS);\n\nexport { SVM_CHAINS, SVM_CHAINS_LIST };\n","import type { PlatformDiscoverer } from \"@usebutr/core\";\n\nimport { discoverSvmAdapters } from \"./wallet-standard-adapter\";\n\n/**\n * No legacy fallback: Solana wallets standardised on Wallet Standard before\n * butr existed, so there's no `window.solana` injected path worth shimming.\n */\nconst svmDiscoverer: PlatformDiscoverer = {\n  subscribe: discoverSvmAdapters,\n};\n\nexport { svmDiscoverer };\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/wallet-standard-adapter.ts","../src/discoverer.ts"],"sourcesContent":["import type { SvmAdapter, WalletAdapter } from \"@usebutr/core\";\nimport { buildAccount, bytesToBase58, SVM_CHAINS_LIST } from \"@usebutr/core\";\nimport {\n  createWalletStandardCore,\n  discoverWalletStandard,\n  getFeature,\n  slugify,\n} from \"@usebutr/wallet-standard-shared\";\nimport type {\n  WalletStandardModuleLoader,\n  WalletStandardWallet,\n} from \"@usebutr/wallet-standard-shared\";\n\nimport type {\n  SolanaSignAndSendTransactionFeature,\n  SolanaSignInFeature,\n  SolanaSignMessageFeature,\n  SolanaSignTransactionFeature,\n} from \"./wallet-standard-types\";\n\n/** Solana features take and return arrays so one call can batch; butr sends\n *  one input, so an empty result is a wallet bug, not an empty success. */\nconst firstOutput = <Output>(outputs: ReadonlyArray<Output>, method: string): Output => {\n  const [output] = outputs;\n  if (output === undefined) {\n    throw new Error(`${method} returned no outputs`);\n  }\n  return output;\n};\n\n/**\n * Wallet Standard carries the chain per call, so `sendTx` and\n * `signTransaction` route `options.chain` without moving the wallet.\n * Balances and receipts need an RPC client, which butr does not ship.\n */\nconst buildSvmAdapter = (\n  wallet: WalletStandardWallet,\n  /** Discovery passes this so a Wallet Standard `unregister` tears down the\n   *  connected pool entry. */\n  registerDisconnector?: (emit: () => void) => void,\n): SvmAdapter | null => {\n  const core = createWalletStandardCore({\n    chains: SVM_CHAINS_LIST,\n    id: slugify(\"svm\", wallet.name),\n    label: \"Solana\",\n    namespace: \"solana\",\n    preferredChainIds: [\"solana:mainnet\", \"solana:mainnet-beta\"],\n    registerDisconnector,\n    trackChainChanges: true,\n    wallet,\n  });\n  if (core === null) {\n    return null;\n  }\n\n  const signAndSend = getFeature<SolanaSignAndSendTransactionFeature>(\n    wallet,\n    \"solana:signAndSendTransaction\",\n    \"signAndSendTransaction\",\n  );\n  const signMessage = getFeature<SolanaSignMessageFeature>(\n    wallet,\n    \"solana:signMessage\",\n    \"signMessage\",\n  );\n  const signTransaction = getFeature<SolanaSignTransactionFeature>(\n    wallet,\n    \"solana:signTransaction\",\n    \"signTransaction\",\n  );\n  const signIn = getFeature<SolanaSignInFeature>(wallet, \"solana:signIn\", \"signIn\");\n\n  return {\n    ...core.base,\n    chainPlatform: \"svm\",\n    ...(signAndSend !== undefined && {\n      async sendTx(tx, options) {\n        const output = firstOutput(\n          await signAndSend.signAndSendTransaction({\n            account: core.resolveAccount(options?.account),\n            chain: core.resolveChainId(options?.chain),\n            transaction: tx,\n          }),\n          \"signAndSendTransaction\",\n        );\n        return bytesToBase58(output.signature);\n      },\n    }),\n    ...(signMessage !== undefined && {\n      async signMessage(message, options) {\n        const output = firstOutput(\n          await signMessage.signMessage({\n            account: core.resolveAccount(options?.account),\n            message,\n          }),\n          \"signMessage\",\n        );\n        return { signature: output.signature, signedMessage: output.signedMessage };\n      },\n    }),\n    ...(signTransaction !== undefined && {\n      async signTransaction(tx, options) {\n        const output = firstOutput(\n          await signTransaction.signTransaction({\n            account: core.resolveAccount(options?.account),\n            chain: core.resolveChainId(options?.chain),\n            transaction: tx,\n          }),\n          \"signTransaction\",\n        );\n        return output.signedTransaction;\n      },\n    }),\n    ...(signIn !== undefined && {\n      async signIn(input) {\n        const output = firstOutput(await signIn.signIn(input), \"signIn\");\n        return {\n          account: buildAccount(output.account.address, core.currentChain()),\n          signature: output.signature,\n          signedMessage: output.signedMessage,\n        };\n      },\n    }),\n  };\n};\n\n/**\n * Requires the optional `@wallet-standard/app` peer dep; without it SVM\n * discovery silently does nothing. The returned unsubscribe is safe to call\n * before the dynamic import has resolved.\n */\nconst discoverSvmAdapters = (\n  onAdapter: (adapter: WalletAdapter) => void,\n  loadModule?: WalletStandardModuleLoader,\n): (() => void) => discoverWalletStandard(onAdapter, buildSvmAdapter, loadModule);\n\nexport { buildSvmAdapter, discoverSvmAdapters };\n","import type { PlatformDiscoverer } from \"@usebutr/core\";\n\nimport { discoverSvmAdapters } from \"./wallet-standard-adapter\";\n\n/**\n * No legacy fallback: Solana wallets standardised on Wallet Standard before\n * butr existed, so there's no `window.solana` injected path worth shimming.\n */\nconst svmDiscoverer: PlatformDiscoverer = {\n  subscribe: discoverSvmAdapters,\n};\n\nexport { svmDiscoverer };\n"],"mappings":";;;;;;AAsBA,MAAM,eAAuB,SAAgC,WAA2B;CACtF,MAAM,CAAC,UAAU;CACjB,IAAI,WAAW,QACb,MAAM,IAAI,MAAM,GAAG,OAAO,qBAAqB;CAEjD,OAAO;AACT;;;;;;AAOA,MAAM,mBACJ,QAGA,yBACsB;CACtB,MAAM,OAAO,yBAAyB;EACpC,QAAQ;EACR,IAAI,QAAQ,OAAO,OAAO,IAAI;EAC9B,OAAO;EACP,WAAW;EACX,mBAAmB,CAAC,kBAAkB,qBAAqB;EAC3D;EACA,mBAAmB;EACnB;CACF,CAAC;CACD,IAAI,SAAS,MACX,OAAO;CAGT,MAAM,cAAc,WAClB,QACA,iCACA,wBACF;CACA,MAAM,cAAc,WAClB,QACA,sBACA,aACF;CACA,MAAM,kBAAkB,WACtB,QACA,0BACA,iBACF;CACA,MAAM,SAAS,WAAgC,QAAQ,iBAAiB,QAAQ;CAEhF,OAAO;EACL,GAAG,KAAK;EACR,eAAe;EACf,GAAI,gBAAgB,UAAa,EAC/B,MAAM,OAAO,IAAI,SAAS;GACxB,MAAM,SAAS,YACb,MAAM,YAAY,uBAAuB;IACvC,SAAS,KAAK,eAAe,SAAS,OAAO;IAC7C,OAAO,KAAK,eAAe,SAAS,KAAK;IACzC,aAAa;GACf,CAAC,GACD,wBACF;GACA,OAAO,cAAc,OAAO,SAAS;EACvC,EACF;EACA,GAAI,gBAAgB,UAAa,EAC/B,MAAM,YAAY,SAAS,SAAS;GAClC,MAAM,SAAS,YACb,MAAM,YAAY,YAAY;IAC5B,SAAS,KAAK,eAAe,SAAS,OAAO;IAC7C;GACF,CAAC,GACD,aACF;GACA,OAAO;IAAE,WAAW,OAAO;IAAW,eAAe,OAAO;GAAc;EAC5E,EACF;EACA,GAAI,oBAAoB,UAAa,EACnC,MAAM,gBAAgB,IAAI,SAAS;GASjC,OARe,YACb,MAAM,gBAAgB,gBAAgB;IACpC,SAAS,KAAK,eAAe,SAAS,OAAO;IAC7C,OAAO,KAAK,eAAe,SAAS,KAAK;IACzC,aAAa;GACf,CAAC,GACD,iBAEU,CAAC,CAAC;EAChB,EACF;EACA,GAAI,WAAW,UAAa,EAC1B,MAAM,OAAO,OAAO;GAClB,MAAM,SAAS,YAAY,MAAM,OAAO,OAAO,KAAK,GAAG,QAAQ;GAC/D,OAAO;IACL,SAAS,aAAa,OAAO,QAAQ,SAAS,KAAK,aAAa,CAAC;IACjE,WAAW,OAAO;IAClB,eAAe,OAAO;GACxB;EACF,EACF;CACF;AACF;;;;;;AAOA,MAAM,uBACJ,WACA,eACiB,uBAAuB,WAAW,iBAAiB,UAAU;;;;;;;;AC9HhF,MAAM,gBAAoC,EACxC,WAAW,oBACb"}

package/dist/transaction.d.ts

@@ -0,0 +1,16 @@
+//#region src/transaction.d.ts
+type SolanaSigningPayload = {
+  /** Serialized message passed to a device that signs messages directly. */
+  message: Uint8Array;
+  /** Returns a copy with the signer's slot filled, preserving other signatures. */
+  withSignature: (signature: Uint8Array) => Uint8Array;
+};
+/**
+ * Resolves the signer's slot in a serialized legacy or v0 transaction.
+ * Validates the signature/header/key layout; instructions stay opaque.
+ * Both device signers and RPCs returning a bare signature use this boundary.
+ */
+declare const prepareSolanaTransaction: (tx: Uint8Array, signer: string) => SolanaSigningPayload;
+//#endregion
+export { type SolanaSigningPayload, prepareSolanaTransaction };
+//# sourceMappingURL=transaction.d.ts.map

package/dist/transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","names":[],"sources":["../src/transaction.ts"],"mappings":";KA2BK;;EAEH,SAAS;;EAET,gBAAgB,WAAW,eAAe;;;;;;;cAQtC,2BAAwB,IAAQ,YAAU,mBAAmB"}

package/dist/transaction.js

@@ -0,0 +1,60 @@
+import { bytesToBase58 } from "@usebutr/core";
+
+//#region src/transaction.ts
+const SIGNATURE_LENGTH = 64;
+const PUBLIC_KEY_LENGTH = 32;
+const BLOCKHASH_LENGTH = 32;
+const V0_PREFIX = 128;
+/** Solana shortvec encodes a u16 in at most three bytes, seven bits per
+*  byte. Reject truncated, overflowing and non-canonical encodings. */
+const readCompactU16 = (bytes, offset) => {
+	let value = 0;
+	for (let index = 0; index < 3; index += 1) {
+		const byte = bytes.at(offset + index);
+		if (byte === void 0 || index === 2 && byte > 3) break;
+		value += byte % 128 * 128 ** index;
+		if (byte < 128) {
+			if (index > 0 && byte === 0) break;
+			return {
+				end: offset + index + 1,
+				value
+			};
+		}
+	}
+	throw new TypeError("Malformed compact-u16 in the Solana transaction");
+};
+/**
+* Resolves the signer's slot in a serialized legacy or v0 transaction.
+* Validates the signature/header/key layout; instructions stay opaque.
+* Both device signers and RPCs returning a bare signature use this boundary.
+*/
+const prepareSolanaTransaction = (tx, signer) => {
+	const signatures = readCompactU16(tx, 0);
+	const messageStart = signatures.end + signatures.value * SIGNATURE_LENGTH;
+	const versionByte = tx.at(messageStart);
+	if (versionByte === void 0) throw new TypeError("Truncated Solana transaction message");
+	if (versionByte > V0_PREFIX) throw new TypeError(`Unsupported Solana message version ${versionByte - V0_PREFIX}`);
+	const headerStart = messageStart + (versionByte === V0_PREFIX ? 1 : 0);
+	const signerCount = tx[headerStart];
+	const keys = readCompactU16(tx, headerStart + 3);
+	const minimumLength = keys.end + keys.value * PUBLIC_KEY_LENGTH + BLOCKHASH_LENGTH + 1;
+	if (signatures.value === 0 || signerCount !== signatures.value || keys.value < signatures.value || minimumLength > tx.length) throw new TypeError("Malformed Solana transaction signature/header/key layout");
+	const slot = Array.from({ length: signatures.value }, (_, index) => {
+		const start = keys.end + index * PUBLIC_KEY_LENGTH;
+		return bytesToBase58(tx.subarray(start, start + PUBLIC_KEY_LENGTH));
+	}).indexOf(signer);
+	if (slot === -1) throw new Error(`${signer} is not a required signer of this transaction`);
+	return {
+		message: tx.subarray(messageStart),
+		withSignature: (signature) => {
+			if (signature.length !== SIGNATURE_LENGTH) throw new Error(`Expected a 64-byte Solana signature, received ${signature.length} bytes`);
+			const signed = Uint8Array.from(tx);
+			signed.set(signature, signatures.end + slot * SIGNATURE_LENGTH);
+			return signed;
+		}
+	};
+};
+
+//#endregion
+export { prepareSolanaTransaction };
+//# sourceMappingURL=transaction.js.map

package/dist/transaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.js","names":[],"sources":["../src/transaction.ts"],"sourcesContent":["import { bytesToBase58 } from \"@usebutr/core\";\n\nconst SIGNATURE_LENGTH = 64;\nconst PUBLIC_KEY_LENGTH = 32;\nconst BLOCKHASH_LENGTH = 32;\nconst V0_PREFIX = 0x80;\n\n/** Solana shortvec encodes a u16 in at most three bytes, seven bits per\n *  byte. Reject truncated, overflowing and non-canonical encodings. */\nconst readCompactU16 = (bytes: Uint8Array, offset: number) => {\n  let value = 0;\n  for (let index = 0; index < 3; index += 1) {\n    const byte = bytes.at(offset + index);\n    if (byte === undefined || (index === 2 && byte > 3)) {\n      break;\n    }\n    value += (byte % 128) * 128 ** index;\n    if (byte < 128) {\n      if (index > 0 && byte === 0) {\n        break;\n      }\n      return { end: offset + index + 1, value };\n    }\n  }\n  throw new TypeError(\"Malformed compact-u16 in the Solana transaction\");\n};\n\ntype SolanaSigningPayload = {\n  /** Serialized message passed to a device that signs messages directly. */\n  message: Uint8Array;\n  /** Returns a copy with the signer's slot filled, preserving other signatures. */\n  withSignature: (signature: Uint8Array) => Uint8Array;\n};\n\n/**\n * Resolves the signer's slot in a serialized legacy or v0 transaction.\n * Validates the signature/header/key layout; instructions stay opaque.\n * Both device signers and RPCs returning a bare signature use this boundary.\n */\nconst prepareSolanaTransaction = (tx: Uint8Array, signer: string): SolanaSigningPayload => {\n  const signatures = readCompactU16(tx, 0);\n  const messageStart = signatures.end + signatures.value * SIGNATURE_LENGTH;\n  const versionByte = tx.at(messageStart);\n  if (versionByte === undefined) {\n    throw new TypeError(\"Truncated Solana transaction message\");\n  }\n  if (versionByte > V0_PREFIX) {\n    throw new TypeError(`Unsupported Solana message version ${versionByte - V0_PREFIX}`);\n  }\n  const headerStart = messageStart + (versionByte === V0_PREFIX ? 1 : 0);\n  const signerCount = tx[headerStart];\n  const keys = readCompactU16(tx, headerStart + 3);\n  const minimumLength = keys.end + keys.value * PUBLIC_KEY_LENGTH + BLOCKHASH_LENGTH + 1;\n  if (\n    signatures.value === 0 ||\n    signerCount !== signatures.value ||\n    keys.value < signatures.value ||\n    minimumLength > tx.length\n  ) {\n    throw new TypeError(\"Malformed Solana transaction signature/header/key layout\");\n  }\n  const signers = Array.from({ length: signatures.value }, (_, index) => {\n    const start = keys.end + index * PUBLIC_KEY_LENGTH;\n    return bytesToBase58(tx.subarray(start, start + PUBLIC_KEY_LENGTH));\n  });\n  const slot = signers.indexOf(signer);\n  if (slot === -1) {\n    throw new Error(`${signer} is not a required signer of this transaction`);\n  }\n\n  return {\n    message: tx.subarray(messageStart),\n    withSignature: (signature) => {\n      if (signature.length !== SIGNATURE_LENGTH) {\n        throw new Error(`Expected a 64-byte Solana signature, received ${signature.length} bytes`);\n      }\n      const signed = Uint8Array.from(tx);\n      signed.set(signature, signatures.end + slot * SIGNATURE_LENGTH);\n      return signed;\n    },\n  };\n};\n\nexport type { SolanaSigningPayload };\nexport { prepareSolanaTransaction };\n"],"mappings":";;;AAEA,MAAM,mBAAmB;AACzB,MAAM,oBAAoB;AAC1B,MAAM,mBAAmB;AACzB,MAAM,YAAY;;;AAIlB,MAAM,kBAAkB,OAAmB,WAAmB;CAC5D,IAAI,QAAQ;CACZ,KAAK,IAAI,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG;EACzC,MAAM,OAAO,MAAM,GAAG,SAAS,KAAK;EACpC,IAAI,SAAS,UAAc,UAAU,KAAK,OAAO,GAC/C;EAEF,SAAU,OAAO,MAAO,OAAO;EAC/B,IAAI,OAAO,KAAK;GACd,IAAI,QAAQ,KAAK,SAAS,GACxB;GAEF,OAAO;IAAE,KAAK,SAAS,QAAQ;IAAG;GAAM;EAC1C;CACF;CACA,MAAM,IAAI,UAAU,iDAAiD;AACvE;;;;;;AAcA,MAAM,4BAA4B,IAAgB,WAAyC;CACzF,MAAM,aAAa,eAAe,IAAI,CAAC;CACvC,MAAM,eAAe,WAAW,MAAM,WAAW,QAAQ;CACzD,MAAM,cAAc,GAAG,GAAG,YAAY;CACtC,IAAI,gBAAgB,QAClB,MAAM,IAAI,UAAU,sCAAsC;CAE5D,IAAI,cAAc,WAChB,MAAM,IAAI,UAAU,sCAAsC,cAAc,WAAW;CAErF,MAAM,cAAc,gBAAgB,gBAAgB,YAAY,IAAI;CACpE,MAAM,cAAc,GAAG;CACvB,MAAM,OAAO,eAAe,IAAI,cAAc,CAAC;CAC/C,MAAM,gBAAgB,KAAK,MAAM,KAAK,QAAQ,oBAAoB,mBAAmB;CACrF,IACE,WAAW,UAAU,KACrB,gBAAgB,WAAW,SAC3B,KAAK,QAAQ,WAAW,SACxB,gBAAgB,GAAG,QAEnB,MAAM,IAAI,UAAU,0DAA0D;CAMhF,MAAM,OAJU,MAAM,KAAK,EAAE,QAAQ,WAAW,MAAM,IAAI,GAAG,UAAU;EACrE,MAAM,QAAQ,KAAK,MAAM,QAAQ;EACjC,OAAO,cAAc,GAAG,SAAS,OAAO,QAAQ,iBAAiB,CAAC;CACpE,CACmB,CAAC,CAAC,QAAQ,MAAM;CACnC,IAAI,SAAS,IACX,MAAM,IAAI,MAAM,GAAG,OAAO,8CAA8C;CAG1E,OAAO;EACL,SAAS,GAAG,SAAS,YAAY;EACjC,gBAAgB,cAAc;GAC5B,IAAI,UAAU,WAAW,kBACvB,MAAM,IAAI,MAAM,iDAAiD,UAAU,OAAO,OAAO;GAE3F,MAAM,SAAS,WAAW,KAAK,EAAE;GACjC,OAAO,IAAI,WAAW,WAAW,MAAM,OAAO,gBAAgB;GAC9D,OAAO;EACT;CACF;AACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usebutr/svm",
-  "version": "2.0.2",
+  "version": "3.0.1",
   "description": "Wallet Standard adapter for butr (Solana / SVM).",
   "keywords": [
     "butr",
@@ -35,19 +35,23 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./transaction": {
+      "types": "./dist/transaction.d.ts",
+      "default": "./dist/transaction.js"
     }
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@usebutr/core": "2.0.1",
-    "@usebutr/wallet-standard-shared": "1.0.0"
+    "@usebutr/core": "3.0.1",
+    "@usebutr/wallet-standard-shared": "2.0.1"
   },
   "devDependencies": {
     "@wallet-standard/app": "^1.1.1",
     "typescript": "^7.0.2",
-    "vitest": "^4.1.10",
+    "vitest": "^5.0.1",
     "@repo/config-vitest": "0.0.0",
     "@repo/typescript-config": "0.0.0"
   },