@dynamic-labs/solana 0.0.0-exp20240808.0

package/src/phantomRedirect/PhantomRedirect.js

@@ -0,0 +1,328 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import nacl from 'tweetnacl';
+import bs58 from 'bs58';
+import { PublicKey, Transaction } from '@solana/web3.js';
+import { SolWalletConnector } from '../solWalletConnector.js';
+import { fetchCluster, buildUrl, decryptPayload, encryptPayload } from './utils.js';
+import { storage, clearStorage } from './storage.js';
+
+class PhantomRedirect extends SolWalletConnector {
+    constructor(props) {
+        super(Object.assign({}, props));
+        this.name = 'Phantom';
+        this.overrideKey = 'phantom';
+    }
+    getMethod() {
+        throw new Error('Method not implemented.');
+    }
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = storage.address.get();
+            if (address) {
+                return address;
+            }
+            yield this.connect();
+            return undefined;
+        });
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            // Generate a new key pair
+            const keyPair = nacl.box.keyPair();
+            storage.encryptionPublicKey.set(keyPair.publicKey);
+            storage.encryptionSecretKey.set(keyPair.secretKey);
+            const isLocalHost = window.location.href.includes('localhost') ||
+                window.location.href.includes('0.0.0.0') ||
+                window.location.href.includes('127.0.0.1');
+            const rpc = (_b = (_a = this.solNetworks[0].privateCustomerRpcUrls) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : this.solNetworks[0].rpcUrls[0];
+            const params = new URLSearchParams({
+                app_url: isLocalHost ? 'https://demo.dynamic.xyz' : window.location.href,
+                cluster: yield fetchCluster(rpc),
+                dapp_encryption_public_key: bs58.encode(keyPair.publicKey),
+                redirect_link: window.location.href,
+            });
+            const url = buildUrl('connect', params);
+            window.location.href = url;
+        });
+    }
+    getSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = new URLSearchParams(window.location.search);
+            const { data, nonce, phantom_encryption_public_key: phantomEncryptionPublicKey, encryptionSecretKey, } = this.getInputsOrThrow('getSession', ['data', 'nonce', 'phantom_encryption_public_key'], ['encryptionSecretKey']);
+            const sharedSecret = nacl.box.before(bs58.decode(phantomEncryptionPublicKey), encryptionSecretKey);
+            storage.sharedSecret.set(sharedSecret);
+            const connectData = decryptPayload(data, nonce, sharedSecret);
+            storage.session.set(connectData.session);
+            storage.address.set(new PublicKey(connectData.public_key));
+            params.delete('phantom_encryption_public_key');
+            params.delete('data');
+            params.delete('nonce');
+            history.replaceState(null, '', `${window.location.origin}${window.location.pathname}?${params.toString()}`);
+            return connectData.public_key;
+        });
+    }
+    signMessage(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { session, sharedSecret, encryptionPublicKey } = this.getInputsOrThrow('signMessage', [], ['session', 'sharedSecret', 'encryptionPublicKey']);
+            storage.message.set(messageToSign);
+            const payload = {
+                message: bs58.encode(Buffer.from(messageToSign)),
+                session,
+            };
+            const [nonce, encryptedPayload] = encryptPayload(payload, sharedSecret);
+            const params = new URLSearchParams({
+                dapp_encryption_public_key: bs58.encode(encryptionPublicKey),
+                nonce: bs58.encode(nonce),
+                payload: bs58.encode(encryptedPayload),
+                redirect_link: window.location.href,
+            });
+            const url = buildUrl('signMessage', params);
+            storage.method.set('signMessage');
+            window.location.href = url;
+            // throwing this to prevent local storage from being cleared.
+            // when verifying signature, the SDK calls endSession when no
+            // signature is returned. in the case of phantom mobile, a signature
+            // is not returned from signMessage, so an error will always be thrown.
+            // this is a workaround to prevent the SDK from clearing local storage
+            // ideally we would figure out how to:
+            //   1. kick off the sign message on one tab
+            //   2. resume the process on that tab after the user signs in phantom
+            throw new Error('ignore');
+        });
+    }
+    extractSignature() {
+        const params = new URLSearchParams(window.location.search);
+        const { data, nonce, sharedSecret, message } = this.getInputsOrThrow('extractSignature', ['data', 'nonce'], ['sharedSecret', 'message']);
+        const signMessageData = decryptPayload(data, nonce, sharedSecret);
+        params.delete('data');
+        params.delete('nonce');
+        history.replaceState(null, '', `${window.location.origin}${window.location.pathname}?${params.toString()}`);
+        return {
+            message,
+            signature: signMessageData.signature,
+        };
+    }
+    extractTransactions() {
+        const params = new URLSearchParams(window.location.search);
+        const { data, nonce, sharedSecret } = this.getInputsOrThrow('extractTransactions', ['data', 'nonce'], ['sharedSecret']);
+        const signAllTransactionsData = decryptPayload(data, nonce, sharedSecret);
+        const decodedTransactions = signAllTransactionsData.transactions.map((t) => Transaction.from(bs58.decode(t)));
+        params.delete('data');
+        params.delete('nonce');
+        history.replaceState(null, '', `${window.location.origin}${window.location.pathname}?${params.toString()}`);
+        return decodedTransactions;
+    }
+    extractTransaction() {
+        const params = new URLSearchParams(window.location.search);
+        const { data, nonce, sharedSecret } = this.getInputsOrThrow('extractTransaction', ['data', 'nonce'], ['sharedSecret']);
+        const signTransactionData = decryptPayload(data, nonce, sharedSecret);
+        const decodedTransaction = Transaction.from(bs58.decode(signTransactionData.transaction));
+        params.delete('data');
+        params.delete('nonce');
+        history.replaceState(null, '', `${window.location.origin}${window.location.pathname}?${params.toString()}`);
+        return decodedTransaction;
+    }
+    consumeMethod() {
+        const method = storage.method.get();
+        storage.method.remove();
+        return method;
+    }
+    getSigner() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = storage.address.get();
+            if (!address) {
+                return undefined;
+            }
+            return {
+                addListener: () => {
+                    throw new Error('Not implemented');
+                },
+                connect: () => {
+                    throw new Error('Not implemented');
+                },
+                disconnect: () => {
+                    throw new Error('Not implemented');
+                },
+                emit: () => {
+                    throw new Error('Not implemented');
+                },
+                eventNames: () => {
+                    throw new Error('Not implemented');
+                },
+                isBackpack: false,
+                isBraveWallet: false,
+                isConnected: true,
+                isExodus: false,
+                isGlow: false,
+                isMagicEden: false,
+                isPhantom: true,
+                isSolflare: false,
+                listenerCount: () => {
+                    throw new Error('Not implemented');
+                },
+                listeners: () => {
+                    throw new Error('Not implemented');
+                },
+                off: () => {
+                    throw new Error('Not implemented');
+                },
+                on: () => {
+                    throw new Error('Not implemented');
+                },
+                once: () => {
+                    throw new Error('Not implemented');
+                },
+                providers: [],
+                publicKey: new PublicKey(address),
+                removeAllListeners: () => {
+                    throw new Error('Not implemented');
+                },
+                removeListener: () => {
+                    throw new Error('Not implemented');
+                },
+                signAllTransactions: (transactions) => __awaiter(this, void 0, void 0, function* () {
+                    const serializedTransactions = transactions.map((t) => bs58.encode(t.serialize({
+                        requireAllSignatures: false,
+                    })));
+                    const { session, sharedSecret, encryptionPublicKey } = this.getInputsOrThrow('signAllTransactions', [], ['session', 'sharedSecret', 'encryptionPublicKey']);
+                    const payload = {
+                        session,
+                        transactions: serializedTransactions,
+                    };
+                    const [nonce, encryptedPayload] = encryptPayload(payload, sharedSecret);
+                    const params = new URLSearchParams({
+                        dapp_encryption_public_key: bs58.encode(encryptionPublicKey),
+                        nonce: bs58.encode(nonce),
+                        payload: bs58.encode(encryptedPayload),
+                        redirect_link: window.location.href,
+                    });
+                    const url = buildUrl('signAllTransactions', params);
+                    window.location.href = url;
+                    // actual signatures will be retrieved upon redirect back to dapp
+                    return [];
+                }),
+                signAndSendTransaction: (transaction, options) => __awaiter(this, void 0, void 0, function* () {
+                    const { session, sharedSecret, encryptionPublicKey } = this.getInputsOrThrow('signAndSendTransaction', [], ['session', 'sharedSecret', 'encryptionPublicKey']);
+                    const payload = {
+                        options,
+                        session,
+                        transaction: bs58.encode(transaction.serialize({ requireAllSignatures: false })),
+                    };
+                    const [nonce, encryptedPayload] = encryptPayload(payload, sharedSecret);
+                    const params = new URLSearchParams({
+                        dapp_encryption_public_key: bs58.encode(encryptionPublicKey),
+                        nonce: bs58.encode(nonce),
+                        payload: bs58.encode(encryptedPayload),
+                        redirect_link: window.location.href,
+                    });
+                    const url = buildUrl('signAndSendTransaction', params);
+                    storage.method.set('signAndSendTransaction');
+                    window.location.href = url;
+                    // actual signature will be retrived upon redirect back to dapp
+                    return { signature: '' };
+                }),
+                signMessage: (message) => __awaiter(this, void 0, void 0, function* () {
+                    const { session, sharedSecret, encryptionPublicKey } = this.getInputsOrThrow('signMessage', [], ['session', 'sharedSecret', 'encryptionPublicKey']);
+                    const payload = {
+                        message: bs58.encode(Buffer.from(message)),
+                        session,
+                    };
+                    const [nonce, encryptedPayload] = encryptPayload(payload, sharedSecret);
+                    const params = new URLSearchParams({
+                        dapp_encryption_public_key: bs58.encode(encryptionPublicKey),
+                        nonce: bs58.encode(nonce),
+                        payload: bs58.encode(encryptedPayload),
+                        redirect_link: window.location.href,
+                    });
+                    const url = buildUrl('signMessage', params);
+                    window.location.href = url;
+                    // actual signature will be retrived upon redirect back to dapp
+                    return Buffer.from('');
+                }),
+                signTransaction: (transaction) => __awaiter(this, void 0, void 0, function* () {
+                    const serializedTransaction = bs58.encode(transaction.serialize({
+                        requireAllSignatures: false,
+                    }));
+                    const { session, sharedSecret, encryptionPublicKey } = this.getInputsOrThrow('signTransaction', [], ['session', 'sharedSecret', 'encryptionPublicKey']);
+                    const payload = {
+                        session,
+                        transaction: serializedTransaction,
+                    };
+                    const [nonce, encryptedPayload] = encryptPayload(payload, sharedSecret);
+                    const params = new URLSearchParams({
+                        dapp_encryption_public_key: bs58.encode(encryptionPublicKey),
+                        nonce: bs58.encode(nonce),
+                        payload: bs58.encode(encryptedPayload),
+                        redirect_link: window.location.href,
+                    });
+                    const url = buildUrl('signTransaction', params);
+                    window.location.href = url;
+                    return transaction;
+                }),
+            };
+        });
+    }
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = storage.address.get();
+            return address ? [address] : [];
+        });
+    }
+    endSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = storage.address.get();
+            const session = storage.session.get();
+            const sharedSecret = storage.sharedSecret.get();
+            const encryptionPublicKey = storage.encryptionPublicKey.get();
+            // Clear all local storage in case of any stale state
+            clearStorage();
+            // if there is no session/encrytion keys, then we don't need to disconnect
+            if (!address || !session || !encryptionPublicKey || !sharedSecret)
+                return;
+            const payload = { session };
+            const [nonce, encryptedPayload] = encryptPayload(payload, sharedSecret);
+            const params = new URLSearchParams({
+                dapp_encryption_public_key: bs58.encode(encryptionPublicKey),
+                nonce: bs58.encode(nonce),
+                payload: bs58.encode(encryptedPayload),
+                redirect_link: window.location.href,
+            });
+            const url = buildUrl('disconnect', params);
+            window.location.href = url;
+        });
+    }
+    /**
+     * Helper method to get inputs from query params and localstorage
+     *
+     * The second argument is used to read values from the query string
+     *   e.g. ['data', 'nonce'] -> params.get('data') and params.get('nonce')
+     *
+     * The third argument is used to read values from local storage
+     *   e.g. ['address', 'message'] -> storage.address.get() and storage.message.get()
+     *
+     * Throws an error if any of the inputs are unable to be found in their respective locations
+     */
+    getInputsOrThrow(methodName, queryParams, storageParams) {
+        const inputs = {};
+        const queryString = new URLSearchParams(window.location.search);
+        queryParams.forEach((param) => {
+            const value = queryString.get(param);
+            if (!value) {
+                throw new Error(`[PhantomRedirect] ${methodName} called, but required input '${param}' not found in query params`);
+            }
+            inputs[param] = value;
+        });
+        storageParams.forEach((storageParam) => {
+            const value = storage[storageParam].get();
+            if (!value) {
+                throw new Error(`[PhantomRedirect] ${methodName} called, but required input '${storageParam}' not found in local storage`);
+            }
+            inputs[storageParam] = value;
+        });
+        return inputs;
+    }
+}
+
+export { PhantomRedirect };

