@dynamic-labs/starknet 4.0.0-alpha.8 → 4.0.0

package/src/wallets/injected/fetchStarknetInjectedWalletConnectors.d.ts

@@ -0,0 +1,5 @@
+import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
+import { WalletBookSchema } from '@dynamic-labs/wallet-book';
+export declare const fetchStarknetInjectedWalletConnectors: ({ walletBook, }: {
+    walletBook: WalletBookSchema;
+}) => WalletConnectorConstructor[];

package/src/wallets/injected/fetchStarknetInjectedWalletConnectors.js

@@ -0,0 +1,31 @@
+'use client'
+import { Injected } from './injected.js';
+
+const filteredStarknetWalletKeysOverrides = [
+    // TODO(starknet-v6): Remove once these wallets support v6
+    'bitgetstarknet',
+    // Braavos has its own connector to implement specific logic
+    'braavos',
+];
+const fetchStarknetInjectedWalletConnectors = ({ walletBook, }) => {
+    var _a;
+    return Object.entries((_a = walletBook === null || walletBook === void 0 ? void 0 : walletBook.wallets) !== null && _a !== void 0 ? _a : {})
+        .filter(([key, wallet]) => {
+        var _a;
+        return ((_a = wallet.injectedConfig) === null || _a === void 0 ? void 0 : _a.find((config) => config.chain === 'starknet')) &&
+            !filteredStarknetWalletKeysOverrides.includes(key);
+    })
+        .map(([key, wallet]) => {
+        var _a, _b, _c;
+        const name = wallet.shortName || wallet.name;
+        const walletConnectorFallback = Boolean(wallet.walletConnect);
+        const id = (_c = (_b = (_a = wallet.injectedConfig) === null || _a === void 0 ? void 0 : _a[0].windowLocations) === null || _b === void 0 ? void 0 : _b[0]) !== null && _c !== void 0 ? _c : key;
+        return class extends Injected {
+            constructor(props) {
+                super(name, id, Object.assign({ name, overrideKey: key, walletBookWallet: wallet, walletConnectorFallback }, props));
+            }
+        };
+    });
+};
+
+export { fetchStarknetInjectedWalletConnectors };

package/src/wallets/injected/injected.cjs

