@dynamic-labs/solana 0.17.0-RC.10

package/src/Solflare.js

@@ -0,0 +1,62 @@
+import { __awaiter } from '../_virtual/_tslib.js';
+import { bufferToBase64 } from '@dynamic-labs/utils';
+import { SolWalletConnector } from './solWalletConnector.js';
+import { SolProviderHelper } from './solProviderHelper.js';
+
+class Solflare extends SolWalletConnector {
+    constructor() {
+        super(...arguments);
+        this.name = 'Solflare';
+    }
+    isInstalledOnBrowser() {
+        return SolProviderHelper.isInstalledHelper(this.name);
+    }
+    fetchPublicAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return SolProviderHelper.fetchPublicAddressWithName(this.name);
+        });
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield SolProviderHelper.connectWithName(this.name);
+        });
+    }
+    getSigner() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return SolProviderHelper.connectWithName(this.name);
+        });
+    }
+    signMessage(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletAddress = yield this.fetchPublicAddress();
+            if (!walletAddress) {
+                return undefined;
+            }
+            const provider = SolProviderHelper.findProvider(this.name);
+            if (!provider) {
+                return undefined;
+            }
+            const encodedMessage = new TextEncoder().encode(messageToSign);
+            const isSignedMessage = (value) => value.signature !== undefined;
+            yield provider.connect();
+            /**
+             * TODO: Remove the sleep once problem is fixed on Solflare's extension.
+             * Tracked in DYN-442
+             */
+            yield new Promise((resolve) => {
+                setTimeout(resolve, 100);
+            });
+            const rawMessage = yield provider.signMessage(encodedMessage, 'utf8');
+            return isSignedMessage(rawMessage)
+                ? bufferToBase64(rawMessage.signature)
+                : undefined;
+        });
+    }
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return SolProviderHelper.getConnectedAccountsWithName(this.name);
+        });
+    }
+}
+
+export { Solflare };

package/src/index.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var CoinbaseSolana = require('./CoinbaseSolana.cjs');
+var Glow = require('./Glow.cjs');
+var Slope = require('./Slope.cjs');
+var Solflare = require('./Solflare.cjs');
+var index = require('./injected/index.cjs');
+var solWalletConnector = require('./solWalletConnector.cjs');
+var solProviderHelper = require('./solProviderHelper.cjs');
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const SolanaWalletConnectors = (props) => [
+    ...index.injectedWallets,
+    CoinbaseSolana.CoinbaseSolana,
+    Glow.Glow,
+    Slope.Slope,
+    Solflare.Solflare,
+];
+
+exports.SolWalletConnector = solWalletConnector.SolWalletConnector;
+exports.SolProviderHelper = solProviderHelper.SolProviderHelper;
+exports.SolanaWalletConnectors = SolanaWalletConnectors;

package/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './solWalletConnector';
+export * from './solProviderHelper';
+export declare const SolanaWalletConnectors: (props: any) => typeof import("./injected/BraveSol").BraveSol[];

package/src/index.js

@@ -0,0 +1,18 @@
+import { CoinbaseSolana } from './CoinbaseSolana.js';
+import { Glow } from './Glow.js';
+import { Slope } from './Slope.js';
+import { Solflare } from './Solflare.js';
+import { injectedWallets } from './injected/index.js';
+export { SolWalletConnector } from './solWalletConnector.js';
+export { SolProviderHelper } from './solProviderHelper.js';
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const SolanaWalletConnectors = (props) => [
+    ...injectedWallets,
+    CoinbaseSolana,
+    Glow,
+    Slope,
+    Solflare,
+];
+
+export { SolanaWalletConnectors };

package/src/injected/BraveSol.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var solProviderHelper = require('../solProviderHelper.cjs');
+var InjectedWalletBase = require('./InjectedWalletBase.cjs');
+
+class BraveSol extends InjectedWalletBase.InjectedWalletBase {
+    constructor() {
+        super(...arguments);
+        this.name = 'BraveSol';
+    }
+    fetchPublicAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return solProviderHelper.SolProviderHelper.fetchPublicAddressWithName(this.name);
+        });
+    }
+}
+
+exports.BraveSol = BraveSol;

package/src/injected/BraveSol.d.ts

@@ -0,0 +1,5 @@
+import { InjectedWalletBase } from './InjectedWalletBase';
+export declare class BraveSol extends InjectedWalletBase {
+    name: string;
+    fetchPublicAddress(): Promise<string | undefined>;
+}

package/src/injected/BraveSol.js

@@ -0,0 +1,17 @@
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { SolProviderHelper } from '../solProviderHelper.js';
+import { InjectedWalletBase } from './InjectedWalletBase.js';
+
+class BraveSol extends InjectedWalletBase {
+    constructor() {
+        super(...arguments);
+        this.name = 'BraveSol';
+    }
+    fetchPublicAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return SolProviderHelper.fetchPublicAddressWithName(this.name);
+        });
+    }
+}
+
+export { BraveSol };

