@meshconnect/web-link-sdk 3.0.11 → 3.1.0-rc.0

package/utils/connectors/solana/transaction.js

@@ -0,0 +1,158 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { Connection, PublicKey, SystemProgram, Transaction } from '@solana/web3.js';
+import bs58 from 'bs58';
+import { getSolanaProvider } from './providerDiscovery';
+var QUICKNODE_RPC = 'https://alien-newest-vineyard.solana-mainnet.quiknode.pro/ebe5e35661d7edb7a5e48ab84bd9d477e472a40b/';
+var isUserRejection = function (error) {
+    if (!error)
+        return false;
+    var message = ((error === null || error === void 0 ? void 0 : error.message) || '').toLowerCase();
+    return (message.includes('user rejected') ||
+        message.includes('declined') ||
+        message.includes('cancelled') ||
+        message.includes('denied') ||
+        (error === null || error === void 0 ? void 0 : error.code) === 4001);
+};
+var standardizeSignature = function (rawSignature) {
+    // First ensure we have a string
+    var signature = typeof rawSignature === 'string' ? rawSignature : bs58.encode(rawSignature);
+    // If signature is longer than standard 88 chars, decode and re-encode
+    if (signature.length > 88) {
+        try {
+            var bytes = bs58.decode(signature);
+            var truncatedBytes = bytes.slice(0, 64);
+            signature = bs58.encode(truncatedBytes);
+        }
+        catch (e) {
+            console.error('Failed to normalize signature:', e);
+        }
+    }
+    return signature;
+};
+var createTransferTransaction = function (config) {
+    var transaction = new Transaction().add(SystemProgram.transfer({
+        fromPubkey: new PublicKey(config.fromAddress),
+        toPubkey: new PublicKey(config.toAddress),
+        lamports: config.amount
+    }));
+    transaction.recentBlockhash = config.blockhash;
+    transaction.feePayer = new PublicKey(config.fromAddress);
+    return transaction;
+};
+var handleManualSignAndSend = function (transaction, provider) { return __awaiter(void 0, void 0, void 0, function () {
+    var signedTx, connection, rawSignature, error_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 3, , 4]);
+                return [4 /*yield*/, provider.signTransaction(transaction)];
+            case 1:
+                signedTx = _a.sent();
+                connection = new Connection(QUICKNODE_RPC);
+                return [4 /*yield*/, connection.sendRawTransaction(signedTx.serialize(), {
+                        skipPreflight: false,
+                        maxRetries: 3,
+                        preflightCommitment: 'confirmed'
+                    })];
+            case 2:
+                rawSignature = _a.sent();
+                return [2 /*return*/, standardizeSignature(rawSignature)];
+            case 3:
+                error_1 = _a.sent();
+                if (isUserRejection(error_1)) {
+                    throw new Error('Transaction was rejected by user');
+                }
+                throw error_1;
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };
+export var sendSOLTransaction = function (config) { return __awaiter(void 0, void 0, void 0, function () {
+    var provider, transaction, isManualWallet, error_2, signature, error_3, error_4;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 9, , 10]);
+                provider = getSolanaProvider(config.walletName);
+                transaction = createTransferTransaction(config);
+                isManualWallet = provider.isTrust ||
+                    provider.isTrustWallet ||
+                    config.walletName.toLowerCase().includes('trust');
+                if (!isManualWallet) return [3 /*break*/, 4];
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, handleManualSignAndSend(transaction, provider)];
+            case 2: return [2 /*return*/, _a.sent()];
+            case 3:
+                error_2 = _a.sent();
+                if (isUserRejection(error_2)) {
+                    throw new Error('Transaction was rejected by user');
+                }
+                throw error_2;
+            case 4:
+                if (!provider.signAndSendTransaction) return [3 /*break*/, 8];
+                _a.label = 5;
+            case 5:
+                _a.trys.push([5, 7, , 8]);
+                return [4 /*yield*/, provider.signAndSendTransaction(transaction)];
+            case 6:
+                signature = (_a.sent()).signature;
+                return [2 /*return*/, signature];
+            case 7:
+                error_3 = _a.sent();
+                if (isUserRejection(error_3)) {
+                    throw new Error('Transaction was rejected by user');
+                }
+                // For other errors, fall back to manual sign and send
+                return [2 /*return*/, handleManualSignAndSend(transaction, provider)];
+            case 8: 
+            // If no signAndSendTransaction available, use manual method
+            return [2 /*return*/, handleManualSignAndSend(transaction, provider)];
+            case 9:
+                error_4 = _a.sent();
+                if (isUserRejection(error_4)) {
+                    throw new Error('Transaction was rejected by user');
+                }
+                throw error_4 instanceof Error
+                    ? error_4
+                    : new Error("Failed to send SOL transaction with ".concat(config.walletName, " wallet"));
+            case 10: return [2 /*return*/];
+        }
+    });
+}); };

