@meshconnect/web-link-sdk 3.1.5 → 3.1.7

package/Link.js

@@ -158,7 +158,7 @@ function handleLinkEvent(event) {
 }
 function handleWalletBrowserEvent(event) {
     return __awaiter(this, void 0, void 0, function () {
-        var walletFactory, _a, payload, networkType, strategy, result, error_1, payload, networkType, strategy, result, error_2, payload, networkType, strategy, result, error_3, payload, networkType, strategy, result, error_4, payload, getResponseType, strategy, result, responseType, error_5, errorType, payload, networkType, strategy, error_6;
+        var walletFactory, _a, payload, networkType, strategy, result, error_1, payload, networkType, strategy, result, error_2, payload, networkType, strategy, result, error_3, payload, networkType, strategy, result, error_4, payload, getResponseType, networkType, strategy, result, responseType, error_5, errorType, payload, networkType, strategy, error_6;
         var _b;
         return __generator(this, function (_c) {
             switch (_c.label) {
@@ -283,7 +283,8 @@ function handleWalletBrowserEvent(event) {
                     _c.label = 22;
                 case 22:
                     _c.trys.push([22, 24, , 25]);
-                    strategy = walletFactory.getStrategy('evm');
+                    networkType = (payload.address.startsWith('0x') ? 'evm' : 'solana');
+                    strategy = walletFactory.getStrategy(networkType);
                     return [4 /*yield*/, strategy.sendSmartContractInteraction(payload)];
                 case 23:
                     result = _c.sent();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meshconnect/web-link-sdk",
-  "version": "3.1.5",
+  "version": "3.1.7",
   "description": "A client-side JS library for integrating with Mesh Connect",
   "exports": "./index.js",
   "license": "MIT",
@@ -23,7 +23,7 @@
   },
   "dependencies": {
     "@meshconnect/node-api": "^2.0.19",
-    "@solana/web3.js": "^1.91.1",
+    "@meshconnect/solana-web3.js": "^1.0.4",
     "bs58": "^5.0.0",
     "buffer": "^6.0.3",
     "ethers": "^6.11.1"
@@ -51,7 +51,7 @@
       ]
     },
     "transformIgnorePatterns": [
-      "/node_modules/(?!(@solana/web3.js|uuid|jayson|superstruct|@noble|@meshconnect|ethers)/)"
+      "/node_modules/(?!(@meshconnect/solana-web3.js|uuid|jayson|superstruct|@noble|@meshconnect|ethers)/)"
     ],
     "testEnvironmentOptions": {
       "url": "http://localhost/"
@@ -60,4 +60,4 @@
   "module": "./index.js",
   "main": "./index.js",
   "types": "./index.d.ts"
-}
+}

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

@@ -1,2 +1,18 @@
-import { TransactionConfig } from './types';
+import { PublicKey, VersionedTransaction, TransactionInstruction } from '@meshconnect/solana-web3.js';
+import { TransactionConfig, SolanaProvider } from './types';
+export declare function getAssociatedTokenAddress(mint: PublicKey, owner: PublicKey): Promise<PublicKey>;
+export declare function createSPLTransferInstruction({ fromTokenAccount, toTokenAccount, owner, amount }: {
+    fromTokenAccount: PublicKey;
+    toTokenAccount: PublicKey;
+    owner: PublicKey;
+    amount: bigint;
+}): TransactionInstruction;
+export declare function createTransferTransaction(config: {
+    fromAddress: string;
+    toAddress: string;
+    amount: bigint;
+    tokenMint?: string;
+    blockhash: string;
+}): Promise<VersionedTransaction>;
+export declare function handleManualSignAndSend(transaction: VersionedTransaction, provider: SolanaProvider): Promise<string>;
 export declare const sendSOLTransaction: (config: TransactionConfig) => Promise<string>;

package/utils/connectors/solana/transaction.js

@@ -34,125 +34,168 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         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 { PublicKey, SystemProgram, TransactionMessage, VersionedTransaction, TransactionInstruction } from '@meshconnect/solana-web3.js';
 import { getSolanaProvider } from './providerDiscovery';
-var QUICKNODE_RPC = 'https://alien-newest-vineyard.solana-mainnet.quiknode.pro/ebe5e35661d7edb7a5e48ab84bd9d477e472a40b/';
+var TOKEN_PROGRAM_ID = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
+var ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
 var isUserRejection = function (error) {
-    if (!error)
+    if (!error || typeof error !== 'object')
         return false;
-    var message = ((error === null || error === void 0 ? void 0 : error.message) || '').toLowerCase();
+    var err = error;
+    var message = (err.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);
+        err.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 function getAssociatedTokenAddress(mint, owner) {
+    return __awaiter(this, void 0, void 0, function () {
+        var address;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, PublicKey.findProgramAddress([owner.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), mint.toBuffer()], ASSOCIATED_TOKEN_PROGRAM_ID)];
+                case 1:
+                    address = (_a.sent())[0];
+                    return [2 /*return*/, address];
+            }
+        });
     });
-}); };
+}
+export function createSPLTransferInstruction(_a) {
+    var fromTokenAccount = _a.fromTokenAccount, toTokenAccount = _a.toTokenAccount, owner = _a.owner, amount = _a.amount;
+    var data = Buffer.alloc(9);
+    data[0] = 3; // Transfer instruction
+    data.writeBigUInt64LE(amount, 1);
+    return new TransactionInstruction({
+        keys: [
+            { pubkey: fromTokenAccount, isSigner: false, isWritable: true },
+            { pubkey: toTokenAccount, isSigner: false, isWritable: true },
+            { pubkey: owner, isSigner: true, isWritable: false }
+        ],
+        programId: TOKEN_PROGRAM_ID,
+        data: data
+    });
+}
+export function createTransferTransaction(config) {
+    return __awaiter(this, void 0, void 0, function () {
+        var fromPubkey, toPubkey, instruction, tokenMintPubkey, fromTokenAccount, toTokenAccount, messageV0;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    fromPubkey = new PublicKey(config.fromAddress);
+                    toPubkey = new PublicKey(config.toAddress);
+                    if (!!config.tokenMint) return [3 /*break*/, 1];
+                    // Native SOL transfer
+                    instruction = SystemProgram.transfer({
+                        fromPubkey: fromPubkey,
+                        toPubkey: toPubkey,
+                        lamports: Number(config.amount)
+                    });
+                    return [3 /*break*/, 4];
+                case 1:
+                    tokenMintPubkey = new PublicKey(config.tokenMint);
+                    return [4 /*yield*/, getAssociatedTokenAddress(tokenMintPubkey, fromPubkey)];
+                case 2:
+                    fromTokenAccount = _a.sent();
+                    return [4 /*yield*/, getAssociatedTokenAddress(tokenMintPubkey, toPubkey)];
+                case 3:
+                    toTokenAccount = _a.sent();
+                    instruction = createSPLTransferInstruction({
+                        fromTokenAccount: fromTokenAccount,
+                        toTokenAccount: toTokenAccount,
+                        owner: fromPubkey,
+                        amount: BigInt(config.amount)
+                    });
+                    _a.label = 4;
+                case 4:
+                    messageV0 = new TransactionMessage({
+                        payerKey: fromPubkey,
+                        recentBlockhash: config.blockhash,
+                        instructions: [instruction]
+                    }).compileToV0Message();
+                    return [2 /*return*/, new VersionedTransaction(messageV0)];
+            }
+        });
+    });
+}
+export function handleManualSignAndSend(transaction, provider) {
+    return __awaiter(this, void 0, void 0, function () {
+        var signature, signedTransaction, signature, error_1;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 6, , 7]);
+                    if (!provider.signAndSendTransaction) return [3 /*break*/, 2];
+                    return [4 /*yield*/, provider.signAndSendTransaction(transaction)];
+                case 1:
+                    signature = (_b.sent()).signature;
+                    return [2 /*return*/, signature];
+                case 2: return [4 /*yield*/, provider.signTransaction(transaction)];
+                case 3:
+                    signedTransaction = _b.sent();
+                    if (!provider.sendTransaction) {
+                        throw new Error('Provider does not support sendTransaction');
+                    }
+                    return [4 /*yield*/, provider.sendTransaction(signedTransaction)];
+                case 4:
+                    signature = _b.sent();
+                    return [2 /*return*/, signature];
+                case 5: return [3 /*break*/, 7];
+                case 6:
+                    error_1 = _b.sent();
+                    console.error('Error in handleManualSignAndSend:', error_1);
+                    if (error_1 instanceof Error && ((_a = error_1.message) === null || _a === void 0 ? void 0 : _a.includes('User rejected'))) {
+                        throw new Error('Transaction was rejected by user');
+                    }
+                    throw error_1;
+                case 7: 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;
+    var provider, transaction, isManualWallet, signature, error_2, error_3;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                _a.trys.push([0, 9, , 10]);
+                _a.trys.push([0, 8, , 9]);
                 provider = getSolanaProvider(config.walletName);
-                transaction = createTransferTransaction(config);
+                return [4 /*yield*/, createTransferTransaction(config)];
+            case 1:
+                transaction = _a.sent();
                 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]);