@@ -0,0 +1,141 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var typesJs = require('@starknet-io/types-js');
+var utils = require('@dynamic-labs/utils');
+var StarknetWalletConnector = require('../../StarknetWalletConnector.cjs');
+
+class Injected extends StarknetWalletConnector.StarknetWalletConnector {
+    constructor(name, id, props) {
+        super(name, id, props);
+        this.overrideKey = props.overrideKey;
+    }
+    prompt(options) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getWindowWallet();
+            if (!wallet) {
+                throw new utils.DynamicError('No wallet available to send RPC requests to');
+            }
+            this.logger.debug('[prompt] Sending wallet_requestAccounts with silent_mode:', options.silently);
+            const accounts = yield wallet.request({
+                params: {
+                    silent_mode: options.silently,
+                },
+                type: 'wallet_requestAccounts',
+            });
+            this.logger.debug('[prompt] Received from wallet_requestAccounts:', accounts);
+            if (accounts.length === 0) {
+                return {
+                    data: {
+                        account: undefined,
+                        chainId: undefined,
+                    },
+                    wallet,
+                };
+            }
+            const [account] = accounts;
+            this.logger.debug('[prompt] Sending wallet_requestChaindId');
+            const chainId = yield wallet.request({
+                type: 'wallet_requestChainId',
+            });
+            this.logger.debug('[prompt] Received from wallet_requestChainId:', chainId);
+            return {
+                data: {
+                    account,
+                    chainId: BigInt(chainId),
+                },
+                wallet,
+            };
+        });
+    }
+    getAddress() {
+        const _super = Object.create(null, {
+            getAddress: { get: () => super.getAddress }
+        });
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this.isInstalledOnBrowser()) {
+                return _super.getAddress.call(this);
+            }
+            const inAppBrowserBase = (_a = this.walletBookWallet.mobile) === null || _a === void 0 ? void 0 : _a.inAppBrowser;
+            if (!inAppBrowserBase || !utils.isMobile()) {
+                return undefined;
+            }
+            const inAppBrowserTemplate = utils.template(inAppBrowserBase);
+            const deepLink = inAppBrowserTemplate({
+                encodedDappURI: window.location.toString().replace(/http(s)?:\/\//, ''),
+            });
+            window.location.href = deepLink;
+            return undefined;
+        });
+    }
+    getConnectedAccounts() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if ((_a = this.walletData) === null || _a === void 0 ? void 0 : _a.account) {
+                this.logger.debug('[getConnectedAccounts] Found existing account:', this.walletData.account);
+                return [this.walletData.account];
+            }
+            const wallet = this.getWindowWallet();
+            if (!wallet) {
+                return [];
+            }
+            const silently = yield this.shouldPromptSilently(wallet);
+            let data;
+            this.logger.debug('[getConnectedAccounts] No existing account, attempting to connect with silent mode:', silently);
+            try {
+                ({ data } = yield this.prompt({
+                    silently,
+                }));
+            }
+            catch (error) {
+                this.logger.debug(`[getConnectedAccounts] Silent connect errored out: ${error}`);
+                return [];
+            }
+            this.logger.debug(`[getConnectedAccounts] Connect returned account: ${data === null || data === void 0 ? void 0 : data.account}`);
+            if (!(data === null || data === void 0 ? void 0 : data.account)) {
+                return [];
+            }
+            this.walletData = data;
+            this.wallet = wallet;
+            this.setupEventListeners();
+            return [data.account];
+        });
+    }
+    shouldPromptSilently(wallet) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            /**
+             * In general, getConnectedAccounts should send a "silent" request to the wallet, meaning
+             * no popup will be displayed to the user. However, in the case that the user comes back
+             * to the dapp with a locked wallet, we do want to trigger a popup for the user to unlock
+             * their wallet, but only if their wallet has still granted permission to the dapp to access
+             * its data. That's what the following `wallet_getPermissions` RPC request does.
+             */
+            let silently = true;
+            try {
+                const permissions = yield wallet.request({
+                    type: 'wallet_getPermissions',
+                });
+                if (permissions.includes(typesJs.WALLET_API.Permission.ACCOUNTS)) {
+                    this.logger.debug('[getConnectedAccounts] Received `accounts` permission from wallet_getPermissions');
+                    silently = false;
+                }
+            }
+            catch (error) {
+                this.logger.debug('[getConnectedAccounts] `wallet_getPermissions` threw error:', error);
+            }
+            return silently;
+        });
+    }
+    getWindowWallet() {
+        this.logger.debug('[getWindowWallet] Looking for wallet from window:', this.id);
+        const wallet = window[`starknet_${this.id}`];
+        this.logger.debug('[getWindowWallet] Lookup result:', wallet);
+        return wallet;
+    }
+}
+
+exports.Injected = Injected;

package/src/wallets/injected/injected.d.ts

@@ -0,0 +1,10 @@
+import { StarknetWalletConnector } from '../../StarknetWalletConnector';
+import { PromptOptions, PromptResult } from '../../types';
+export declare class Injected extends StarknetWalletConnector {
+    constructor(name: string, id: string, props: any);
+    prompt(options: PromptOptions): Promise<PromptResult>;
+    getAddress(): Promise<string | undefined>;
+    getConnectedAccounts(): Promise<string[]>;
+    private shouldPromptSilently;
+    private getWindowWallet;
+}

package/src/wallets/injected/injected.js