package/utils/connectors/solana/types.d.ts

@@ -0,0 +1,68 @@
+import { Transaction } from '@solana/web3.js';
+export declare enum SolanaWalletType {
+    PHANTOM = "phantom",
+    SOLFLARE = "solflare",
+    TRUST = "trustwallet",
+    EXODUS = "exodus",
+    UNKNOWN = "unknown"
+}
+export interface SolanaConnectResult {
+    accounts: string[];
+    chainId: string;
+    isConnected: boolean;
+}
+export interface SolanaProvider {
+    connect(options?: {
+        onlyIfTrusted?: boolean;
+    }): Promise<{
+        publicKey: {
+            toString(): string;
+            toBase58(): string;
+        };
+    }>;
+    disconnect(): Promise<void>;
+    walletType?: SolanaWalletType;
+    isConnected?: boolean;
+    publicKey?: {
+        toString(): string;
+        toBase58(): string;
+    };
+    on(event: 'connect' | 'disconnect' | 'accountChanged', callback: (publicKey?: any) => void): void;
+    signMessage(message: Uint8Array): Promise<{
+        signature: Uint8Array;
+    }>;
+    signTransaction(transaction: Transaction): Promise<Transaction>;
+    signAndSendTransaction?(transaction: Transaction): Promise<{
+        signature: string;
+    }>;
+    sendTransaction?(transaction: Transaction): Promise<string>;
+}
+export interface WindowWithSolanaProviders extends Window {
+    solana?: SolanaProvider & {
+        isPhantom?: boolean;
+        isSolflare?: boolean;
+        isTrust?: boolean;
+        isTrustWallet?: boolean;
+        isExodus?: boolean;
+    };
+    phantom?: {
+        solana?: SolanaProvider;
+    };
+    exodus?: {
+        solana?: SolanaProvider;
+    };
+    trustwallet?: {
+        solana?: SolanaProvider;
+    };
+    solflare?: SolanaProvider;
+    [key: string]: {
+        solana?: SolanaProvider;
+    } | SolanaProvider | undefined | any;
+}
+export interface TransactionConfig {
+    toAddress: string;
+    amount: bigint;
+    fromAddress: string;
+    blockhash: string;
+    walletName: string;
+}

package/utils/connectors/solana/types.js

@@ -0,0 +1,8 @@
+export var SolanaWalletType;
+(function (SolanaWalletType) {
+    SolanaWalletType["PHANTOM"] = "phantom";
+    SolanaWalletType["SOLFLARE"] = "solflare";
+    SolanaWalletType["TRUST"] = "trustwallet";
+    SolanaWalletType["EXODUS"] = "exodus";
+    SolanaWalletType["UNKNOWN"] = "unknown";
+})(SolanaWalletType || (SolanaWalletType = {}));

package/utils/event-types.d.ts

@@ -1,6 +1,6 @@
 import { LinkPayload, TransferFinishedPayload } from './types';