+                if (!isManualWallet) return [3 /*break*/, 3];
                 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;
+                if (!provider.signAndSendTransaction) return [3 /*break*/, 7];
+                _a.label = 4;
             case 4:
-                if (!provider.signAndSendTransaction) return [3 /*break*/, 8];
-                _a.label = 5;
-            case 5:
-                _a.trys.push([5, 7, , 8]);
+                _a.trys.push([4, 6, , 7]);
                 return [4 /*yield*/, provider.signAndSendTransaction(transaction)];
-            case 6:
+            case 5:
                 signature = (_a.sent()).signature;
                 return [2 /*return*/, signature];
-            case 7:
-                error_3 = _a.sent();
-                if (isUserRejection(error_3)) {
+            case 6:
+                error_2 = _a.sent();
+                if (isUserRejection(error_2)) {
                     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)) {
+            case 7: return [2 /*return*/, handleManualSignAndSend(transaction, provider)];
+            case 8:
+                error_3 = _a.sent();
+                if (isUserRejection(error_3)) {
                     throw new Error('Transaction was rejected by user');
                 }
-                throw error_4 instanceof Error
-                    ? error_4
+                throw error_3 instanceof Error
+                    ? error_3
                     : new Error("Failed to send SOL transaction with ".concat(config.walletName, " wallet"));
-            case 10: return [2 /*return*/];
+            case 9: return [2 /*return*/];
         }
     });
 }); };

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