package/src/phantomRedirect/storage.cjs

@@ -0,0 +1,96 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const storage = {
+    address: {
+        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_wallet_address')) !== null && _a !== void 0 ? _a : undefined; },
+        remove: () => {
+            localStorage.removeItem('dynamic_phantom_wallet_address');
+        },
+        set: (address) => {
+            localStorage.setItem('dynamic_phantom_wallet_address', address.toString());
+        },
+    },
+    encryptionPublicKey: {
+        get: () => {
+            const rawPublicKey = localStorage.getItem('dynamic_phantom_public_key');
+            if (!rawPublicKey) {
+                return undefined;
+            }
+            return new Uint8Array(JSON.parse(rawPublicKey));
+        },
+        remove: () => {
+            localStorage.removeItem('dynamic_phantom_public_key');
+        },
+        set: (publicKey) => {
+            localStorage.setItem('dynamic_phantom_public_key', JSON.stringify([...publicKey]));
+        },
+    },
+    encryptionSecretKey: {
+        get: () => {
+            const rawSecretKey = localStorage.getItem('dynamic_phantom_secret_key');
+            if (!rawSecretKey) {
+                return undefined;
+            }
+            return new Uint8Array(JSON.parse(rawSecretKey));
+        },
+        remove: () => {
+            localStorage.removeItem('dynamic_phantom_secret_key');
+        },
+        set: (secretKey) => {
+            localStorage.setItem('dynamic_phantom_secret_key', JSON.stringify([...secretKey]));
+        },
+    },
+    message: {
+        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_message_to_sign')) !== null && _a !== void 0 ? _a : undefined; },
+        remove: () => {
+            localStorage.removeItem('dynamic_phantom_message_to_sign');
+        },
+        set: (message) => {
+            localStorage.setItem('dynamic_phantom_message_to_sign', message);
+        },
+    },
+    method: {
+        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_method')) !== null && _a !== void 0 ? _a : undefined; },
+        remove: () => {
+            localStorage.removeItem('dynamic_phantom_method');
+        },
+        set: (method) => {
+            localStorage.setItem('dynamic_phantom_method', method);
+        },
+    },
+    session: {
+        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_session')) !== null && _a !== void 0 ? _a : undefined; },
+        remove: () => {
+            localStorage.removeItem('dynamic_phantom_session');
+        },
+        set: (session) => {
+            localStorage.setItem('dynamic_phantom_session', session);
+        },
+    },
+    sharedSecret: {
+        get: () => {
+            const rawSharedSecret = localStorage.getItem('dynamic_phantom_shared_secret');
+            if (!rawSharedSecret) {
+                return undefined;
+            }
+            return new Uint8Array(JSON.parse(rawSharedSecret));
+        },
+        remove: () => {
+            localStorage.removeItem('dynamic_phantom_shared_secret');
+        },
+        set: (sharedSecret) => {
+            localStorage.setItem('dynamic_phantom_shared_secret', JSON.stringify([...sharedSecret]));
+        },
+    },
+};
+const clearStorage = () => {
+    for (const key in storage) {
+        storage[key].remove();
+    }
+};
+
+exports.clearStorage = clearStorage;
+exports.storage = storage;