-export type LinkEventType = IntegrationConnected | IntegrationConnectionError | TransferCompleted | IntegrationSelected | CredentialsEntered | TransferStarted | TransferPreviewed | TransferPreviewError | TransferExecutionError | PageLoaded | IntegrationMfaRequired | IntegrationMfaEntered | IntegrationOAuthStarted | IntegrationAccountSelectionRequired | TransferAssetSelected | TransferNetworkSelected | TransferAmountEntered | TransferMfaRequired | TransferMfaEntered | TransferKycRequired | TransferInitiated | TransferExecuted | TransferNoEligibleAssets | WalletMessageSigned | DoneEvent | CloseEvent | VerifyWalletRejected | VerifyDonePage;
-declare const LINK_EVENT_TYPE_KEYS: readonly ["integrationConnected", "integrationConnectionError", "integrationMfaRequired", "integrationMfaEntered", "integrationOAuthStarted", "integrationAccountSelectionRequired", "transferCompleted", "integrationSelected", "credentialsEntered", "transferStarted", "transferPreviewed", "transferPreviewError", "transferExecutionError", "pageLoaded", "transferAssetSelected", "transferNetworkSelected", "transferAmountEntered", "transferMfaRequired", "transferMfaEntered", "transferKycRequired", "transferExecuted", "transferInitiated", "transferNoEligibleAssets", "walletMessageSigned", "verifyDonePage", "verifyWalletRejected", "connectionDeclined", "transferConfigureError", "connectionUnavailable", "transferDeclined", "done", "close"];
+export type LinkEventType = IntegrationConnected | IntegrationConnectionError | TransferCompleted | IntegrationSelected | CredentialsEntered | TransferStarted | TransferPreviewed | TransferPreviewError | TransferExecutionError | PageLoaded | IntegrationMfaRequired | IntegrationMfaEntered | IntegrationOAuthStarted | IntegrationAccountSelectionRequired | TransferAssetSelected | TransferNetworkSelected | TransferAmountEntered | TransferMfaRequired | TransferMfaEntered | TransferKycRequired | TransferInitiated | TransferExecuted | TransferNoEligibleAssets | WalletMessageSigned | DoneEvent | CloseEvent | VerifyWalletRejected | VerifyDonePage | SDKinjectedWalletProviders;
+declare const LINK_EVENT_TYPE_KEYS: readonly ["integrationConnected", "integrationConnectionError", "integrationMfaRequired", "integrationMfaEntered", "integrationOAuthStarted", "integrationAccountSelectionRequired", "transferCompleted", "integrationSelected", "credentialsEntered", "transferStarted", "transferPreviewed", "transferPreviewError", "transferExecutionError", "pageLoaded", "transferAssetSelected", "transferNetworkSelected", "transferAmountEntered", "transferMfaRequired", "transferMfaEntered", "transferKycRequired", "transferExecuted", "transferInitiated", "transferNoEligibleAssets", "walletMessageSigned", "verifyDonePage", "verifyWalletRejected", "connectionDeclined", "transferConfigureError", "connectionUnavailable", "transferDeclined", "done", "close", "SDKinjectedWalletProviders"];
 export type LinkEventTypeKeys = (typeof LINK_EVENT_TYPE_KEYS)[number];
 export declare function isLinkEventTypeKey(key: string): key is LinkEventTypeKeys;
 interface LinkEventBase {
@@ -199,4 +199,12 @@ export interface SessionSymmary {
     };
     errorMessage?: string;
 }
+export interface SDKinjectedWalletProviders extends LinkEventBase {
+    type: 'SDKinjectedWalletProviders';
+    payload: Array<{
+        icon?: string;
+        id: string;
+        name: string;
+    }>;
+}
 export {};

package/utils/event-types.js

