@solana/kit-plugin-wallet 0.0.0 → 0.12.0

package/dist/types/wallet.d.ts

@@ -0,0 +1,133 @@
+import { type ClientWithIdentity, type ClientWithPayer, type ClientWithSubscribeToIdentity, type ClientWithSubscribeToPayer } from '@solana/kit';
+import type { ClientWithWallet, WalletPluginConfig } from './types';
+/**
+ * A framework-agnostic Kit plugin that manages wallet discovery, connection
+ * lifecycle, and signer creation using wallet-standard — and syncs the
+ * connected wallet's signer to both `client.payer` and `client.identity`.
+ *
+ * This is the most common entrypoint for dApps. When a signing-capable
+ * wallet is connected, `client.payer` and `client.identity` both return the
+ * wallet signer. When disconnected or read-only, accessing either throws.
+ *
+ * Because the signer is dynamic, both `client.subscribeToPayer` and
+ * `client.subscribeToIdentity` are installed so reactive consumers can observe
+ * changes (the Kit reactive-capability convention).
+ *
+ * **SSR-safe.** Can be included in a shared client chain that runs on both
+ * server and browser.
+ *
+ * ```ts
+ * const client = createClient()
+ *   .use(walletSigner({ chain: 'solana:mainnet' }))
+ *   .use(solanaRpc({ rpcUrl: 'https://api.mainnet-beta.solana.com' }))
+ *   .use(planAndSendTransactions());
+ * ```
+ *
+ * @param config - Plugin configuration.
+ *
+ * @see {@link walletPayer}
+ * @see {@link walletIdentity}
+ * @see {@link walletWithoutSigner}
+ * @see {@link WalletPluginConfig}
+ */
+export declare function walletSigner(config: WalletPluginConfig): <T extends object & {
+    wallet?: never;
+}>(client: T) => Disposable & Omit<T, "wallet" | "payer" | "identity" | "subscribeToIdentity" | "subscribeToPayer"> & ClientWithIdentity & ClientWithPayer & ClientWithSubscribeToIdentity & ClientWithSubscribeToPayer & ClientWithWallet;
+/**
+ * A framework-agnostic Kit plugin that manages wallet discovery, connection
+ * lifecycle, and signer creation using wallet-standard — and syncs the
+ * connected wallet's signer to `client.identity`.
+ *
+ * Use this when `client.payer` is controlled by a separate `payer()` plugin
+ * (e.g. a backend relayer pays fees, but the user's wallet is the identity).
+ *
+ * Because the signer is dynamic, `client.subscribeToIdentity` is installed so
+ * reactive consumers can observe changes (the Kit reactive-capability convention).
+ *
+ * **SSR-safe.** Can be included in a shared client chain that runs on both
+ * server and browser.
+ *
+ * ```ts
+ * const client = createClient()
+ *   .use(payer(relayerKeypair))
+ *   .use(walletIdentity({ chain: 'solana:mainnet' }))
+ *   .use(solanaRpc({ rpcUrl: 'https://api.mainnet-beta.solana.com' }))
+ *   .use(planAndSendTransactions());
+ * ```
+ *
+ * @param config - Plugin configuration.
+ *
+ * @see {@link walletSigner}
+ * @see {@link walletPayer}
+ * @see {@link walletWithoutSigner}
+ * @see {@link WalletPluginConfig}
+ */
+export declare function walletIdentity(config: WalletPluginConfig): <T extends object & {
+    wallet?: never;
+}>(client: T) => Disposable & Omit<T, "wallet" | "identity" | "subscribeToIdentity"> & ClientWithIdentity & ClientWithSubscribeToIdentity & ClientWithWallet;
+/**
+ * A framework-agnostic Kit plugin that manages wallet discovery, connection
+ * lifecycle, and signer creation using wallet-standard — and syncs the
+ * connected wallet's signer to `client.payer`.
+ *
+ * Use this when you need the wallet as the fee payer but don't need
+ * `client.identity`. For most dApps, prefer {@link walletSigner} which
+ * sets both.
+ *
+ * Because the signer is dynamic, `client.subscribeToPayer` is installed so
+ * reactive consumers can observe changes (the Kit reactive-capability convention).
+ *
+ * **SSR-safe.** Can be included in a shared client chain that runs on both
+ * server and browser.
+ *
+ * ```ts
+ * const client = createClient()
+ *   .use(walletPayer({ chain: 'solana:mainnet' }))
+ *   .use(solanaRpc({ rpcUrl: 'https://api.mainnet-beta.solana.com' }))
+ *   .use(planAndSendTransactions());
+ * ```
+ *
+ * @param config - Plugin configuration.
+ *
+ * @see {@link walletSigner}
+ * @see {@link walletIdentity}
+ * @see {@link walletWithoutSigner}
+ * @see {@link WalletPluginConfig}
+ */
+export declare function walletPayer(config: WalletPluginConfig): <T extends object & {
+    wallet?: never;
+}>(client: T) => Disposable & Omit<T, "wallet" | "payer" | "subscribeToPayer"> & ClientWithPayer & ClientWithSubscribeToPayer & ClientWithWallet;
+/**
+ * A framework-agnostic Kit plugin that manages wallet discovery, connection
+ * lifecycle, and signer creation using wallet-standard.
+ *
+ * Adds the `wallet` namespace to the client without setting `client.payer`
+ * or `client.identity`. Use this alongside separate `payer()` and/or
+ * `identity()` plugins, or when the wallet's signer is used explicitly in
+ * instructions. For most dApps, prefer {@link walletSigner} instead.
+ *
+ * **SSR-safe.** Can be included in a shared client chain that runs on both
+ * server and browser.
+ *
+ * ```ts
+ * const client = createClient()
+ *   .use(payer(backendKeypair))
+ *   .use(walletWithoutSigner({ chain: 'solana:mainnet' }))
+ *   .use(solanaRpc({ rpcUrl: 'https://api.mainnet-beta.solana.com' }))
+ *   .use(planAndSendTransactions());
+ *
+ * // client.payer is always backendKeypair
+ * // client.wallet.getState().connected?.signer for manual use
+ * ```
+ *
+ * @param config - Plugin configuration.
+ *
+ * @see {@link walletSigner}
+ * @see {@link walletPayer}
+ * @see {@link walletIdentity}
+ * @see {@link WalletPluginConfig}
+ */
+export declare function walletWithoutSigner(config: WalletPluginConfig): <T extends object & {
+    wallet?: never;
+}>(client: T) => Disposable & Omit<T, "wallet"> & ClientWithWallet;
+//# sourceMappingURL=wallet.d.ts.map