package/src/phantomRedirect/storage.d.ts

@@ -0,0 +1,40 @@
+import { PublicKey } from '@solana/web3.js';
+import { Method } from './types';
+export declare const storage: {
+    address: {
+        get: () => string | undefined;
+        remove: () => void;
+        set: (address: PublicKey) => void;
+    };
+    encryptionPublicKey: {
+        get: () => Uint8Array | undefined;
+        remove: () => void;
+        set: (publicKey: Uint8Array) => void;
+    };
+    encryptionSecretKey: {
+        get: () => Uint8Array | undefined;
+        remove: () => void;
+        set: (secretKey: Uint8Array) => void;
+    };
+    message: {
+        get: () => string | undefined;
+        remove: () => void;
+        set: (message: string) => void;
+    };
+    method: {
+        get: () => Method | undefined;
+        remove: () => void;
+        set: (method: Method) => void;
+    };
+    session: {
+        get: () => string | undefined;
+        remove: () => void;
+        set: (session: string) => void;
+    };
+    sharedSecret: {
+        get: () => Uint8Array | undefined;
+        remove: () => void;
+        set: (sharedSecret: Uint8Array) => void;
+    };
+};
+export declare const clearStorage: () => void;

package/src/phantomRedirect/storage.js

@@ -0,0 +1,91 @@
+'use client'
+const storage = {
+    address: {
+        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_wallet_address')) !== null && _a !== void 0 ? _a : undefined; },
+        remove: () => {
+            localStorage.removeItem('dynamic_phantom_wallet_address');
+        },
+        set: (address) => {
+            localStorage.setItem('dynamic_phantom_wallet_address', address.toString());
+        },
+    },
+    encryptionPublicKey: {
+        get: () => {
+            const rawPublicKey = localStorage.getItem('dynamic_phantom_public_key');
+            if (!rawPublicKey) {
+                return undefined;
+            }
+            return new Uint8Array(JSON.parse(rawPublicKey));
+        },
+        remove: () => {
+            localStorage.removeItem('dynamic_phantom_public_key');
+        },
+        set: (publicKey) => {
+            localStorage.setItem('dynamic_phantom_public_key', JSON.stringify([...publicKey]));
+        },
+    },
+    encryptionSecretKey: {
+        get: () => {
+            const rawSecretKey = localStorage.getItem('dynamic_phantom_secret_key');
+            if (!rawSecretKey) {
+                return undefined;
+            }
+            return new Uint8Array(JSON.parse(rawSecretKey));
+        },
+        remove: () => {
+            localStorage.removeItem('dynamic_phantom_secret_key');
+        },
+        set: (secretKey) => {
+            localStorage.setItem('dynamic_phantom_secret_key', JSON.stringify([...secretKey]));
+        },
+    },
+    message: {
+        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_message_to_sign')) !== null && _a !== void 0 ? _a : undefined; },
+        remove: () => {
+            localStorage.removeItem('dynamic_phantom_message_to_sign');
+        },
+        set: (message) => {
+            localStorage.setItem('dynamic_phantom_message_to_sign', message);
+        },
+    },
+    method: {
+        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_method')) !== null && _a !== void 0 ? _a : undefined; },
+        remove: () => {
+            localStorage.removeItem('dynamic_phantom_method');
+        },
+        set: (method) => {
+            localStorage.setItem('dynamic_phantom_method', method);
+        },
+    },
+    session: {
+        get: () => { var _a; return (_a = localStorage.getItem('dynamic_phantom_session')) !== null && _a !== void 0 ? _a : undefined; },
+        remove: () => {
+            localStorage.removeItem('dynamic_phantom_session');
+        },
+        set: (session) => {
+            localStorage.setItem('dynamic_phantom_session', session);
+        },
+    },
+    sharedSecret: {
+        get: () => {
+            const rawSharedSecret = localStorage.getItem('dynamic_phantom_shared_secret');
+            if (!rawSharedSecret) {
+                return undefined;
+            }
+            return new Uint8Array(JSON.parse(rawSharedSecret));
+        },
+        remove: () => {
+            localStorage.removeItem('dynamic_phantom_shared_secret');
+        },
+        set: (sharedSecret) => {
+            localStorage.setItem('dynamic_phantom_shared_secret', JSON.stringify([...sharedSecret]));
+        },
+    },
+};
+const clearStorage = () => {
+    for (const key in storage) {
+        storage[key].remove();
+    }
+};
+
+export { clearStorage, storage };