@@ -30,7 +30,8 @@ var LINK_EVENT_TYPE_KEYS = [
     'connectionUnavailable',
     'transferDeclined',
     'done',
-    'close'
+    'close',
+    'SDKinjectedWalletProviders'
 ];
 export function isLinkEventTypeKey(key) {
     return LINK_EVENT_TYPE_KEYS.includes(key);

package/utils/sdk-specs.d.ts

@@ -1,4 +1,5 @@
 export declare const sdkSpecs: {
     platform: string;
     version: string;
+    origin: string;
 };

package/utils/sdk-specs.js

@@ -1,5 +1,6 @@
 import { sdkVersion } from './version';
 export var sdkSpecs = {
     platform: 'web',
-    version: sdkVersion
+    version: sdkVersion,
+    origin: window.location.origin
 };

package/utils/types.d.ts

@@ -1,6 +1,5 @@
 import type { BrokerType } from '@meshconnect/node-api';
 import { SessionSymmary, LinkEventType } from './event-types';
-import { Hash, Chain } from 'viem';
 export type EventType = 'brokerageAccountAccessToken' | 'delayedAuthentication' | 'loaded' | 'oauthLinkOpen' | 'transferFinished';
 export interface Link {
     /**
@@ -68,34 +67,44 @@ export interface IntegrationAccessToken {
     brokerType: BrokerType;
     brokerName: string;
 }
-export interface WagmiInjectedConnectorData {
-    id: string;
-    name: string;
-    type: string;
-    icon?: string;
-    uid: string;
-}
-export interface WalletConnectSignedTxHash {
-    txSigned: Hash;
-}
-export interface IncomingConfig {
-    chains: Chain[];
-    transports: Record<number, string | string[]>;
-}
-export interface AbiItem {
-    name: string;
-    type: string;
-    inputs: {
-        name: string;
-        type: string;
-    }[];
-    outputs?: {
-        name: string;
-        type: string;
-    }[];
-    stateMutability?: string;
-}
-export type Abi = AbiItem[];
+export interface WalletBrowserPayload {
+    networkType?: string;
+    integrationName: string;
+    targetChainId?: string;
+    walletName?: string;
+}
+export interface SignRequestPayload {
+    address: string;
+    message: string;
+    walletName?: string;
+}
+export interface ChainSwitchPayload {
+    chainId: number;
+    networkType?: string;
+    walletName?: string;
+}
+export interface TransferPayload {
+    toAddress: string;
+    amount: number;
+    decimalPlaces: number;
+    chainId: number;
+    account: string;
+    network: string;
+    blockhash?: string;
+    walletName?: string;
+}
+export interface SmartContractPayload {
+    address: string;
+    abi: string;
+    functionName: string;
+    args: unknown[];
+    account: string;
+    value?: string;
+}
+export interface DisconnectPayload {
+    networkType?: string;
+    walletName?: string;
+}
 export interface LinkOptions {
     /**
      * Client ID that can be obtained at https://dashboard.meshconnect.com/company/keys

package/utils/version.d.ts

@@ -1 +1 @@
-export declare const sdkVersion = "3.0.11";
+export declare const sdkVersion = "3.1.0-rc.0";

package/utils/version.js

@@ -1 +1 @@
-export var sdkVersion = '3.0.11';
+export var sdkVersion = '3.1.0-rc.0';

package/utils/wallet/EVMWalletStrategy.d.ts

@@ -0,0 +1,23 @@
+import { BaseWalletStrategy } from './WalletStrategy';
+import { WalletBrowserPayload, SignRequestPayload, ChainSwitchPayload, TransferPayload, SmartContractPayload, DisconnectPayload } from '../types';
+export declare class EVMWalletStrategy extends BaseWalletStrategy {
+    connect(payload: WalletBrowserPayload): Promise<{
+        accounts: string[];
+        chainId: number;
+        isConnected: boolean;
+    }>;
+    disconnect(payload: DisconnectPayload): Promise<void>;
+    signMessage(payload: SignRequestPayload): Promise<string>;
+    switchChain(payload: ChainSwitchPayload): Promise<{
+        chainId: number;
+        accounts: string[];
+    }>;
+    sendNativeTransfer(payload: TransferPayload): Promise<string>;
+    sendSmartContractInteraction(payload: SmartContractPayload): Promise<string>;
+    getProviders(): {
+        icon: string | undefined;
+        id: string;
+        name: string;
+        type: string;
+    }[];
+}

package/utils/wallet/EVMWalletStrategy.js

@@ -0,0 +1,205 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { BaseWalletStrategy } from './WalletStrategy';
+import { connectToEVMWallet, disconnectFromEVMWallet, signEVMMessage, sendEVMTransaction, sendEVMTokenTransaction, switchEVMChain, findAvailableProviders } from '../connectors/evm';
+var EVMWalletStrategy = /** @class */ (function (_super) {
+    __extends(EVMWalletStrategy, _super);
+    function EVMWalletStrategy() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    EVMWalletStrategy.prototype.connect = function (payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, connectToEVMWallet(payload.integrationName, payload.targetChainId ? parseInt(payload.targetChainId, 10) : undefined)];
+                    case 1:
+                        result = _a.sent();
+                        if (result instanceof Error) {
+                            throw result;
+                        }
+                        return [2 /*return*/, {
+                                accounts: result.accounts,
+                                chainId: result.chainId,
+                                isConnected: result.isConnected
+                            }];
+                    case 2:
+                        error_1 = _a.sent();
+                        throw this.handleError(error_1, 'connect to EVM wallet');
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EVMWalletStrategy.prototype.disconnect = function (payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, disconnectFromEVMWallet(payload.walletName || 'Unknown Wallet')];
+                    case 1:
+                        result = _a.sent();
+                        if (result instanceof Error) {
+                            throw result;
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_2 = _a.sent();
+                        throw this.handleError(error_2, 'disconnect from EVM wallet');
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EVMWalletStrategy.prototype.signMessage = function (payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, signEVMMessage(payload.walletName || 'Unknown Wallet', payload.address, payload.message)];
+                    case 1:
+                        result = _a.sent();
+                        if (result instanceof Error) {
+                            throw result;
+                        }
+                        return [2 /*return*/, result];
+                    case 2:
+                        error_3 = _a.sent();
+                        throw this.handleError(error_3, 'sign EVM message');
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EVMWalletStrategy.prototype.switchChain = function (payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result, error_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, switchEVMChain(payload.chainId)];
+                    case 1:
+                        result = _a.sent();
+                        if (result instanceof Error) {
+                            throw result;
+                        }
+                        return [2 /*return*/, result];
+                    case 2:
+                        error_4 = _a.sent();
+                        throw this.handleError(error_4, 'switch EVM chain');
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EVMWalletStrategy.prototype.sendNativeTransfer = function (payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result, error_5;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, sendEVMTransaction(payload.toAddress, BigInt(payload.amount * Math.pow(10, payload.decimalPlaces)), payload.account)];
+                    case 1:
+                        result = _a.sent();
+                        if (result instanceof Error) {
+                            throw result;
+                        }
+                        return [2 /*return*/, result];
+                    case 2:
+                        error_5 = _a.sent();
+                        throw this.handleError(error_5, 'send EVM native transfer');
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EVMWalletStrategy.prototype.sendSmartContractInteraction = function (payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result, error_6;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, sendEVMTokenTransaction(payload.address, JSON.parse(payload.abi), payload.functionName, payload.args, payload.account, payload.value ? BigInt(payload.value) : undefined)];
+                    case 1:
+                        result = _a.sent();
+                        if (result instanceof Error) {
+                            throw result;
+                        }
+                        return [2 /*return*/, result];
+                    case 2:
+                        error_6 = _a.sent();
+                        throw this.handleError(error_6, 'send EVM smart contract interaction');
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EVMWalletStrategy.prototype.getProviders = function () {
+        return findAvailableProviders().map(function (provider) { return ({
+            icon: provider.icon,
+            id: provider.id,
+            name: provider.name,
+            type: 'evm'
+        }); });
+    };
+    return EVMWalletStrategy;
+}(BaseWalletStrategy));
+export { EVMWalletStrategy };

package/utils/wallet/SolanaWalletStrategy.d.ts

@@ -0,0 +1,29 @@
+import { BaseWalletStrategy } from './WalletStrategy';
+import { WalletBrowserPayload, SignRequestPayload, ChainSwitchPayload, TransferPayload, SmartContractPayload, DisconnectPayload } from '../types';
+export declare class SolanaWalletStrategy extends BaseWalletStrategy {
+    connect(payload: WalletBrowserPayload): Promise<{
+        accounts: string[];
+        chainId: string;
+        isConnected: boolean;
+    }>;
+    disconnect(payload: DisconnectPayload): Promise<void>;
+    signMessage(payload: SignRequestPayload): Promise<string>;
+    /**
+     * @note Solana doesn't support chain switching as it's a single-chain network
+     * This method is implemented to satisfy the interface but will always return mainnet (101)
+     */
+    switchChain(_payload: ChainSwitchPayload): Promise<{
+        chainId: string;
+        accounts: string[];
+    }>;
+    sendNativeTransfer(payload: TransferPayload): Promise<string>;
+    /**
+     * @note This feature is not yet implemented for Solana
+     * @throws {Error} Always throws with a "not implemented" message
+     */
+    sendSmartContractInteraction(_payload: SmartContractPayload): Promise<string>;
+    getProviders(): {
+        id: string;
+        type: string;
+    }[];
+}