@meshconnect/web-link-sdk 3.2.5 → 3.2.6

package/package.json

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

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

@@ -1,18 +1,13 @@
 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 getAssociatedTokenAddress(mint: PublicKey, owner: PublicKey, programId?: string): Promise<PublicKey>;
+export declare function createTransferCheckedInstruction(fromTokenAccount: PublicKey, toTokenAccount: PublicKey, owner: PublicKey, amount: bigint, decimals: number | undefined, tokenMint: PublicKey): TransactionInstruction;
 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 createTransferTransaction(config: TransactionConfig): 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,9 +34,10 @@ 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 { PublicKey, SystemProgram, TransactionMessage, VersionedTransaction, TransactionInstruction } from '@meshconnect/solana-web3.js';
+import { PublicKey, SystemProgram, TransactionMessage, VersionedTransaction, TransactionInstruction, Connection } from '@meshconnect/solana-web3.js';
 import { getSolanaProvider } from './providerDiscovery';
 var TOKEN_PROGRAM_ID = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
+var TOKEN_2022_PROGRAM_ID = new PublicKey('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb');
 var ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
 var isUserRejection = function (error) {
     if (!error || typeof error !== 'object')
@@ -49,12 +50,13 @@ var isUserRejection = function (error) {
         message.includes('denied') ||
         err.code === 4001);
 };
-export function getAssociatedTokenAddress(mint, owner) {
-    return __awaiter(this, void 0, void 0, function () {
+export function getAssociatedTokenAddress(mint_1, owner_1) {
+    return __awaiter(this, arguments, void 0, function (mint, owner, programId) {
         var address;
+        if (programId === void 0) { programId = TOKEN_PROGRAM_ID.toBase58(); }
         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 0: return [4 /*yield*/, PublicKey.findProgramAddress([owner.toBuffer(), new PublicKey(programId).toBuffer(), mint.toBuffer()], ASSOCIATED_TOKEN_PROGRAM_ID)];
                 case 1:
                     address = (_a.sent())[0];
                     return [2 /*return*/, address];
@@ -62,6 +64,24 @@ export function getAssociatedTokenAddress(mint, owner) {
         });
     });
 }
+export function createTransferCheckedInstruction(fromTokenAccount, toTokenAccount, owner, amount, decimals, tokenMint) {
+    if (decimals === void 0) { decimals = 9; }
+    var data = Buffer.alloc(10);
+    data[0] = 12; // TransferChecked instruction enum
+    data.writeBigUInt64LE(amount, 1); // 8-byte amount
+    data[9] = decimals; // single-byte decimal
+    var programId = TOKEN_2022_PROGRAM_ID;
+    return new TransactionInstruction({
+        keys: [
+            { pubkey: fromTokenAccount, isSigner: false, isWritable: true },
+            { pubkey: tokenMint, isSigner: false, isWritable: false },
+            { pubkey: toTokenAccount, isSigner: false, isWritable: true },
+            { pubkey: owner, isSigner: true, isWritable: false }
+        ],
+        programId: programId,
+        data: data
+    });
+}
 export function createSPLTransferInstruction(_a) {
     var fromTokenAccount = _a.fromTokenAccount, toTokenAccount = _a.toTokenAccount, owner = _a.owner, amount = _a.amount;
     var data = Buffer.alloc(9);
@@ -86,7 +106,6 @@ export function createTransferTransaction(config) {
                     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,
@@ -95,18 +114,21 @@ export function createTransferTransaction(config) {
                     return [3 /*break*/, 4];
                 case 1:
                     tokenMintPubkey = new PublicKey(config.tokenMint);
-                    return [4 /*yield*/, getAssociatedTokenAddress(tokenMintPubkey, fromPubkey)];
+                    return [4 /*yield*/, getAssociatedTokenAddress(tokenMintPubkey, fromPubkey, config.tokenProgram)];
                 case 2:
                     fromTokenAccount = _a.sent();
-                    return [4 /*yield*/, getAssociatedTokenAddress(tokenMintPubkey, toPubkey)];
+                    return [4 /*yield*/, getAssociatedTokenAddress(tokenMintPubkey, toPubkey, config.tokenProgram)];
                 case 3:
                     toTokenAccount = _a.sent();
-                    instruction = createSPLTransferInstruction({
-                        fromTokenAccount: fromTokenAccount,
-                        toTokenAccount: toTokenAccount,
-                        owner: fromPubkey,
-                        amount: BigInt(config.amount)
-                    });
+                    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;
                 case 4:
                     messageV0 = new TransactionMessage({
@@ -156,38 +178,55 @@ export function handleManualSignAndSend(transaction, provider) {
     });
 }
 export var sendSOLTransaction = function (config) { return __awaiter(void 0, void 0, void 0, function () {
-    var provider, transaction, isManualWallet, signature, error_2, error_3;
+    var provider, walletPublicKey, connection, token2022Accounts, transaction, isManualWallet, signature, error_2, error_3;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                _a.trys.push([0, 8, , 9]);
+                _a.trys.push([0, 10, , 11]);
                 provider = getSolanaProvider(config.walletName);
-                return [4 /*yield*/, createTransferTransaction(config)];
+                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 })];
             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*/, 3];
+                if (!isManualWallet) return [3 /*break*/, 5];
                 return [4 /*yield*/, handleManualSignAndSend(transaction, provider)];
-            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)];
+            case 4: return [2 /*return*/, _a.sent()];
             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;
                 return [2 /*return*/, signature];
-            case 6:
+            case 8:
                 error_2 = _a.sent();
                 if (isUserRejection(error_2)) {
                     throw new Error('Transaction was rejected by user');
                 }
                 return [2 /*return*/, handleManualSignAndSend(transaction, provider)];
-            case 7: return [2 /*return*/, handleManualSignAndSend(transaction, provider)];
-            case 8:
+            case 9: return [2 /*return*/, handleManualSignAndSend(transaction, provider)];
+            case 10:
                 error_3 = _a.sent();
                 if (isUserRejection(error_3)) {
                     throw new Error('Transaction was rejected by user');
@@ -195,7 +234,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 9: return [2 /*return*/];
+            case 11: return [2 /*return*/];
         }
     });
 }); };

package/utils/version.d.ts

@@ -1 +1 @@
-export declare const sdkVersion = "3.2.5";
+export declare const sdkVersion = "3.2.6";

package/utils/version.js

@@ -1 +1 @@
-export var sdkVersion = '3.2.5';
+export var sdkVersion = '3.2.6';