@meshconnect/web-link-sdk 3.2.7 → 3.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meshconnect/web-link-sdk",
-  "version": "3.2.7",
+  "version": "3.2.9",
   "description": "A client-side JS library for integrating with Mesh Connect",
   "exports": "./index.js",
   "license": "MIT",

package/utils/connectors/solana/transaction.js

@@ -64,6 +64,22 @@ export function getAssociatedTokenAddress(mint_1, owner_1) {
         });
     });
 }
+function createTokenAccountInstruction(payer, associatedToken, owner, mint, programId) {
+    if (programId === void 0) { programId = TOKEN_PROGRAM_ID; }
+    var keys = [
+        { pubkey: payer, isSigner: true, isWritable: true },
+        { pubkey: associatedToken, isSigner: false, isWritable: true },
+        { pubkey: owner, isSigner: false, isWritable: false },
+        { pubkey: mint, isSigner: false, isWritable: false },
+        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        { pubkey: programId, isSigner: false, isWritable: false }
+    ];
+    return new TransactionInstruction({
+        keys: keys,
+        programId: ASSOCIATED_TOKEN_PROGRAM_ID,
+        data: Buffer.alloc(0)
+    });
+}
 export function createTransferCheckedInstruction(fromTokenAccount, toTokenAccount, owner, amount, decimals, tokenMint) {
     if (decimals === void 0) { decimals = 9; }
     var data = Buffer.alloc(10);
@@ -99,42 +115,68 @@ export function createSPLTransferInstruction(_a) {
 }
 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) {
+        var fromPubkey, toPubkey, instructions, connection, token2022Accounts, tokenProgram, tokenMintPubkey, fromTokenAccount, toTokenAccount, messageV0;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
                 case 0:
                     fromPubkey = new PublicKey(config.fromAddress);
                     toPubkey = new PublicKey(config.toAddress);
+                    instructions = [];
                     if (!!config.tokenMint) return [3 /*break*/, 1];
-                    instruction = SystemProgram.transfer({
+                    instructions.push(SystemProgram.transfer({
                         fromPubkey: fromPubkey,
                         toPubkey: toPubkey,
                         lamports: Number(config.amount)
-                    });
-                    return [3 /*break*/, 4];
+                    }));
+                    return [3 /*break*/, 6];
                 case 1:
+                    connection = void 0;
+                    // special use case for PYUSD on solana devnet. TODO: make it generic
+                    if (config.tokenMint === 'CXk2AMBfi3TwaEL2468s6zP8xq9NxTXjp9gjMgzeUynM') {
+                        connection = new Connection('https://api.devnet.solana.com', 'confirmed');
+                    }
+                    else {
+                        connection = new Connection('https://api.mainnet-beta.solana.com', 'confirmed');
+                    }
+                    return [4 /*yield*/, connection.getTokenAccountsByOwner(fromPubkey, { programId: TOKEN_2022_PROGRAM_ID })];
+                case 2:
+                    token2022Accounts = _b.sent();
+                    tokenProgram = (token2022Accounts === null || token2022Accounts === void 0 ? void 0 : token2022Accounts.value.length)
+                        ? TOKEN_2022_PROGRAM_ID
+                        : TOKEN_PROGRAM_ID;
+                    config.tokenProgram = tokenProgram.toBase58();
                     tokenMintPubkey = new PublicKey(config.tokenMint);
                     return [4 /*yield*/, getAssociatedTokenAddress(tokenMintPubkey, fromPubkey, config.tokenProgram)];
-                case 2:
-                    fromTokenAccount = _a.sent();
-                    return [4 /*yield*/, getAssociatedTokenAddress(tokenMintPubkey, toPubkey, config.tokenProgram)];
                 case 3:
-                    toTokenAccount = _a.sent();
-                    instruction =
-                        config.tokenProgram === TOKEN_2022_PROGRAM_ID.toBase58()
-                            ? createTransferCheckedInstruction(fromTokenAccount, toTokenAccount, fromPubkey, BigInt(config.amount), config.tokenDecimals, tokenMintPubkey)
-                            : createSPLTransferInstruction({
-                                fromTokenAccount: fromTokenAccount,
-                                toTokenAccount: toTokenAccount,
-                                owner: fromPubkey,
-                                amount: BigInt(config.amount)
-                            });
-                    _a.label = 4;
+                    fromTokenAccount = _b.sent();
+                    return [4 /*yield*/, getAssociatedTokenAddress(tokenMintPubkey, toPubkey, config.tokenProgram)];
                 case 4:
+                    toTokenAccount = _b.sent();
+                    return [4 /*yield*/, connection.getTokenAccountsByOwner(toPubkey, {
+                            programId: tokenProgram
+                        })];
+                case 5:
+                    if (!((_a = (_b.sent())) === null || _a === void 0 ? void 0 : _a.value.length)) {
+                        instructions.push(createTokenAccountInstruction(fromPubkey, toTokenAccount, toPubkey, tokenMintPubkey, tokenProgram));
+                    }
+                    if (config.tokenProgram === TOKEN_2022_PROGRAM_ID.toBase58()) {
+                        instructions.push(createTransferCheckedInstruction(fromTokenAccount, toTokenAccount, fromPubkey, BigInt(config.amount), config.tokenDecimals, tokenMintPubkey));
+                    }
+                    else {
+                        instructions.push(createSPLTransferInstruction({
+                            fromTokenAccount: fromTokenAccount,
+                            toTokenAccount: toTokenAccount,
+                            owner: fromPubkey,
+                            amount: BigInt(config.amount)
+                        }));
+                    }
+                    _b.label = 6;
+                case 6:
                     messageV0 = new TransactionMessage({
                         payerKey: fromPubkey,
                         recentBlockhash: config.blockhash,
-                        instructions: [instruction]
+                        instructions: instructions
                     }).compileToV0Message();
                     return [2 /*return*/, new VersionedTransaction(messageV0)];
             }
