@meshconnect/web-link-sdk 3.3.2 → 3.3.4

package/utils/connectors/solana/transaction.js

@@ -1,362 +0,0 @@
-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 { PublicKey, SystemProgram, TransactionMessage, VersionedTransaction, TransactionInstruction } 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')
-        return false;
-    var err = error;
-    var message = (err.message || '').toLowerCase();
-    return (message.includes('user rejected') ||
-        message.includes('declined') ||
-        message.includes('cancelled') ||
-        message.includes('denied') ||
-        err.code === 4001);
-};
-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(), new PublicKey(programId).toBuffer(), mint.toBuffer()], ASSOCIATED_TOKEN_PROGRAM_ID)];
-                case 1:
-                    address = (_a.sent())[0];
-                    return [2 /*return*/, address];
-            }
-        });
-    });
-}
-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);
-    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);
-    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 instructions, fromPubkey, messageV0;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, createTransferInstructions(config)];
-                case 1:
-                    instructions = _a.sent();
-                    fromPubkey = new PublicKey(config.fromAddress);
-                    messageV0 = new TransactionMessage({
-                        payerKey: fromPubkey,
-                        recentBlockhash: config.blockhash,
-                        instructions: instructions
-                    }).compileToV0Message();
-                    return [2 /*return*/, new VersionedTransaction(messageV0)];
-            }
-        });
-    });
-}
-function createTransferInstructions(config) {
-    return __awaiter(this, void 0, void 0, function () {
-        var fromPubkey, toPubkey, instructions, tokenMintPubkey, fromTokenAccount, toTokenAccount;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    fromPubkey = new PublicKey(config.fromAddress);
-                    toPubkey = new PublicKey(config.toAddress);
-                    instructions = [];
-                    if (!!config.tokenMint) return [3 /*break*/, 1];
-                    instructions.push(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, config.tokenProgram)];
-                case 2:
-                    fromTokenAccount = _a.sent();
-                    return [4 /*yield*/, getAssociatedTokenAddress(tokenMintPubkey, toPubkey, config.tokenProgram)];
-                case 3:
-                    toTokenAccount = _a.sent();
-                    if (config.createATA) {
-                        instructions.push(createTokenAccountInstruction(fromPubkey, toTokenAccount, toPubkey, tokenMintPubkey, config.tokenProgram
-                            ? new PublicKey(config.tokenProgram)
-                            : TOKEN_PROGRAM_ID));
-                    }
-                    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)
-                        }));
-                    }
-                    _a.label = 4;
-                case 4: return [2 /*return*/, instructions];
-            }
-        });
-    });
-}
-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 function getTransferInstructions(instructions) {
-    return __awaiter(this, void 0, void 0, function () {
-        var result, _loop_1, instrIndex;
-        return __generator(this, function (_a) {
-            result = [];
-            _loop_1 = function (instrIndex) {
-                var ix = instructions[instrIndex];
-                var programId = new PublicKey(ix.programId);
-                var keys = ix.accounts.map(function (meta, accountIndex) {
-                    if (!meta.pubKey) {
-                        throw new Error("Account at instruction ".concat(instrIndex, ", index ").concat(accountIndex, " has no pubKey and is not fillable"));
-                    }
-                    var resolvedPubkey = new PublicKey(meta.pubKey);
-                    return {
-                        pubkey: resolvedPubkey,
-                        isSigner: meta.isSigner,
-                        isWritable: meta.isWritable
-                    };
-                });
-                result.push(new TransactionInstruction({
-                    keys: keys,
-                    programId: programId,
-                    data: Buffer.from(ix.data, 'base64')
-                }));
-            };
-            for (instrIndex = 0; instrIndex < instructions.length; instrIndex++) {
-                _loop_1(instrIndex);
-            }
-            return [2 /*return*/, result];
-        });
-    });
-}
-export var sendSOLTransaction = function (config) { return __awaiter(void 0, void 0, void 0, function () {
-    var provider, transaction, isManualWallet, signature, error_2, error_3;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                _a.trys.push([0, 8, , 9]);
-                provider = getSolanaProvider(config.walletName);
-                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*/, 3];
-                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)
-                    // @TODO: validate that signature was a successful tx
-                ];
-            case 5:
-                signature = (_a.sent()).signature;
-                // @TODO: validate that signature was a successful tx
-                return [2 /*return*/, signature];
-            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 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_3 instanceof Error
-                    ? error_3
-                    : new Error("Failed to send SOL transaction with ".concat(config.walletName, " wallet"));
-            case 9: return [2 /*return*/];
-        }
-    });
-}); };
-export var sendSOLTransactionWithInstructions = function (payload, transferConfig) { return __awaiter(void 0, void 0, void 0, function () {
-    var walletName, instructions, fromPubkey, transferInstructions, transaction, error_4;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                walletName = payload.transactionInstructions.walletName || 'Phantom';
-                _a.label = 1;
-            case 1:
-                _a.trys.push([1, 5, , 6]);
-                return [4 /*yield*/, getTransferInstructions(payload.transactionInstructions.instructions)];
-            case 2:
-                instructions = _a.sent();
-                fromPubkey = new PublicKey(transferConfig.fromAddress);
-                return [4 /*yield*/, createTransferInstructions(transferConfig)];
-            case 3:
-                transferInstructions = _a.sent();
-                instructions.push.apply(instructions, transferInstructions);
-                transaction = new VersionedTransaction(new TransactionMessage({
-                    payerKey: fromPubkey,
-                    recentBlockhash: payload.transactionInstructions.blockhash,
-                    instructions: instructions
-                }).compileToV0Message());
-                return [4 /*yield*/, sendSolanaTransfer(walletName, transaction)];
-            case 4: return [2 /*return*/, _a.sent()];
-            case 5:
-                error_4 = _a.sent();
-                if (isUserRejection(error_4)) {
-                    throw new Error('Transaction was rejected by user');
-                }
-                throw error_4 instanceof Error
-                    ? error_4
-                    : new Error("Failed to send SOL transaction with ".concat(walletName, " wallet"));
-            case 6: return [2 /*return*/];
-        }
-    });
-}); };
-export var sendSolanaTransfer = function (walletName, transaction) { return __awaiter(void 0, void 0, void 0, function () {
-    var provider, isManualWallet, signature, error_5;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                provider = getSolanaProvider(walletName);
-                isManualWallet = provider.isTrust ||
-                    provider.isTrustWallet ||
-                    walletName.includes('trust');
-                if (!isManualWallet) return [3 /*break*/, 2];
-                return [4 /*yield*/, handleManualSignAndSend(transaction, provider)];
-            case 1: return [2 /*return*/, _a.sent()];
-            case 2:
-                if (!provider.signAndSendTransaction) return [3 /*break*/, 6];
-                _a.label = 3;
-            case 3:
-                _a.trys.push([3, 5, , 6]);
-                return [4 /*yield*/, provider.signAndSendTransaction(transaction)];
-            case 4:
-                signature = (_a.sent()).signature;
-                return [2 /*return*/, signature];
-            case 5:
-                error_5 = _a.sent();
-                if (isUserRejection(error_5)) {
-                    throw new Error('Transaction was rejected by user');
-                }
-                return [2 /*return*/, handleManualSignAndSend(transaction, provider)];
-            case 6: return [2 /*return*/, handleManualSignAndSend(transaction, provider)];
-        }
-    });
-}); };

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

