@farcaster/frame-wagmi-connector 0.0.0-canary-20250430150627

package/LICENSE

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

package/README.md

@@ -0,0 +1,33 @@
+# @farcaster/frame-wagmi-connector
+
+A [Wagmi connector](https://wagmi.sh/) for interacting with wallets in Mini Apps.
+
+
+## Installation
+
+[Install and setup wagmi](https://wagmi.sh/react/getting-started#manual-installation).
+
+```bash
+pnpm add @farcaster/frame-wagmi-connector
+```
+
+## Usage
+
+Connect to users wallet:
+
+```
+import { useConnect } from 'wagmi'
+import { farcasterFrame } from "@farcaster/frame-wagmi-connector";
+
+function App() {
+  const { connect } = useConnect()
+
+  return (
+    <button onClick={() => connect({ connector: farcasterFrame() })}>
+      Connect
+    </button>
+  )
+}
+```
+
+You can now interact with the users connected wallet via Wagmi.

package/dist/connector.d.ts

@@ -0,0 +1,444 @@
+export declare function farcasterFrame(): import("@wagmi/core").CreateConnectorFn<{
+    request: import("ox/Provider").RequestFn<{
+        Request: {
+            method: "eth_accounts";
+            params?: undefined;
+        };
+        ReturnType: readonly import("ox/Address").Address[];
+    } | {
+        Request: {
+            method: "eth_blobBaseFee";
+            params?: undefined;
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_blockNumber";
+            params?: undefined;
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_call";
+            params: [transaction: import("ox/TransactionRequest").Rpc] | [transaction: import("ox/TransactionRequest").Rpc, block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier] | [transaction: import("ox/TransactionRequest").Rpc, block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier, stateOverride: unknown];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_chainId";
+            params?: undefined;
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_coinbase";
+            params?: undefined;
+        };
+        ReturnType: import("ox/Address").Address;
+    } | {
+        Request: {
+            method: "eth_estimateGas";
+            params: [transaction: import("ox/TransactionRequest").Rpc] | [transaction: import("ox/TransactionRequest").Rpc, block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier] | [transaction: import("ox/TransactionRequest").Rpc, block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier, stateOverride: unknown];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_feeHistory";
+            params: [blockCount: import("ox/Hex").Hex, newestBlock: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag, rewardPercentiles: number[] | undefined];
+        };
+        ReturnType: import("ox/Fee").FeeHistoryRpc;
+    } | {
+        Request: {
+            method: "eth_gasPrice";
+            params?: undefined;
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_getBalance";
+            params: [address: import("ox/Address").Address, block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_getBlockByHash";
+            params: [hash: import("ox/Hex").Hex, includeTransactionObjects: boolean];
+        };
+        ReturnType: import("ox/Block").Rpc | null;
+    } | {
+        Request: {
+            method: "eth_getBlockByNumber";
+            params: [block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag, includeTransactionObjects: boolean];
+        };
+        ReturnType: import("ox/Block").Rpc | null;
+    } | {
+        Request: {
+            method: "eth_getBlockTransactionCountByHash";
+            params: [hash: import("ox/Hex").Hex];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_getBlockTransactionCountByNumber";
+            params: [block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_getCode";
+            params: [address: import("ox/Address").Address, block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_getFilterChanges";
+            params: [filterId: import("ox/Hex").Hex];
+        };
+        ReturnType: readonly import("ox/Log").Rpc[] | readonly import("ox/Hex").Hex[];
+    } | {
+        Request: {
+            method: "eth_getFilterLogs";
+            params: [filterId: import("ox/Hex").Hex];
+        };
+        ReturnType: readonly import("ox/Log").Rpc[];
+    } | {
+        Request: {
+            method: "eth_getLogs";
+            params: [filter: import("ox/Filter").Rpc];
+        };
+        ReturnType: readonly import("ox/Log").Rpc[];
+    } | {
+        Request: {
+            method: "eth_getProof";
+            params: [address: import("ox/Address").Address, storageKeys: import("ox/Hex").Hex[], block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier];
+        };
+        ReturnType: import("ox/AccountProof").Rpc;
+    } | {
+        Request: {
+            method: "eth_getStorageAt";
+            params: [address: import("ox/Address").Address, index: import("ox/Hex").Hex, block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_getTransactionByBlockHashAndIndex";
+            params: [hash: import("ox/Hex").Hex, index: import("ox/Hex").Hex];
+        };
+        ReturnType: import("ox/Transaction").Rpc | null;
+    } | {
+        Request: {
+            method: "eth_getTransactionByBlockNumberAndIndex";
+            params: [block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag, index: import("ox/Hex").Hex];
+        };
+        ReturnType: import("ox/Transaction").Rpc | null;
+    } | {
+        Request: {
+            method: "eth_getTransactionByHash";
+            params: [hash: import("ox/Hex").Hex];
+        };
+        ReturnType: import("ox/Transaction").Rpc | null;
+    } | {
+        Request: {
+            method: "eth_getTransactionCount";
+            params: [address: import("ox/Address").Address, block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_getTransactionReceipt";
+            params: [hash: import("ox/Hex").Hex];
+        };
+        ReturnType: import("ox/TransactionReceipt").Rpc | null;
+    } | {
+        Request: {
+            method: "eth_getUncleCountByBlockHash";
+            params: [hash: import("ox/Hex").Hex];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_getUncleCountByBlockNumber";
+            params: [block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_maxPriorityFeePerGas";
+            params?: undefined;
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_newBlockFilter";
+            params?: undefined;
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_newFilter";
+            params: [filter: import("ox/Filter").Rpc];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_newPendingTransactionFilter";
+            params?: undefined;
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_protocolVersion";
+            params?: undefined;
+        };
+        ReturnType: string;
+    } | {
+        Request: {
+            method: "eth_requestAccounts";
+            params?: undefined;
+        };
+        ReturnType: readonly import("ox/Address").Address[];
+    } | {
+        Request: {
+            method: "eth_sendRawTransaction";
+            params: [serializedTransaction: import("ox/Hex").Hex];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_sendTransaction";
+            params: [transaction: import("ox/TransactionRequest").Rpc];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_signTransaction";
+            params: [request: import("ox/TransactionRequest").Rpc];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_signTypedData_v4";
+            params: [address: import("ox/Address").Address, message: string];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_uninstallFilter";
+            params: [filterId: import("ox/Hex").Hex];
+        };
+        ReturnType: boolean;
+    } | {
+        Request: {
+            method: "eth_requestAccounts";
+            params?: undefined;
+        };
+        ReturnType: readonly import("ox/Address").Address[];
+    } | {
+        Request: {
+            method: "eth_sendRawTransaction";
+            params: [serializedTransaction: import("ox/Hex").Hex];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_sendTransaction";
+            params: [transaction: import("ox/TransactionRequest").Rpc];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_signTransaction";
+            params: [request: import("ox/TransactionRequest").Rpc];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "eth_signTypedData_v4";
+            params: [address: import("ox/Address").Address, message: string];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "personal_sign";
+            params: [data: import("ox/Hex").Hex, address: import("ox/Address").Address];
+        };
+        ReturnType: import("ox/Hex").Hex;
+    } | {
+        Request: {
+            method: "wallet_addEthereumChain";
+            params: [chain: {
+                chainId: string;
+                chainName: string;
+                nativeCurrency?: {
+                    name: string;
+                    symbol: string;
+                    decimals: number;
+                } | undefined | undefined;
+                rpcUrls: readonly string[];
+                blockExplorerUrls?: readonly string[] | undefined;
+                iconUrls?: readonly string[] | undefined;
+            }];
+        };
+        ReturnType: null;
+    } | {
+        Request: {
+            method: "wallet_getCallsStatus";
+            params?: [string];
+        };
+        ReturnType: {
+            status: "PENDING" | "CONFIRMED";
+            receipts?: readonly {
+                logs: {
+                    address: import("ox/Hex").Hex;
+                    data: import("ox/Hex").Hex;
+                    topics: readonly import("ox/Hex").Hex[];
+                }[];
+                status: import("ox/Hex").Hex;
+                blockHash: import("ox/Hex").Hex;
+                blockNumber: import("ox/Hex").Hex;
+                gasUsed: import("ox/Hex").Hex;
+                transactionHash: import("ox/Hex").Hex;
+            }[] | undefined;
+        };
+    } | {
+        Request: {
+            method: "wallet_getCapabilities";
+            params?: [import("ox/Address").Address];
+        };
+        ReturnType: {
+            [x: `0x${string}`]: {
+                [capability: string]: any;
+            };
+        };
+    } | {
+        Request: {
+            method: "wallet_getPermissions";
+            params?: undefined;
+        };
+        ReturnType: readonly {
+            caveats: readonly {
+                type: string;
+                value: any;
+            }[];
+            date: number;
+            id: string;
+            invoker: `http://${string}` | `https://${string}`;
+            parentCapability: "eth_accounts" | string;
+        }[];
+    } | {
+        Request: {
+            method: "wallet_grantPermissions";
+            params?: [{
+                signer?: {
+                    type: string;
+                    data?: unknown | undefined;
+                } | undefined;
+                permissions: readonly {
+                    data: unknown;
+                    policies: readonly {
+                        data: unknown;
+                        type: string;
+                    }[];
+                    required?: boolean | undefined;
+                    type: string;
+                }[];
+                expiry: number;
+            }];
+        };
+        ReturnType: {
+            expiry: number;
+            factory?: `0x${string}` | undefined | undefined;
+            factoryData?: string | undefined | undefined;
+            grantedPermissions: readonly {
+                data: unknown;
+                policies: readonly {
+                    data: unknown;
+                    type: string;
+                }[];
+                required?: boolean | undefined;
+                type: string;
+            }[];
+            permissionsContext: string;
+            signerData?: {
+                userOpBuilder?: `0x${string}` | undefined;
+                submitToAddress?: `0x${string}` | undefined;
+            } | undefined | undefined;
+        };
+    } | {
+        Request: {
+            method: "wallet_requestPermissions";
+            params: [permissions: {
+                eth_accounts: Record<string, any>;
+            }];
+        };
+        ReturnType: readonly {
+            caveats: readonly {
+                type: string;
+                value: any;
+            }[];
+            date: number;
+            id: string;
+            invoker: `http://${string}` | `https://${string}`;
+            parentCapability: "eth_accounts" | string;
+        }[];
+    } | {
+        Request: {
+            method: "wallet_revokePermissions";
+            params: [permissions: {
+                eth_accounts: Record<string, any>;
+            }];
+        };
+        ReturnType: null;
+    } | {
+        Request: {
+            method: "wallet_sendCalls";
+            params: [{
+                calls: readonly {
+                    to?: import("ox/Address").Address | undefined;
+                    data?: import("ox/Hex").Hex | undefined;
+                    value?: import("ox/Hex").Hex | undefined;
+                }[];
+                capabilities?: {
+                    [capability: string]: any;
+                } | undefined;
+                chainId?: import("ox/Hex").Hex | undefined;
+                from: import("ox/Address").Address;
+                version: string;
+            }];
+        };
+        ReturnType: string;
+    } | {
+        Request: {
+            method: "wallet_showCallsStatus";
+            params: [string];
+        };
+        ReturnType: undefined;
+    } | {
+        Request: {
+            method: "wallet_switchEthereumChain";
+            params: [chain: {
+                chainId: string;
+            }];
+        };
+        ReturnType: null;
+    } | {
+        Request: {
+            method: "wallet_watchAsset";
+            params: [{
+                type: "ERC20";
+                options: {
+                    address: string;
+                    symbol: string;
+                    decimals: number;
+                    image?: string | undefined;
+                };
+            }];
+        };
+        ReturnType: boolean;
+    }>;
+    on: import("ox/Provider").EventListenerFn;
+    removeListener: import("ox/Provider").EventListenerFn;
+}, Record<string, unknown>, Record<string, unknown>>;
+export declare namespace farcasterFrame {
+    var type: "farcasterFrame";
+}

package/dist/connector.js

@@ -0,0 +1,118 @@
+import FrameSDK from '@farcaster/frame-sdk';
+import { ChainNotConfiguredError, createConnector, } from '@wagmi/core';
+import { SwitchChainError, fromHex, getAddress, numberToHex } from 'viem';
+farcasterFrame.type = 'farcasterFrame';
+let accountsChanged;
+let chainChanged;
+let disconnect;
+export function farcasterFrame() {
+    return createConnector((config) => ({
+        id: 'farcaster',
+        name: 'Farcaster',
+        rdns: 'xyz.farcaster.MiniAppWallet',
+        icon: 'https://imagedelivery.net/BXluQx4ige9GuW0Ia56BHw/055c25d6-7fe7-4a49-abf9-49772021cf00/original',
+        type: farcasterFrame.type,
+        async connect({ chainId } = {}) {
+            const provider = await this.getProvider();
+            const accounts = await provider.request({
+                method: 'eth_requestAccounts',
+            });
+            if (!accountsChanged) {
+                accountsChanged = this.onAccountsChanged.bind(this);
+                // @ts-expect-error - provider type is stricter
+                provider.on('accountsChanged', accountsChanged);
+            }
+            if (!chainChanged) {
+                chainChanged = this.onChainChanged.bind(this);
+                provider.on('chainChanged', chainChanged);
+            }
+            if (!disconnect) {
+                disconnect = this.onDisconnect.bind(this);
+                provider.on('disconnect', disconnect);
+            }
+            let currentChainId = await this.getChainId();
+            if (chainId && currentChainId !== chainId) {
+                const chain = await this.switchChain({ chainId });
+                currentChainId = chain.id;
+            }
+            return {
+                accounts: accounts.map((x) => getAddress(x)),
+                chainId: currentChainId,
+            };
+        },
+        async disconnect() {
+            const provider = await this.getProvider();
+            if (accountsChanged) {
+                // @ts-expect-error - provider type is stricter
+                provider.removeListener('accountsChanged', accountsChanged);
+                accountsChanged = undefined;
+            }
+            if (chainChanged) {
+                provider.removeListener('chainChanged', chainChanged);
+                chainChanged = undefined;
+            }
+            if (disconnect) {
+                provider.removeListener('disconnect', disconnect);
+                disconnect = undefined;
+            }
+        },
+        async getAccounts() {
+            const provider = await this.getProvider();
+            const accounts = await provider.request({
+                method: 'eth_accounts',
+            });
+            return accounts.map((x) => getAddress(x));
+        },
+        async getChainId() {
+            const provider = await this.getProvider();
+            const hexChainId = await provider.request({ method: 'eth_chainId' });
+            return fromHex(hexChainId, 'number');
+        },
+        async isAuthorized() {
+            try {
+                const accounts = await this.getAccounts();
+                return !!accounts.length;
+            }
+            catch {
+                return false;
+            }
+        },
+        async switchChain({ chainId }) {
+            const provider = await this.getProvider();
+            const chain = config.chains.find((x) => x.id === chainId);
+            if (!chain) {
+                throw new SwitchChainError(new ChainNotConfiguredError());
+            }
+            await provider.request({
+                method: 'wallet_switchEthereumChain',
+                params: [{ chainId: numberToHex(chainId) }],
+            });
+            // providers should start emitting these events - remove when hosts have upgraded
+            //
+            // explicitly emit this event as a workaround for ethereum provider not
+            // emitting events, can remove once events are flowing
+            config.emitter.emit('change', { chainId });
+            return chain;
+        },
+        onAccountsChanged(accounts) {
+            if (accounts.length === 0) {
+                this.onDisconnect();
+            }
+            else {
+                config.emitter.emit('change', {
+                    accounts: accounts.map((x) => getAddress(x)),
+                });
+            }
+        },
+        onChainChanged(chain) {
+            const chainId = Number(chain);
+            config.emitter.emit('change', { chainId });
+        },
+        async onDisconnect() {
+            config.emitter.emit('disconnect');
+        },
+        async getProvider() {
+            return FrameSDK.wallet.ethProvider;
+        },
+    }));
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { farcasterFrame } from './connector';
+export * from './connector';
+export default farcasterFrame;

package/dist/index.js

@@ -0,0 +1,3 @@
+import { farcasterFrame } from './connector';
+export * from './connector';
+export default farcasterFrame;