@meshconnect/web-link-sdk 3.2.15 → 3.2.16

package/{src/utils/event-types.test.ts → utils/event-types.js}

@@ -1,7 +1,4 @@
-import { isLinkEventTypeKey } from './event-types'
-
-describe('Event types tests', () => {
-  test.each([
+var LINK_EVENT_TYPE_KEYS = [
     'integrationConnected',
     'integrationConnectionError',
     'integrationMfaRequired',
@@ -41,14 +38,7 @@ describe('Event types tests', () => {
     'fundingOptionsUpdated',
     'fundingOptionsViewed',
     'gasIncreaseWarning'
-  ])(
-    'isLinkEventTypeKey should return true if parameter is "%s"',
-    eventType => {
-      expect(isLinkEventTypeKey(eventType)).toBe(true)
-    }
-  )
-
-  test('isLinkEventTypeKey should return false if parameter is not event', () => {
-    expect(isLinkEventTypeKey('test')).toBe(false)
-  })
-})
+];
+export function isLinkEventTypeKey(key) {
+    return LINK_EVENT_TYPE_KEYS.includes(key);
+}

package/utils/popup.d.ts

@@ -0,0 +1,3 @@
+export declare const iframeId = "mesh-link-popup__iframe";
+export declare function removePopup(): void;
+export declare function addPopup(iframeLink: string): void;

package/utils/popup.js

@@ -0,0 +1,36 @@
+import { getLinkStyle, getNumber } from './style';
+var popupId = 'mesh-link-popup';
+var backdropId = 'mesh-link-popup__backdrop';
+var popupContentId = 'mesh-link-popup__popup-content';
+var stylesId = 'mesh-link-popup__styles';
+export var iframeId = 'mesh-link-popup__iframe';
+var getStylesContent = function (style) { return "\n  body {\n    position: fixed;\n    left: 0;\n    top: 0;\n    bottom: 0;\n    right: 0;\n    overflow: hidden;\n  }\n\n  #".concat(popupId, " {\n    all: unset;\n    position: fixed;\n    left: 0;\n    top: 0;\n    bottom: 0;\n    right: 0;\n    display: flex;\n    flex-direction: column;\n    align-items: center;\n    justify-content: center;\n    z-index: 10000;\n  }\n\n  #").concat(backdropId, " {\n    position: absolute;\n    left: 0;\n    top: 0;\n    bottom: 0;\n    right: 0;\n    z-index: 10000;\n    background: black;\n    opacity: ").concat(getNumber(0.6, style === null || style === void 0 ? void 0 : style.io), ";\n  }\n\n  #").concat(popupContentId, " {\n    position: absolute;\n    height: 80%;\n    max-height: 710px;\n    min-height: 685px;\n    margin: auto;\n    z-index: 10001;\n    width: 30%;\n    max-width: 430px;\n    min-width: 380px;\n    display: flex;\n    flex-direction: column;\n    border-radius: ").concat(getNumber(24, style === null || style === void 0 ? void 0 : style.ir), "px;\n    flex-grow: 1;\n  }\n\n  #").concat(popupContentId, " iframe {\n    border: none;\n    width: 100%;\n    flex-grow: 1;\n    border-radius: ").concat(getNumber(24, style === null || style === void 0 ? void 0 : style.ir), "px;\n  }\n\n  @media only screen and (max-width: 768px) {\n    #").concat(popupContentId, " {\n      height: 100vh;\n      width: 100vw;\n      max-width: 100%;\n      min-width: 100%;\n      max-height: 100%;\n      min-height: 100%;\n      border-radius: 0px;\n    }\n\n    #").concat(popupContentId, " iframe {\n      border-radius: 0px;\n    }\n  }\n\n  @media only screen and (max-height: 710px) {\n    #").concat(popupContentId, " {\n      max-height: 100%;\n      min-height: 100%;\n    }\n  }\n"); };
+export function removePopup() {
+    var _a, _b;
+    var existingPopup = window.document.getElementById(popupId);
+    (_a = existingPopup === null || existingPopup === void 0 ? void 0 : existingPopup.parentElement) === null || _a === void 0 ? void 0 : _a.removeChild(existingPopup);
+    var existingStyles = window.document.getElementById(stylesId);
+    (_b = existingStyles === null || existingStyles === void 0 ? void 0 : existingStyles.parentElement) === null || _b === void 0 ? void 0 : _b.removeChild(existingStyles);
+}
+export function addPopup(iframeLink) {
+    removePopup();
+    var styleElement = document.createElement('style');
+    styleElement.id = stylesId;
+    var style = getLinkStyle(iframeLink);
+    styleElement.textContent = getStylesContent(style);
+    window.document.head.appendChild(styleElement);
+    var popupRootElement = document.createElement('div');
+    popupRootElement.id = popupId;
+    var popupBackdropElement = document.createElement('div');
+    popupBackdropElement.id = backdropId;
+    popupRootElement.appendChild(popupBackdropElement);
+    var popupContentElement = document.createElement('div');
+    popupContentElement.id = popupContentId;
+    var iframeElement = document.createElement('iframe');
+    iframeElement.id = iframeId;
+    iframeElement.src = iframeLink;
+    iframeElement.allow = 'clipboard-read *; clipboard-write *';
+    popupContentElement.appendChild(iframeElement);
+    popupRootElement.appendChild(popupContentElement);
+    window.document.body.appendChild(popupRootElement);
+}

package/utils/sdk-specs.d.ts

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

package/utils/sdk-specs.js

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

package/utils/style.d.ts

@@ -0,0 +1,3 @@
+import { LinkStyle } from './types';
+export declare function getLinkStyle(url: string): LinkStyle | undefined;
+export declare function getNumber(def: number, value?: number): number;

package/utils/style.js

@@ -0,0 +1,13 @@
+export function getLinkStyle(url) {
+    try {
+        var params = new URLSearchParams(new URL(url).search);
+        var style = params.get('link_style');
+        return style && JSON.parse(window.atob(style));
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+export function getNumber(def, value) {
+    return value !== undefined ? value : def;
+}

package/utils/types.d.ts

@@ -0,0 +1,234 @@
+import type { BrokerType } from '@meshconnect/node-api';
+import { SessionSummary, LinkEventType } from './event-types';
+export type EventType = 'brokerageAccountAccessToken' | 'delayedAuthentication' | 'loaded' | 'transferFinished';
+export interface Link {
+    /**
+     * A function that takes linkToken parameter from `/api/v1/linktoken` endpoint as an input, and opens the Link UI popup
+     * @param linkToken - Base64 encoded link token from the `/api/v1/linktoken` endpoint
+     * @param customIframeId - Optional custom ID for the existing iframe element. If not provided, a new iframe element will be created
+     */
+    openLink: (linkToken: string, customIframeId?: string) => void;
+    /**
+     * A function to close Link UI popup
+     */
+    closeLink: () => void;
+}
+export interface AccountToken {
+    account: Account;
+    accessToken: string;
+    refreshToken?: string;
+    tokenId?: string;
+}
+export interface Account {
+    accountId: string;
+    accountName: string;
+    fund?: number;
+    cash?: number;
+    isReconnected?: boolean;
+}
+/**
+ * Integration brand information
+ */
+export interface BrandInfo {
+    /**
+     * Integration logo in base 64 format
+     */
+    brokerLogo: string;
+    /**
+     * Integration logo URL (obsolete, use `logoLightUrl` instead)
+     */
+    brokerLogoUrl?: string;
+    /**
+     * Integration logo URL for light theme
+     */
+    logoLightUrl?: string;
+    /**
+     * Integration logo URL for dark theme
+     */
+    logoDarkUrl?: string;
+    /**
+     * Integration icon URL for light theme
+     */
+    iconLightUrl?: string;
+    /**
+     * Integration icon URL for dark theme
+     */
+    iconDarkUrl?: string;
+}
+export interface LinkPayload {
+    accessToken?: AccessTokenPayload;
+    delayedAuth?: DelayedAuthPayload;
+}
+export interface AccessTokenPayload {
+    accountTokens: AccountToken[];
+    brokerBrandInfo: BrandInfo;
+    expiresInSeconds?: number;
+    refreshTokenExpiresInSeconds?: number;
+    brokerType: BrokerType;
+    brokerName: string;
+}
+export interface DelayedAuthPayload {
+    refreshTokenExpiresInSeconds?: number;
+    brokerType: BrokerType;
+    refreshToken: string;
+    brokerName: string;
+    brokerBrandInfo: BrandInfo;
+}
+export interface TransferFinishedPayload {
+    status: 'success';
+    txId: string;
+    fromAddress: string;
+    toAddress: string;
+    symbol: string;
+    amount: number;
+    networkId: string;
+    amountInFiat?: number;
+    totalAmountInFiat?: number;
+    networkName?: string;
+    txHash?: string;
+    transferId?: string;
+    refundAddress?: string;
+}
+export interface IntegrationAccessToken {
+    accountId: string;
+    accountName: string;
+    accessToken: string;
+    brokerType: BrokerType;
+    brokerName: string;
+}
+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;
+    gasLimit?: number | null;
+    maxFeePerGas?: number | null;
+    maxPriorityFeePerGas?: number | null;
+}
+export interface SmartContractPayload {
+    address: string;
+    abi: string;
+    functionName: string;
+    args: unknown[];
+    account: string;
+    value?: string;
+    walletName?: string;
+    tokenProgram?: string;
+    blockhash?: string;
+    createATA?: boolean;
+    gasLimit?: number | null;
+    maxFeePerGas?: number | null;
+    maxPriorityFeePerGas?: number | null;
+}
+export interface TransactionBatchPayload {
+    version: string;
+    from: string;
+    chainId: string;
+    atomicRequired: boolean;
+    calls: {
+        to: string;
+        value: string;
+        data?: string;
+    }[];
+}
+export interface WalletCapabilitiesPayload {
+    from: string;
+    chainId: string;
+}
+export interface DisconnectPayload {
+    networkType?: string;
+    walletName?: string;
+}
+export interface AddressLookupTableStateDto {
+    deactivationSlot: bigint;
+    lastExtendedSlot: number;
+    lastExtendedStartIndex: number;
+    key: string;
+    authority?: string;
+    addresses: string[];
+}
+export interface SolanaTransferWithInstructionsPayload {
+    transactionInstructions: {
+        states: AddressLookupTableStateDto[];
+        instructions: TransactionInstructionDto[];
+        account: string;
+        blockhash: string;
+        walletName?: string;
+        network?: string;
+    };
+    transferConfig: SmartContractPayload;
+}
+export interface SolanaAccountMeta {
+    shouldFillPubkey: boolean;
+    pubKey: string | null;
+    isWritable: boolean;
+    isSigner: boolean;
+}
+export interface TransactionInstructionDto {
+    programId: string;
+    accounts: SolanaAccountMeta[];
+    data: string;
+}
+export interface LinkOptions {
+    /**
+     * Client ID that can be obtained at https://dashboard.meshconnect.com/company/keys
+     */
+    clientId?: string;
+    /**
+     * A callback function that is called when an integration is successfully connected.
+     * It receives a payload of type `LinkPayload`.
+     */
+    onIntegrationConnected: (payload: LinkPayload) => void;
+    /**
+     * (Optional) A callback function that is called when the Front iframe is closed.
+     */
+    onExit?: (error?: string, summary?: SessionSummary) => void;
+    /**
+     * (Optional) A callback function that is called when a transfer is finished.
+     * It receives a payload of type `TransferFinishedPayload`.
+     */
+    onTransferFinished?: (payload: TransferFinishedPayload) => void;
+    /**
+     * (Optional) A callback function that is called when various events occur within the Front iframe.
+     * It receives an object with type `LinkEventTypeKeys` indicating the event, and an optional 'payload' containing additional data.
+     */
+    onEvent?: (event: LinkEventType) => void;
+    /**
+     * (Optional) An array of integration access tokens.
+     * These access tokens are used to initialize crypto transfers flow at 'Select asset step'
+     */
+    accessTokens?: IntegrationAccessToken[];
+    /**
+     * (Optional) An array of integration access tokens.
+     * Can be used to initialize the crypto transfers flow as an alternative to the target addresses.
+     */
+    transferDestinationTokens?: IntegrationAccessToken[];
+    /**
+     * Link UI language. Supported: 'en', 'ru'. Can be set as 'en-US', 'ru-RU', etc.
+     */
+    language?: string;
+}
+export interface LinkStyle {
+    ir: number;
+    io: number;
+}

package/utils/types.js

@@ -0,0 +1 @@
+export {};

package/utils/version.d.ts

@@ -0,0 +1 @@
+export declare const sdkVersion = "3.2.16";

package/utils/version.js

@@ -0,0 +1 @@
+export var sdkVersion = '3.2.16';

package/utils/wallet/EVMWalletStrategy.d.ts

@@ -0,0 +1,31 @@
+import { BaseWalletStrategy } from './WalletStrategy';
+import { WalletBrowserPayload, SignRequestPayload, ChainSwitchPayload, TransferPayload, SmartContractPayload, DisconnectPayload, TransactionBatchPayload, WalletCapabilitiesPayload } from '../types';
+export declare class EVMWalletStrategy extends BaseWalletStrategy {
+    sendTransactionWithInstructions(): Promise<string>;
+    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>;
+    sendNativeSmartContractInteraction(payload: SmartContractPayload): Promise<string>;
+    sendTransactionBatch(payload: TransactionBatchPayload): Promise<string>;
+    getWalletCapabilities(payload: WalletCapabilitiesPayload): Promise<{
+        atomic: {
+            status: string;
+        };
+    }>;
+    getProviders(): {
+        icon: string | undefined;
+        id: string;
+        name: string;
+        type: string;
+    }[];
+}

package/utils/wallet/EVMWalletStrategy.js

@@ -0,0 +1,265 @@
+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, sendNativeSmartContractTransaction, switchEVMChain, findAvailableProviders, sendEVMTransactionBatch, getWalletCapabilities } from '../connectors/evm';
+var EVMWalletStrategy = /** @class */ (function (_super) {
+    __extends(EVMWalletStrategy, _super);
+    function EVMWalletStrategy() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    EVMWalletStrategy.prototype.sendTransactionWithInstructions = function () {
+        throw new Error('Method not implemented.');
+    };
+    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, payload.gasLimit, payload.maxFeePerGas, payload.maxPriorityFeePerGas)];
+                    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)];
+                    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.sendNativeSmartContractInteraction = function (payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result, error_7;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, sendNativeSmartContractTransaction(payload.address, JSON.parse(payload.abi), payload.functionName, payload.args, payload.account, payload.value)];
+                    case 1:
+                        result = _a.sent();
+                        if (result instanceof Error) {
+                            throw result;
+                        }
+                        return [2 /*return*/, result];
+                    case 2:
+                        error_7 = _a.sent();
+                        throw this.handleError(error_7, 'send EVM smart contract interaction');
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EVMWalletStrategy.prototype.sendTransactionBatch = function (payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result, error_8;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, sendEVMTransactionBatch(payload)];
+                    case 1:
+                        result = _a.sent();
+                        if (result instanceof Error) {
+                            throw result;
+                        }
+                        return [2 /*return*/, result];
+                    case 2:
+                        error_8 = _a.sent();
+                        throw this.handleError(error_8, 'send EVM smart contract interaction');
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EVMWalletStrategy.prototype.getWalletCapabilities = function (payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, getWalletCapabilities(payload.from, payload.chainId)];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    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,33 @@
+import { BaseWalletStrategy } from './WalletStrategy';
+import { WalletBrowserPayload, SignRequestPayload, ChainSwitchPayload, TransferPayload, SmartContractPayload, DisconnectPayload, SolanaTransferWithInstructionsPayload } 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>;
+    /**
+     * Handles chain switching for Solana networks
+     * Supports both mainnet (101) and devnet (103)
+     */
+    switchChain(payload: ChainSwitchPayload): Promise<{
+        chainId: string;
+        accounts: string[];
+    }>;
+    sendNativeTransfer(payload: TransferPayload): Promise<string>;
+    sendSmartContractInteraction(payload: SmartContractPayload): Promise<string>;
+    sendTransactionWithInstructions(payload: SolanaTransferWithInstructionsPayload): Promise<string>;
+    sendNativeSmartContractInteraction(): Promise<string>;
+    sendTransactionBatch(): Promise<string>;
+    getWalletCapabilities(): Promise<{
+        atomic: {
+            status: string;
+        };
+    }>;
+    getProviders(): {
+        id: string;
+        type: string;
+    }[];
+}