@@ -1,71 +0,0 @@
-import { Transaction, VersionedTransaction } from '@meshconnect/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 | VersionedTransaction): Promise<Transaction | VersionedTransaction>;
-    signAndSendTransaction?(transaction: Transaction | VersionedTransaction): Promise<{
-        signature: string;
-    }>;
-    sendTransaction?(transaction: Transaction | VersionedTransaction): Promise<string>;
-    isPhantom?: boolean;
-    isSolflare?: boolean;
-    isTrust?: boolean;
-    isTrustWallet?: boolean;
-    isExodus?: boolean;
-}
-export interface WindowWithSolanaProviders extends Window {
-    solana?: SolanaProvider;
-    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;
-    tokenMint?: string;
-    createATA?: boolean;
-    tokenProgram?: string;
-    tokenDecimals?: number;
-}

package/utils/connectors/solana/types.js

@@ -1,8 +0,0 @@
-export var SolanaWalletType;
-(function (SolanaWalletType) {
-    SolanaWalletType["PHANTOM"] = "phantom";
-    SolanaWalletType["SOLFLARE"] = "solflare";
-    SolanaWalletType["TRUST"] = "trustwallet";
-    SolanaWalletType["EXODUS"] = "exodus";
-    SolanaWalletType["UNKNOWN"] = "unknown";
-})(SolanaWalletType || (SolanaWalletType = {}));

package/utils/wallet/EVMWalletStrategy.d.ts

@@ -1,31 +0,0 @@
-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;
-    }[];
-}