@@ -0,0 +1,137 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { WALLET_API } from '@starknet-io/types-js';
+import { DynamicError, isMobile, template } from '@dynamic-labs/utils';
+import { StarknetWalletConnector } from '../../StarknetWalletConnector.js';
+
+class Injected extends StarknetWalletConnector {
+    constructor(name, id, props) {
+        super(name, id, props);
+        this.overrideKey = props.overrideKey;
+    }
+    prompt(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getWindowWallet();
+            if (!wallet) {
+                throw new DynamicError('No wallet available to send RPC requests to');
+            }
+            this.logger.debug('[prompt] Sending wallet_requestAccounts with silent_mode:', options.silently);
+            const accounts = yield wallet.request({
+                params: {
+                    silent_mode: options.silently,
+                },
+                type: 'wallet_requestAccounts',
+            });
+            this.logger.debug('[prompt] Received from wallet_requestAccounts:', accounts);
+            if (accounts.length === 0) {
+                return {
+                    data: {
+                        account: undefined,
+                        chainId: undefined,
+                    },
+                    wallet,
+                };
+            }
+            const [account] = accounts;
+            this.logger.debug('[prompt] Sending wallet_requestChaindId');
+            const chainId = yield wallet.request({
+                type: 'wallet_requestChainId',
+            });
+            this.logger.debug('[prompt] Received from wallet_requestChainId:', chainId);
+            return {
+                data: {
+                    account,
+                    chainId: BigInt(chainId),
+                },
+                wallet,
+            };
+        });
+    }
+    getAddress() {
+        const _super = Object.create(null, {
+            getAddress: { get: () => super.getAddress }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this.isInstalledOnBrowser()) {
+                return _super.getAddress.call(this);
+            }
+            const inAppBrowserBase = (_a = this.walletBookWallet.mobile) === null || _a === void 0 ? void 0 : _a.inAppBrowser;
+            if (!inAppBrowserBase || !isMobile()) {
+                return undefined;
+            }
+            const inAppBrowserTemplate = template(inAppBrowserBase);
+            const deepLink = inAppBrowserTemplate({
+                encodedDappURI: window.location.toString().replace(/http(s)?:\/\//, ''),
+            });
+            window.location.href = deepLink;
+            return undefined;
+        });
+    }
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if ((_a = this.walletData) === null || _a === void 0 ? void 0 : _a.account) {
+                this.logger.debug('[getConnectedAccounts] Found existing account:', this.walletData.account);
+                return [this.walletData.account];
+            }
+            const wallet = this.getWindowWallet();
+            if (!wallet) {
+                return [];
+            }
+            const silently = yield this.shouldPromptSilently(wallet);
+            let data;
+            this.logger.debug('[getConnectedAccounts] No existing account, attempting to connect with silent mode:', silently);
+            try {
+                ({ data } = yield this.prompt({
+                    silently,
+                }));
+            }
+            catch (error) {
+                this.logger.debug(`[getConnectedAccounts] Silent connect errored out: ${error}`);
+                return [];
+            }
+            this.logger.debug(`[getConnectedAccounts] Connect returned account: ${data === null || data === void 0 ? void 0 : data.account}`);
+            if (!(data === null || data === void 0 ? void 0 : data.account)) {
+                return [];
+            }
+            this.walletData = data;
+            this.wallet = wallet;
+            this.setupEventListeners();
+            return [data.account];
+        });
+    }
+    shouldPromptSilently(wallet) {
+        return __awaiter(this, void 0, void 0, function* () {
+            /**
+             * In general, getConnectedAccounts should send a "silent" request to the wallet, meaning
+             * no popup will be displayed to the user. However, in the case that the user comes back
+             * to the dapp with a locked wallet, we do want to trigger a popup for the user to unlock
+             * their wallet, but only if their wallet has still granted permission to the dapp to access
+             * its data. That's what the following `wallet_getPermissions` RPC request does.
+             */
+            let silently = true;
+            try {
+                const permissions = yield wallet.request({
+                    type: 'wallet_getPermissions',
+                });
+                if (permissions.includes(WALLET_API.Permission.ACCOUNTS)) {
+                    this.logger.debug('[getConnectedAccounts] Received `accounts` permission from wallet_getPermissions');
+                    silently = false;
+                }
+            }
+            catch (error) {
+                this.logger.debug('[getConnectedAccounts] `wallet_getPermissions` threw error:', error);
+            }
+            return silently;
+        });
+    }
+    getWindowWallet() {
+        this.logger.debug('[getWindowWallet] Looking for wallet from window:', this.id);
+        const wallet = window[`starknet_${this.id}`];
+        this.logger.debug('[getWindowWallet] Lookup result:', wallet);
+        return wallet;
+    }
+}
+
+export { Injected };

package/src/wallets/{metamask.cjs → injected/metamask.cjs}

@@ -3,25 +3,30 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var _tslib = require('../../_virtual/_tslib.cjs');
-var utils = require('@dynamic-labs/utils');
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var starknet = require('@starknet-io/get-starknet-core');
 var logger$1 = require('@dynamic-labs/logger');
-var starknetWalletConnector = require('../starknetWalletConnector.cjs');
-var starknetSnap = require('../utils/starknetSnap.cjs');
+var injected = require('./injected.cjs');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var starknet__default = /*#__PURE__*/_interopDefaultLegacy(starknet);
 
 const logger = new logger$1.Logger('MetaMask Starknet Snap', logger$1.LogLevel.INFO);