package/src/phantomRedirect/types.d.ts

@@ -0,0 +1 @@
+export type Method = 'signMessage' | 'signAndSendTransaction';

package/src/phantomRedirect/utils.cjs

@@ -0,0 +1,56 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var nacl = require('tweetnacl');
+var bs58 = require('bs58');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var nacl__default = /*#__PURE__*/_interopDefaultLegacy(nacl);
+var bs58__default = /*#__PURE__*/_interopDefaultLegacy(bs58);
+
+const buildUrl = (path, params) => `https://phantom.app/ul/v1/${path}?${params.toString()}`;
+const decryptPayload = (data, nonce, sharedSecret) => {
+    const decryptedData = nacl__default["default"].box.open.after(bs58__default["default"].decode(data), bs58__default["default"].decode(nonce), sharedSecret);
+    if (!decryptedData) {
+        throw new Error('Unable to decrypt data');
+    }
+    return JSON.parse(Buffer.from(decryptedData).toString('utf8'));
+};
+const encryptPayload = (payload, sharedSecret) => {
+    const nonce = nacl__default["default"].randomBytes(24);
+    const encryptedPayload = nacl__default["default"].box.after(Buffer.from(JSON.stringify(payload)), nonce, sharedSecret);
+    return [nonce, encryptedPayload];
+};
+const GENESIS_HASHES = {
+    '4uhcVJyU9pJkvQyS88uRDiswHXSCkY3zQawwpjk2NsNY': 'testnet',
+    '5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d': 'mainnet-beta',
+    EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG: 'devnet',
+};
+const fetchCluster = (rpc) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { result } = yield (yield fetch(rpc, {
+            body: JSON.stringify({
+                id: 1,
+                jsonrpc: '2.0',
+                method: 'getGenesisHash',
+            }),
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            method: 'POST',
+        })).json();
+        return GENESIS_HASHES[result];
+    }
+    catch (err) {
+        return 'mainnet-beta';
+    }
+});
+
+exports.buildUrl = buildUrl;
+exports.decryptPayload = decryptPayload;
+exports.encryptPayload = encryptPayload;
+exports.fetchCluster = fetchCluster;