package/dist/types/wallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../src/wallet.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,6BAA6B,EAClC,KAAK,0BAA0B,EAMlC,MAAM,aAAa,CAAC;AAGrB,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAgEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,kBAAkB,IAtD3C,CAAC;aAA6B,KAAK;2OA8D9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,kBAAkB,IA7F7C,CAAC;aAA6B,KAAK;6JA+F9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,kBAAkB,IA9H1C,CAAC;aAA6B,KAAK;iJAgI9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,kBAAkB,IAhKlD,CAAC;aAA6B,KAAK;mEAkK9C"}

package/package.json

@@ -1,12 +1,78 @@
 {
   "name": "@solana/kit-plugin-wallet",
-  "version": "0.0.0",
-  "description": "",
-  "license": "ISC",
-  "author": "",
+  "version": "0.12.0",
+  "description": "Wallet connection plugin for Kit clients",
+  "keywords": [
+    "kit",
+    "plugin",
+    "signer",
+    "solana",
+    "wallet",
+    "wallet-adapter",
+    "wallet-standard"
+  ],
+  "bugs": {
+    "url": "http://github.com/anza-xyz/kit-plugins/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anza-xyz/kit-plugins"
+  },
+  "files": [
+    "./dist/types",
+    "./dist/index.*",
+    "./src/"
+  ],
   "type": "commonjs",
-  "main": "index.js",
+  "sideEffects": false,
+  "main": "./dist/index.node.cjs",
+  "module": "./dist/index.node.mjs",
+  "browser": {
+    "./dist/index.node.cjs": "./dist/index.browser.cjs",
+    "./dist/index.node.mjs": "./dist/index.browser.mjs"
+  },
+  "types": "./dist/types/index.d.ts",
+  "react-native": "./dist/index.react-native.mjs",
+  "exports": {
+    "types": "./dist/types/index.d.ts",
+    "react-native": "./dist/index.react-native.mjs",
+    "browser": {
+      "import": "./dist/index.browser.mjs",
+      "require": "./dist/index.browser.cjs"
+    },
+    "node": {
+      "import": "./dist/index.node.mjs",
+      "require": "./dist/index.node.cjs"
+    }
+  },
+  "dependencies": {
+    "@solana/wallet-account-signer": "^6.10.0",
+    "@solana/wallet-standard-chains": "^1.1.2",
+    "@solana/wallet-standard-features": "^1.4.0",
+    "@wallet-standard/app": "^1.1.1",
+    "@wallet-standard/base": "^1.1.1",
+    "@wallet-standard/features": "^1.1.1",
+    "@wallet-standard/ui": "^1.0.3",
+    "@wallet-standard/ui-features": "^1.0.3",
+    "@wallet-standard/ui-registry": "^1.1.1"
+  },
+  "devDependencies": {
+    "@wallet-standard/errors": "^0.1.2"
+  },
+  "peerDependencies": {
+    "@solana/kit": "^6.10.0"
+  },
+  "browserslist": [
+    "supports bigint and not dead",
+    "maintained node versions"
+  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "rimraf dist && tsup && tsc -p ./tsconfig.declarations.json",
+    "dev": "vitest --project node",
+    "test": "pnpm test:types && pnpm test:treeshakability && pnpm test:unit",
+    "test:treeshakability": "for file in dist/index.*.mjs; do agadoo $file; done",
+    "test:types": "tsc --noEmit",
+    "test:unit": "vitest run"
   }
-}
+}