package/src/injected/ExodusSol.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var InjectedWalletBase = require('./InjectedWalletBase.cjs');
+
+class ExodusSol extends InjectedWalletBase.InjectedWalletBase {
+    constructor() {
+        super(...arguments);
+        this.name = 'ExodusSol';
+    }
+}
+
+exports.ExodusSol = ExodusSol;

package/src/injected/ExodusSol.d.ts

@@ -0,0 +1,4 @@
+import { InjectedWalletBase } from './InjectedWalletBase';
+export declare class ExodusSol extends InjectedWalletBase {
+    name: string;
+}

package/src/injected/ExodusSol.js

@@ -0,0 +1,10 @@
+import { InjectedWalletBase } from './InjectedWalletBase.js';
+
+class ExodusSol extends InjectedWalletBase {
+    constructor() {
+        super(...arguments);
+        this.name = 'ExodusSol';
+    }
+}
+
+export { ExodusSol };

package/src/injected/InjectedWalletBase.cjs

@@ -0,0 +1,68 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var utils = require('@dynamic-labs/utils');
+var solWalletConnector = require('../solWalletConnector.cjs');
+var solProviderHelper = require('../solProviderHelper.cjs');
+
+class InjectedWalletBase extends solWalletConnector.SolWalletConnector {
+    setupEventListeners(listeners) {
+        solProviderHelper.SolProviderHelper._setupEventListeners(listeners, solProviderHelper.SolProviderHelper.findProvider(this.name));
+    }
+    teardownEventListeners() {
+        solProviderHelper.SolProviderHelper._teardownEventListeners(this.name);
+    }
+    connect() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield solProviderHelper.SolProviderHelper.connectWithName(this.name);
+        });
+    }
+    getSigner() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return solProviderHelper.SolProviderHelper.connectWithName(this.name);
+        });
+    }
+    isInstalledOnBrowser() {
+        var _a;
+        /**
+         * When Glow wallet is installed and Phantom isn't, isPhantom will
+         * still be true. This added check is to return false in that scenario.
+         * It relies on the fact that if both Glow and Phantom are enabled,
+         * solana.isGlow will return false.
+         */
+        return (solProviderHelper.SolProviderHelper.isInstalledHelper(this.name) && !((_a = window.solana) === null || _a === void 0 ? void 0 : _a.isGlow));
+    }
+    fetchPublicAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (this.isInstalledOnBrowser()) {
+                return solProviderHelper.SolProviderHelper.fetchPublicAddressWithName(this.name);
+            }
+            const url = encodeURIComponent(window.location.toString());
+            const ref = encodeURIComponent(window.location.origin);
+            // samsung browser only supports native links, not universal links
+            if (utils.isMobile()) {
+                if (utils.isSamsungBrowser()) {
+                    window.location.assign(`phantom://browse/${url}?ref=${ref}`);
+                }
+                else {
+                    window.location.assign(`https://phantom.app/ul/browse/${url}?ref=${ref}`);
+                }
+            }
+            return;
+        });
+    }
+    signMessage(messageToSign) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return solProviderHelper.SolProviderHelper.signMessageWithName(messageToSign, this.name);
+        });
+    }
+    getConnectedAccounts() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return solProviderHelper.SolProviderHelper.getConnectedAccountsWithName(this.name);
+        });
+    }
+}
+
+exports.InjectedWalletBase = InjectedWalletBase;

package/src/injected/InjectedWalletBase.d.ts

@@ -0,0 +1,13 @@
+import { WalletEventListeners } from '@dynamic-labs/wallet-connector-core';
+import { SolWalletConnector } from '../solWalletConnector';
+import { ISolana } from '../types';
+export declare abstract class InjectedWalletBase extends SolWalletConnector {
+    setupEventListeners(listeners: WalletEventListeners): void;
+    teardownEventListeners(): void;
+    connect(): Promise<void>;
+    getSigner(): Promise<ISolana | undefined>;
+    isInstalledOnBrowser(): boolean;
+    fetchPublicAddress(): Promise<string | undefined>;
+    signMessage(messageToSign: string): Promise<string | undefined>;
+    getConnectedAccounts(): Promise<string[]>;
+}

package/src/injected/InjectedWalletBase.js