-class MetaMask extends starknetWalletConnector["default"] {
+class MetaMask extends injected.Injected {
     constructor(opts) {
-        super('MetaMask Starknet', 'metamask_snap', opts);
+        super('MetaMask Starknet', 'metamask', opts);
         this.overrideKey = 'metamaskstarknet';
-        const { providers } = utils.Eip6963ProviderSingleton.get();
-        const metamaskProvider = providers.find((p) => ['io.metamask', 'io.metamask.flask'].includes(p.info.rdns));
-        if (metamaskProvider) {
-            this.provider = metamaskProvider.provider;
-        }
-        if (!window.starknet_metamask_snap && metamaskProvider) {
-            window.starknet_metamask_snap = starknetSnap.createMetaMaskProviderWrapper(metamaskProvider.provider);
-        }
+        starknet__default["default"].discoverVirtualWallets().then(() => {
+            starknet__default["default"].getAvailableWallets().then((wallets) => {
+                const metaMaskProvider = wallets.find((wallet) => wallet.id === 'metamask');
+                if (metaMaskProvider) {
+                    // Justification: Checked with the Snap team, the provider is available on the window object
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    this.provider = metaMaskProvider.provider;
+                }
+            });
+        });
     }
     getNetwork() {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
@@ -101,21 +106,6 @@ class MetaMask extends starknetWalletConnector["default"] {
             this.teardownEventListeners();
         });
     }
-    getConnectedAccounts() {
-        return _tslib.__awaiter(this, void 0, void 0, function* () {
-            const wallet = this.getWallet();
-            if (!wallet) {
-                return [];
-            }
-            const isProviderConnected = this.isProviderConnected();
-            const isPreauthorized = yield wallet.isPreauthorized();
-            const shouldReconnect = !isProviderConnected && isPreauthorized;
-            if (shouldReconnect) {
-                yield this.connect();
-            }
-            return wallet.selectedAddress ? [wallet.selectedAddress] : [];
-        });
-    }
 }
 
 exports.MetaMask = MetaMask;

package/src/wallets/{metamask.d.ts → injected/metamask.d.ts}

@@ -1,6 +1,5 @@
-import { WalletConnectorBase } from '@dynamic-labs/wallet-connector-core';
-import StarknetProvider from '../starknetWalletConnector';
-export declare class MetaMask extends StarknetProvider implements WalletConnectorBase {
+import { Injected } from './injected';
+export declare class MetaMask extends Injected {
     overrideKey: string;
     private currentChainId;
     private intervalId;
@@ -10,5 +9,4 @@ export declare class MetaMask extends StarknetProvider implements WalletConnecto
     setupEventListeners(): void;
     teardownEventListeners(): Promise<void>;
     endSession(): Promise<void>;
-    getConnectedAccounts(): Promise<string[]>;
 }

package/src/wallets/{metamask.js → injected/metamask.js}

@@ -1,23 +1,24 @@
 'use client'
-import { __awaiter } from '../../_virtual/_tslib.js';
-import { Eip6963ProviderSingleton } from '@dynamic-labs/utils';
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import starknet from '@starknet-io/get-starknet-core';
 import { Logger, LogLevel } from '@dynamic-labs/logger';
-import StarknetWalletConnector from '../starknetWalletConnector.js';
-import { createMetaMaskProviderWrapper } from '../utils/starknetSnap.js';
+import { Injected } from './injected.js';
 
 const logger = new Logger('MetaMask Starknet Snap', LogLevel.INFO);
-class MetaMask extends StarknetWalletConnector {
+class MetaMask extends Injected {
     constructor(opts) {
-        super('MetaMask Starknet', 'metamask_snap', opts);
+        super('MetaMask Starknet', 'metamask', opts);
         this.overrideKey = 'metamaskstarknet';
-        const { providers } = Eip6963ProviderSingleton.get();
-        const metamaskProvider = providers.find((p) => ['io.metamask', 'io.metamask.flask'].includes(p.info.rdns));
-        if (metamaskProvider) {
-            this.provider = metamaskProvider.provider;
-        }
-        if (!window.starknet_metamask_snap && metamaskProvider) {
-            window.starknet_metamask_snap = createMetaMaskProviderWrapper(metamaskProvider.provider);
-        }
+        starknet.discoverVirtualWallets().then(() => {
+            starknet.getAvailableWallets().then((wallets) => {
+                const metaMaskProvider = wallets.find((wallet) => wallet.id === 'metamask');
+                if (metaMaskProvider) {
+                    // Justification: Checked with the Snap team, the provider is available on the window object
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    this.provider = metaMaskProvider.provider;
+                }
+            });
+        });
     }
     getNetwork() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -97,21 +98,6 @@ class MetaMask extends StarknetWalletConnector {
             this.teardownEventListeners();
         });
     }
-    getConnectedAccounts() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const wallet = this.getWallet();
-            if (!wallet) {
-                return [];
-            }
-            const isProviderConnected = this.isProviderConnected();
-            const isPreauthorized = yield wallet.isPreauthorized();
-            const shouldReconnect = !isProviderConnected && isPreauthorized;
-            if (shouldReconnect) {
-                yield this.connect();
-            }
-            return wallet.selectedAddress ? [wallet.selectedAddress] : [];
-        });
-    }
 }
 
 export { MetaMask };