package/src/phantomRedirect/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const buildUrl: (path: string, params: URLSearchParams) => string;
+export declare const decryptPayload: (data: string, nonce: string, sharedSecret: Uint8Array) => any;
+export declare const encryptPayload: (payload: any, sharedSecret: Uint8Array) => Uint8Array[];
+export declare const fetchCluster: (rpc: string) => Promise<string>;

package/src/phantomRedirect/utils.js

@@ -0,0 +1,44 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import nacl from 'tweetnacl';
+import bs58 from 'bs58';
+
+const buildUrl = (path, params) => `https://phantom.app/ul/v1/${path}?${params.toString()}`;
+const decryptPayload = (data, nonce, sharedSecret) => {
+    const decryptedData = nacl.box.open.after(bs58.decode(data), bs58.decode(nonce), sharedSecret);
+    if (!decryptedData) {
+        throw new Error('Unable to decrypt data');
+    }
+    return JSON.parse(Buffer.from(decryptedData).toString('utf8'));
+};
+const encryptPayload = (payload, sharedSecret) => {
+    const nonce = nacl.randomBytes(24);
+    const encryptedPayload = nacl.box.after(Buffer.from(JSON.stringify(payload)), nonce, sharedSecret);
+    return [nonce, encryptedPayload];
+};
+const GENESIS_HASHES = {
+    '4uhcVJyU9pJkvQyS88uRDiswHXSCkY3zQawwpjk2NsNY': 'testnet',
+    '5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d': 'mainnet-beta',
+    EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG: 'devnet',
+};
+const fetchCluster = (rpc) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { result } = yield (yield fetch(rpc, {
+            body: JSON.stringify({
+                id: 1,
+                jsonrpc: '2.0',
+                method: 'getGenesisHash',
+            }),
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            method: 'POST',
+        })).json();
+        return GENESIS_HASHES[result];
+    }
+    catch (err) {
+        return 'mainnet-beta';
+    }
+});
+
+export { buildUrl, decryptPayload, encryptPayload, fetchCluster };