@meshconnect/web-link-sdk 3.0.12 → 3.1.0-rc.1

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/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.12";
+export declare const sdkVersion = "3.1.0-rc.1";

package/utils/version.js

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

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;
+    }[];
+}

package/utils/wallet/SolanaWalletStrategy.js

@@ -0,0 +1,194 @@
+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 { connectToSolanaWallet, disconnectFromSolanaWallet, signSolanaMessage, sendSOLTransaction, findAvailableSolanaProviders } from '../connectors/solana';
+var SolanaWalletStrategy = /** @class */ (function (_super) {
+    __extends(SolanaWalletStrategy, _super);
+    function SolanaWalletStrategy() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SolanaWalletStrategy.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*/, connectToSolanaWallet(payload.integrationName)];
+                    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 Solana wallet');
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SolanaWalletStrategy.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*/, disconnectFromSolanaWallet(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 Solana wallet');
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SolanaWalletStrategy.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*/, signSolanaMessage(payload.walletName || 'Unknown Wallet', 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 Solana message');
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * @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)
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    SolanaWalletStrategy.prototype.switchChain = function (_payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        chainId: '101',
+                        accounts: []
+                    }];
+            });
+        });
+    };
+    SolanaWalletStrategy.prototype.sendNativeTransfer = 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*/, sendSOLTransaction({
+                                toAddress: payload.toAddress,
+                                amount: BigInt(payload.amount * Math.pow(10, payload.decimalPlaces)),
+                                fromAddress: payload.account,
+                                blockhash: payload.blockhash || '',
+                                walletName: payload.walletName || ''
+                            })];
+                    case 1:
+                        result = _a.sent();
+                        if (typeof result === 'string') {
+                            return [2 /*return*/, result];
+                        }
+                        throw result;
+                    case 2:
+                        error_4 = _a.sent();
+                        throw this.handleError(error_4, 'send Solana native transfer');
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * @note This feature is not yet implemented for Solana
+     * @throws {Error} Always throws with a "not implemented" message
+     */
+    SolanaWalletStrategy.prototype.sendSmartContractInteraction = function (
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('NOT_IMPLEMENTED: Solana smart contract interactions are not yet supported');
+            });
+        });
+    };
+    SolanaWalletStrategy.prototype.getProviders = function () {
+        var solanaProviderMap = findAvailableSolanaProviders();
+        return Object.keys(solanaProviderMap).map(function (id) { return ({
+            id: id,
+            type: 'solana'
+        }); });
+    };
+    return SolanaWalletStrategy;
+}(BaseWalletStrategy));
+export { SolanaWalletStrategy };