package/src/__typetests__/wallet-typetest.ts

@@ -0,0 +1,114 @@
+import {
+    type ClientWithIdentity,
+    type ClientWithPayer,
+    type ClientWithSubscribeToIdentity,
+    type ClientWithSubscribeToPayer,
+    createClient,
+    TransactionSigner,
+} from '@solana/kit';
+
+import { ClientWithWallet } from '../types';
+import { walletIdentity, walletPayer, walletSigner, walletWithoutSigner } from '../wallet';
+
+const config = { chain: 'solana:mainnet' as const };
+
+const signer = null as unknown as TransactionSigner;
+
+// [DESCRIBE] walletSigner
+{
+    // It sets payer, identity, and wallet on the client.
+    {
+        const client = createClient().use(walletSigner(config));
+        client.payer satisfies ClientWithPayer['payer'];
+        client.identity satisfies ClientWithIdentity['identity'];
+        client.wallet satisfies ClientWithWallet['wallet'];
+        client.subscribeToPayer satisfies ClientWithSubscribeToPayer['subscribeToPayer'];
+        client.subscribeToIdentity satisfies ClientWithSubscribeToIdentity['subscribeToIdentity'];
+    }
+}
+
+// [DESCRIBE] walletPayer
+{
+    // It sets payer and wallet on the client.
+    {
+        const client = createClient().use(walletPayer(config));
+        client.payer satisfies ClientWithPayer['payer'];
+        client.wallet satisfies ClientWithWallet['wallet'];
+        client.subscribeToPayer satisfies ClientWithSubscribeToPayer['subscribeToPayer'];
+        // @ts-expect-error walletPayer does not install subscribeToIdentity.
+        void client.subscribeToIdentity;
+    }
+    // It does not strip a previously-set identity.
+    {
+        const base = { identity: signer } as unknown as ClientWithIdentity;
+        const result = walletPayer(config)(base);
+        result.identity satisfies TransactionSigner;
+    }
+}
+
+// [DESCRIBE] walletIdentity
+{
+    // It sets identity and wallet on the client.
+    {
+        const client = createClient().use(walletIdentity(config));
+        client.identity satisfies ClientWithIdentity['identity'];
+        client.wallet satisfies ClientWithWallet['wallet'];
+        client.subscribeToIdentity satisfies ClientWithSubscribeToIdentity['subscribeToIdentity'];
+        // @ts-expect-error walletIdentity does not install subscribeToPayer.
+        void client.subscribeToPayer;
+    }
+    // It does not strip a previously-set payer.
+    {
+        const base = { payer: signer } as unknown as ClientWithPayer;
+        const result = walletIdentity(config)(base);
+        result.payer satisfies TransactionSigner;
+    }
+}
+
+// [DESCRIBE] walletWithoutSigner
+{
+    // It sets wallet on the client.
+    {
+        const client = createClient().use(walletWithoutSigner(config));
+        client.wallet satisfies ClientWithWallet['wallet'];
+        // @ts-expect-error walletWithoutSigner does not install subscribeToPayer.
+        void client.subscribeToPayer;
+        // @ts-expect-error walletWithoutSigner does not install subscribeToIdentity.
+        void client.subscribeToIdentity;
+    }
+    // It does not strip a previously-set payer.
+    {
+        const base = { payer: signer } as unknown as ClientWithPayer;
+        const result = walletWithoutSigner(config)(base);
+        result.payer satisfies TransactionSigner;
+    }
+    // It does not strip a previously-set identity.
+    {
+        const base = { identity: signer } as unknown as ClientWithIdentity;
+        const result = walletWithoutSigner(config)(base);
+        result.identity satisfies TransactionSigner;
+    }
+    // It does not strip a previously-set payer and identity.
+    {
+        const base = { identity: signer, payer: signer } as unknown as ClientWithIdentity & ClientWithPayer;
+        const result = walletWithoutSigner(config)(base);
+        result.payer satisfies TransactionSigner;
+        result.identity satisfies TransactionSigner;
+    }
+}
+
+// [DESCRIBE] Only one wallet plugin allowed
+{
+    // It fails to typecheck when a wallet plugin is used on a client that already has wallet.
+    {
+        const client = createClient().use(walletSigner(config));
+        // @ts-expect-error Cannot use a second wallet plugin.
+        walletSigner(config)(client);
+        // @ts-expect-error Cannot use a second wallet plugin.
+        walletPayer(config)(client);
+        // @ts-expect-error Cannot use a second wallet plugin.
+        walletIdentity(config)(client);
+        // @ts-expect-error Cannot use a second wallet plugin.
+        walletWithoutSigner(config)(client);
+    }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './wallet';