@@ -0,0 +1,64 @@
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { isMobile, isSamsungBrowser } from '@dynamic-labs/utils';
+import { SolWalletConnector } from '../solWalletConnector.js';
+import { SolProviderHelper } from '../solProviderHelper.js';
+
+class InjectedWalletBase extends SolWalletConnector {
+    setupEventListeners(listeners) {
+        SolProviderHelper._setupEventListeners(listeners, SolProviderHelper.findProvider(this.name));
+    }
+    teardownEventListeners() {
+        SolProviderHelper._teardownEventListeners(this.name);
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield SolProviderHelper.connectWithName(this.name);
+        });
+    }
+    getSigner() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return SolProviderHelper.connectWithName(this.name);
+        });
+    }
+    isInstalledOnBrowser() {
+        var _a;
+        /**
+         * When Glow wallet is installed and Phantom isn't, isPhantom will
+         * still be true. This added check is to return false in that scenario.
+         * It relies on the fact that if both Glow and Phantom are enabled,
+         * solana.isGlow will return false.
+         */
+        return (SolProviderHelper.isInstalledHelper(this.name) && !((_a = window.solana) === null || _a === void 0 ? void 0 : _a.isGlow));
+    }
+    fetchPublicAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isInstalledOnBrowser()) {
+                return SolProviderHelper.fetchPublicAddressWithName(this.name);
+            }
+            const url = encodeURIComponent(window.location.toString());
+            const ref = encodeURIComponent(window.location.origin);
+            // samsung browser only supports native links, not universal links
+            if (isMobile()) {
+                if (isSamsungBrowser()) {
+                    window.location.assign(`phantom://browse/${url}?ref=${ref}`);
+                }
+                else {
+                    window.location.assign(`https://phantom.app/ul/browse/${url}?ref=${ref}`);
+                }
+            }
+            return;
+        });
+    }
+    signMessage(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return SolProviderHelper.signMessageWithName(messageToSign, this.name);
+        });
+    }
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return SolProviderHelper.getConnectedAccountsWithName(this.name);
+        });
+    }
+}
+
+export { InjectedWalletBase };

package/src/injected/Phantom.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var InjectedWalletBase = require('./InjectedWalletBase.cjs');
+
+class Phantom extends InjectedWalletBase.InjectedWalletBase {
+    constructor() {
+        super(...arguments);
+        this.name = 'Phantom';
+    }
+}
+
+exports.Phantom = Phantom;

package/src/injected/Phantom.d.ts

@@ -0,0 +1,4 @@
+import { InjectedWalletBase } from './InjectedWalletBase';
+export declare class Phantom extends InjectedWalletBase {
+    name: string;
+}

package/src/injected/Phantom.js

@@ -0,0 +1,10 @@
+import { InjectedWalletBase } from './InjectedWalletBase.js';
+
+class Phantom extends InjectedWalletBase {
+    constructor() {
+        super(...arguments);
+        this.name = 'Phantom';
+    }
+}
+
+export { Phantom };

package/src/injected/PhantomLedger.cjs

@@ -0,0 +1,70 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var web3_js = require('@solana/web3.js');
+var utils = require('@dynamic-labs/utils');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var extractNonce = require('../utils/extractNonce.cjs');
+var InjectedWalletBase = require('./InjectedWalletBase.cjs');
+
+const MEMO_PROGRAM_ID = new web3_js.PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr');
+class PhantomLedger extends InjectedWalletBase.InjectedWalletBase {
+    constructor() {
+        super(...arguments);
+        /**
+         * I'm exporting the walletName to use it for DYN-1447. As we only need the wallet name,
+         * exporting it in this way, we avoid to instantiate the whole PhantomLedger class every time.
+         */
+        this.name = walletConnectorCore.PhantomLedgerWalletName;
+        this.buildAuthTx = (message) => {
+            const transaction = new web3_js.Transaction();
+            transaction.add(new web3_js.TransactionInstruction({
+                data: Buffer.from(message, 'utf8'),
+                keys: [],
+                programId: MEMO_PROGRAM_ID,
+            }));
+            return transaction;
+        };
+    }
+    signMessage() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            throw new utils.NotSupportedError(`Message signing is currently not supported on ${this.name}
+      You can use signMessageViaTransaction instead to achieve similar functionality
+      by signing a transaction with a memo instruction.
+      You can read more about it here https://github.com/solana-labs/solana/issues/21366`);
+        });
+    }
+    proveOwnership(messageToSign) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const nonce = extractNonce.extractNonce(messageToSign);
+            if (!nonce) {
+                throw new utils.DynamicError('Nonce missing');
+            }
+            return this.signMessageViaTransaction(nonce);
+        });
+    }
+    signMessageViaTransaction(messageToSign) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const address = yield this.fetchPublicAddress();
+            if (!address) {
+                throw new utils.DynamicError('Address missing');
+            }
+            const transaction = this.buildAuthTx(messageToSign);
+            transaction.feePayer = new web3_js.PublicKey(address);
+            transaction.recentBlockhash = (yield this.getWeb3Provider().getLatestBlockhash()).blockhash;
+            const signer = yield this.getSigner();
+            if (!signer) {
+                throw new utils.DynamicError('Signer not found');
+            }
+            const signedTransaction = yield signer.signTransaction(transaction);
+            return JSON.stringify({
+                signedTransaction: signedTransaction.serialize(),
+            });
+        });
+    }
+}
+
+exports.MEMO_PROGRAM_ID = MEMO_PROGRAM_ID;
+exports.PhantomLedger = PhantomLedger;