@@ -178,55 +220,41 @@ export function handleManualSignAndSend(transaction, provider) {
     });
 }
 export var sendSOLTransaction = function (config) { return __awaiter(void 0, void 0, void 0, function () {
-    var provider, walletPublicKey, connection, token2022Accounts, transaction, isManualWallet, signature, error_2, error_3;
+    var provider, transaction, isManualWallet, signature, error_2, error_3;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                _a.trys.push([0, 10, , 11]);
+                _a.trys.push([0, 8, , 9]);
                 provider = getSolanaProvider(config.walletName);
-                walletPublicKey = new PublicKey(config.fromAddress);
-                if (!config.tokenMint) return [3 /*break*/, 2];
-                connection = void 0;
-                // special use case for PYUSD on solana devnet. TODO: make it generic
-                if (config.tokenMint === 'CXk2AMBfi3TwaEL2468s6zP8xq9NxTXjp9gjMgzeUynM') {
-                    connection = new Connection('https://api.devnet.solana.com', 'confirmed');
-                }
-                else {
-                    connection = new Connection('https://api.mainnet-beta.solana.com', 'confirmed');
-                }
-                return [4 /*yield*/, connection.getTokenAccountsByOwner(walletPublicKey, { programId: TOKEN_2022_PROGRAM_ID })];
+                return [4 /*yield*/, createTransferTransaction(config)];
             case 1:
-                token2022Accounts = _a.sent();
-                config.tokenProgram = (token2022Accounts === null || token2022Accounts === void 0 ? void 0 : token2022Accounts.value.length)
-                    ? TOKEN_2022_PROGRAM_ID.toBase58()
-                    : TOKEN_PROGRAM_ID.toBase58();
-                _a.label = 2;
-            case 2: return [4 /*yield*/, createTransferTransaction(config)];
-            case 3:
                 transaction = _a.sent();
                 isManualWallet = provider.isTrust ||
                     provider.isTrustWallet ||
                     config.walletName.toLowerCase().includes('trust');
-                if (!isManualWallet) return [3 /*break*/, 5];
+                if (!isManualWallet) return [3 /*break*/, 3];
                 return [4 /*yield*/, handleManualSignAndSend(transaction, provider)];
-            case 4: return [2 /*return*/, _a.sent()];
+            case 2: return [2 /*return*/, _a.sent()];
+            case 3:
+                if (!provider.signAndSendTransaction) return [3 /*break*/, 7];
+                _a.label = 4;
+            case 4:
+                _a.trys.push([4, 6, , 7]);
+                return [4 /*yield*/, provider.signAndSendTransaction(transaction)
+                    // @TODO: validate that signature was a successful tx
+                ];
             case 5:
-                if (!provider.signAndSendTransaction) return [3 /*break*/, 9];
-                _a.label = 6;
-            case 6:
-                _a.trys.push([6, 8, , 9]);
-                return [4 /*yield*/, provider.signAndSendTransaction(transaction)];
-            case 7:
                 signature = (_a.sent()).signature;
+                // @TODO: validate that signature was a successful tx
                 return [2 /*return*/, signature];
-            case 8:
+            case 6:
                 error_2 = _a.sent();
                 if (isUserRejection(error_2)) {
                     throw new Error('Transaction was rejected by user');
                 }
                 return [2 /*return*/, handleManualSignAndSend(transaction, provider)];
-            case 9: return [2 /*return*/, handleManualSignAndSend(transaction, provider)];
-            case 10:
+            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');
@@ -234,7 +262,7 @@ export var sendSOLTransaction = function (config) { return __awaiter(void 0, voi
                 throw error_3 instanceof Error
                     ? error_3
                     : new Error("Failed to send SOL transaction with ".concat(config.walletName, " wallet"));
-            case 11: return [2 /*return*/];
+            case 9: return [2 /*return*/];
         }
     });
 }); };

package/utils/version.d.ts

@@ -1 +1 @@
-export declare const sdkVersion = "3.2.7";
+export declare const sdkVersion = "3.2.9";

package/utils/version.js

@@ -1 +1 @@
-export var sdkVersion = '3.2.7';
+export var sdkVersion = '3.2.9';