@@ -1,4 +1,4 @@
-import { Transaction } from '@solana/web3.js';
+import { Transaction, VersionedTransaction } from '@meshconnect/solana-web3.js';
 export declare enum SolanaWalletType {
     PHANTOM = "phantom",
     SOLFLARE = "solflare",
@@ -31,11 +31,11 @@ export interface SolanaProvider {
     signMessage(message: Uint8Array): Promise<{
         signature: Uint8Array;
     }>;
-    signTransaction(transaction: Transaction): Promise<Transaction>;
-    signAndSendTransaction?(transaction: Transaction): Promise<{
+    signTransaction(transaction: Transaction | VersionedTransaction): Promise<Transaction | VersionedTransaction>;
+    signAndSendTransaction?(transaction: Transaction | VersionedTransaction): Promise<{
         signature: string;
     }>;
-    sendTransaction?(transaction: Transaction): Promise<string>;
+    sendTransaction?(transaction: Transaction | VersionedTransaction): Promise<string>;
 }
 export interface WindowWithSolanaProviders extends Window {
     solana?: SolanaProvider & {
@@ -65,4 +65,7 @@ export interface TransactionConfig {
     fromAddress: string;
     blockhash: string;
     walletName: string;
+    tokenMint?: string;
+    tokenProgram?: string;
+    tokenDecimals?: number;
 }

package/utils/popup.d.ts

@@ -1,3 +1,4 @@
+import { Language } from './types';
 export declare const iframeId = "mesh-link-popup__iframe";
 export declare function removePopup(): void;
-export declare function addPopup(iframeLink: string, language: string | undefined): void;
+export declare function addPopup(iframeLink: string, language: Language | undefined): void;

package/utils/popup.js

@@ -19,9 +19,7 @@ export function addPopup(iframeLink, language) {
     var style = getLinkStyle(iframeLink);
     styleElement.textContent = getStylesContent(style);
     window.document.head.appendChild(styleElement);
-    if (language) {
-        iframeLink = "".concat(iframeLink).concat(iframeLink.includes('?') ? '&' : '?', "lng=").concat(language);
-    }
+    iframeLink = "".concat(iframeLink).concat(iframeLink.includes('?') ? '&' : '?', "lng=").concat(language || 'en');
     var popupRootElement = document.createElement('div');
     popupRootElement.id = popupId;
     var popupBackdropElement = document.createElement('div');

package/utils/types.d.ts

@@ -103,11 +103,14 @@ export interface SmartContractPayload {
     args: unknown[];
     account: string;
     value?: string;
+    walletName?: string;
+    blockhash?: string;
 }
 export interface DisconnectPayload {
     networkType?: string;
     walletName?: string;
 }
+export type Language = 'en' | 'ru';
 export interface LinkOptions {
     /**
      * Client ID that can be obtained at https://dashboard.meshconnect.com/company/keys
@@ -143,9 +146,9 @@ export interface LinkOptions {
      */
     transferDestinationTokens?: IntegrationAccessToken[];
     /**
-     * Link UI language. Right now only 'en' is supported.
+     * Link UI language. Supported: 'en', 'ru'.
      */
-    language?: 'en';
+    language?: Language;
 }
 export interface LinkStyle {
     ir: number;

package/utils/version.d.ts

@@ -1 +1 @@
-export declare const sdkVersion = "3.1.5";
+export declare const sdkVersion = "3.1.6";

package/utils/version.js

@@ -1 +1 @@
-export var sdkVersion = '3.1.5';
+export var sdkVersion = '3.1.6';

package/utils/wallet/SolanaWalletStrategy.d.ts

@@ -17,11 +17,7 @@ export declare class SolanaWalletStrategy extends BaseWalletStrategy {
         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>;
+    sendSmartContractInteraction(payload: SmartContractPayload): Promise<string>;
     getProviders(): {
         id: string;
         type: string;

package/utils/wallet/SolanaWalletStrategy.js

@@ -50,7 +50,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 import { BaseWalletStrategy } from './WalletStrategy';
-import { connectToSolanaWallet, disconnectFromSolanaWallet, signSolanaMessage, sendSOLTransaction, findAvailableSolanaProviders } from '../connectors/solana';
+import { connectToSolanaWallet, disconnectFromSolanaWallet, signSolanaMessage, sendSOLTransaction, findAvailableSolanaProviders, getSolanaProvider } from '../connectors/solana';
 var SolanaWalletStrategy = /** @class */ (function (_super) {
     __extends(SolanaWalletStrategy, _super);
     function SolanaWalletStrategy() {
@@ -169,16 +169,43 @@ var SolanaWalletStrategy = /** @class */ (function (_super) {
             });
         });
     };
-    /**
-     * @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) {
+    SolanaWalletStrategy.prototype.sendSmartContractInteraction = function (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');
+            var provider, senderAddress, _a, decimals, rawAmount, scaledAmount;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        provider = getSolanaProvider(payload.walletName || '');
+                        _a = payload.account;
+                        if (_a) return [3 /*break*/, 2];
+                        return [4 /*yield*/, ((_b = provider.publicKey) === null || _b === void 0 ? void 0 : _b.toString())];
+                    case 1:
+                        _a = (_c.sent());
+                        _c.label = 2;
+                    case 2:
+                        senderAddress = _a;
+                        if (!senderAddress) {
+                            throw new Error('Sender account address is required');
+                        }
+                        decimals = payload.args[2] || 6 // USDC has 6 decimals
+                        ;
+                        rawAmount = payload.args[1];
+                        scaledAmount = rawAmount;
+                        if (!payload.blockhash) {
+                            throw new Error('Blockhash is required for Solana transactions');
+                        }
+                        return [4 /*yield*/, sendSOLTransaction({
+                                toAddress: payload.args[0],
+                                amount: scaledAmount,
+                                fromAddress: senderAddress,
+                                blockhash: payload.blockhash,
+                                walletName: payload.walletName || '',
+                                tokenMint: payload.address,
+                                tokenDecimals: decimals
+                            })];
+                    case 3: return [2 /*return*/, _c.sent()];
+                }
             });
         });
     };