package/src/injected/PhantomLedger.d.ts

@@ -0,0 +1,14 @@
+import { PublicKey } from '@solana/web3.js';
+import { InjectedWalletBase } from './InjectedWalletBase';
+export declare const MEMO_PROGRAM_ID: PublicKey;
+export declare class PhantomLedger extends InjectedWalletBase {
+    /**
+     * I'm exporting the walletName to use it for DYN-1447. As we only need the wallet name,
+     * exporting it in this way, we avoid to instantiate the whole PhantomLedger class every time.
+     */
+    name: string;
+    signMessage(): Promise<string | undefined>;
+    proveOwnership(messageToSign: string): Promise<string | undefined>;
+    signMessageViaTransaction(messageToSign: string): Promise<string>;
+    private buildAuthTx;
+}

package/src/injected/PhantomLedger.js

@@ -0,0 +1,65 @@
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { PublicKey, Transaction, TransactionInstruction } from '@solana/web3.js';
+import { NotSupportedError, DynamicError } from '@dynamic-labs/utils';
+import { PhantomLedgerWalletName } from '@dynamic-labs/wallet-connector-core';
+import { extractNonce } from '../utils/extractNonce.js';
+import { InjectedWalletBase } from './InjectedWalletBase.js';
+
+const MEMO_PROGRAM_ID = new PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr');
+class PhantomLedger extends InjectedWalletBase {
+    constructor() {
+        super(...arguments);
+        /**
+         * I'm exporting the walletName to use it for DYN-1447. As we only need the wallet name,
+         * exporting it in this way, we avoid to instantiate the whole PhantomLedger class every time.
+         */
+        this.name = PhantomLedgerWalletName;
+        this.buildAuthTx = (message) => {
+            const transaction = new Transaction();
+            transaction.add(new TransactionInstruction({
+                data: Buffer.from(message, 'utf8'),
+                keys: [],
+                programId: MEMO_PROGRAM_ID,
+            }));
+            return transaction;
+        };
+    }
+    signMessage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new NotSupportedError(`Message signing is currently not supported on ${this.name}
+      You can use signMessageViaTransaction instead to achieve similar functionality
+      by signing a transaction with a memo instruction.
+      You can read more about it here https://github.com/solana-labs/solana/issues/21366`);
+        });
+    }
+    proveOwnership(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nonce = extractNonce(messageToSign);
+            if (!nonce) {
+                throw new DynamicError('Nonce missing');
+            }
+            return this.signMessageViaTransaction(nonce);
+        });
+    }
+    signMessageViaTransaction(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield this.fetchPublicAddress();
+            if (!address) {
+                throw new DynamicError('Address missing');
+            }
+            const transaction = this.buildAuthTx(messageToSign);
+            transaction.feePayer = new PublicKey(address);
+            transaction.recentBlockhash = (yield this.getWeb3Provider().getLatestBlockhash()).blockhash;
+            const signer = yield this.getSigner();
+            if (!signer) {
+                throw new DynamicError('Signer not found');
+            }
+            const signedTransaction = yield signer.signTransaction(transaction);
+            return JSON.stringify({
+                signedTransaction: signedTransaction.serialize(),
+            });
+        });
+    }
+}
+
+export { MEMO_PROGRAM_ID, PhantomLedger };

package/src/injected/index.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var BraveSol = require('./BraveSol.cjs');
+var ExodusSol = require('./ExodusSol.cjs');
+var PhantomLedger = require('./PhantomLedger.cjs');
+var Phantom = require('./Phantom.cjs');
+
+const injectedWallets = [BraveSol.BraveSol, ExodusSol.ExodusSol, PhantomLedger.PhantomLedger, Phantom.Phantom];
+
+exports.injectedWallets = injectedWallets;

package/src/injected/index.d.ts

@@ -0,0 +1,2 @@
+import { BraveSol } from './BraveSol';
+export declare const injectedWallets: (typeof BraveSol)[];

package/src/injected/index.js

@@ -0,0 +1,8 @@
+import { BraveSol } from './BraveSol.js';
+import { ExodusSol } from './ExodusSol.js';
+import { PhantomLedger } from './PhantomLedger.js';
+import { Phantom } from './Phantom.js';
+
+const injectedWallets = [BraveSol, ExodusSol, PhantomLedger, Phantom];
+
+export { injectedWallets };