@wallfree-dev/solana 0.13.43-beta.2 → 0.13.43-beta.6

package/v1/protocol/SolanaSPLTokenProtocol.js

@@ -0,0 +1,1129 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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;
+    return g = { next: verb(0), "throw": verb(1), "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 (_) 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 };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSolanaSPLTokenProtocol = exports.SolanaSPLTokenProtocolImpl = void 0;
+var module_kit_1 = require("@wallfree-dev/module-kit");
+var solanaWeb3 = __importStar(require("@solana/web3.js"));
+// @ts-ignore
+var bs58 = __importStar(require("bs58"));
+var nacl = __importStar(require("tweetnacl"));
+var bignumber_1 = require("@wallfree-dev/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber");
+var SolanaProtocol_1 = require("./SolanaProtocol");
+// SPL Token Program ID
+var TOKEN_PROGRAM_ID = new solanaWeb3.PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
+var ASSOCIATED_TOKEN_PROGRAM_ID = new solanaWeb3.PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
+// Rent exemption for a token account (165 bytes) - approximately 0.00203928 SOL
+// This is the minimum balance required to keep a token account alive
+var TOKEN_ACCOUNT_RENT_EXEMPTION_LAMPORTS = 2039280;
+// Implementation
+var SolanaSPLTokenProtocolImpl = /** @class */ (function () {
+    function SolanaSPLTokenProtocolImpl(options) {
+        this.options = options;
+        this.units = options.units;
+        this.mainUnit = options.mainUnit;
+    }
+    // Helper for RPC calls with fallback to backup endpoints
+    SolanaSPLTokenProtocolImpl.prototype.withFallback = function (fn, maxRetries) {
+        var _a, _b, _c, _d, _e;
+        if (maxRetries === void 0) { maxRetries = 2; }
+        return __awaiter(this, void 0, void 0, function () {
+            var allUrls, lastError, _i, allUrls_1, rpcUrl, _loop_1, retry, state_1;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        allUrls = __spreadArray([this.options.network.rpcUrl], SolanaSPLTokenProtocolImpl.FALLBACK_RPC_URLS, true);
+                        _i = 0, allUrls_1 = allUrls;
+                        _f.label = 1;
+                    case 1:
+                        if (!(_i < allUrls_1.length)) return [3 /*break*/, 6];
+                        rpcUrl = allUrls_1[_i];
+                        _loop_1 = function (retry) {
+                            var connection, _g, e_1, isTemporaryError;
+                            return __generator(this, function (_h) {
+                                switch (_h.label) {
+                                    case 0:
+                                        _h.trys.push([0, 2, , 5]);
+                                        connection = new solanaWeb3.Connection(rpcUrl);
+                                        _g = {};
+                                        return [4 /*yield*/, fn(connection)];
+                                    case 1: return [2 /*return*/, (_g.value = _h.sent(), _g)];
+                                    case 2:
+                                        e_1 = _h.sent();
+                                        lastError = e_1;
+                                        isTemporaryError = ((_a = e_1 === null || e_1 === void 0 ? void 0 : e_1.message) === null || _a === void 0 ? void 0 : _a.includes('500')) ||
+                                            ((_b = e_1 === null || e_1 === void 0 ? void 0 : e_1.message) === null || _b === void 0 ? void 0 : _b.includes('502')) ||
+                                            ((_c = e_1 === null || e_1 === void 0 ? void 0 : e_1.message) === null || _c === void 0 ? void 0 : _c.includes('503')) ||
+                                            ((_d = e_1 === null || e_1 === void 0 ? void 0 : e_1.message) === null || _d === void 0 ? void 0 : _d.includes('code":19')) ||
+                                            ((_e = e_1 === null || e_1 === void 0 ? void 0 : e_1.message) === null || _e === void 0 ? void 0 : _e.includes('Temporary'));
+                                        if (!isTemporaryError) {
+                                            return [2 /*return*/, "break"];
+                                        }
+                                        if (!(retry < maxRetries - 1)) return [3 /*break*/, 4];
+                                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1000 * (retry + 1)); })];
+                                    case 3:
+                                        _h.sent();
+                                        _h.label = 4;
+                                    case 4: return [3 /*break*/, 5];
+                                    case 5: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        retry = 0;
+                        _f.label = 2;
+                    case 2:
+                        if (!(retry < maxRetries)) return [3 /*break*/, 5];
+                        return [5 /*yield**/, _loop_1(retry)];
+                    case 3:
+                        state_1 = _f.sent();
+                        if (typeof state_1 === "object")
+                            return [2 /*return*/, state_1.value];
+                        if (state_1 === "break")
+                            return [3 /*break*/, 5];
+                        _f.label = 4;
+                    case 4:
+                        retry++;
+                        return [3 /*break*/, 2];
+                    case 5:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 6: throw lastError;
+                }
+            });
+        });
+    };
+    // SubProtocol methods
+    SolanaSPLTokenProtocolImpl.prototype.getType = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, 'token'];
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.mainProtocol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.mainIdentifier];
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.getContractAddress = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.contractAddress];
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.getMetadata = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        identifier: this.options.identifier,
+                        name: this.options.name,
+                        units: this.units,
+                        mainUnit: this.mainUnit,
+                        fee: {
+                            defaults: {
+                                low: (0, module_kit_1.newAmount)(0.000005, 'SOL'),
+                                medium: (0, module_kit_1.newAmount)(0.000005, 'SOL'),
+                                high: (0, module_kit_1.newAmount)(0.000005, 'SOL')
+                            },
+                            units: SolanaProtocol_1.SOLANA_UNITS_METADATA,
+                            mainUnit: 'SOL'
+                        },
+                        account: {
+                            standardDerivationPath: "m/44'/501'/0'/0'",
+                            address: {
+                                isCaseSensitive: true,
+                                placeholder: '...',
+                                regex: '^[1-9A-HJ-NP-Za-km-z]{32,44}$'
+                            }
+                        }
+                    }];
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.getPublicKeyBuffer = function (publicKey) {
+        if (publicKey.format === 'hex') {
+            return Buffer.from(publicKey.value, 'hex');
+        }
+        else if (publicKey.format === 'encoded') {
+            return bs58.decode(publicKey.value);
+        }
+        return Buffer.from(publicKey.value, 'hex');
+    };
+    SolanaSPLTokenProtocolImpl.prototype.getAddressFromPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pubKeyBytes;
+            return __generator(this, function (_a) {
+                pubKeyBytes = this.getPublicKeyBuffer(publicKey);
+                return [2 /*return*/, bs58.encode(pubKeyBytes)];
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.getAddressesFromPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, [{
+                                    address: address,
+                                    cursor: { hasNext: false }
+                                }]];
+                }
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.validateAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pubkey;
+            return __generator(this, function (_a) {
+                try {
+                    pubkey = new solanaWeb3.PublicKey(address);
+                    // Additional check: ensure it's on the ed25519 curve (valid public key)
+                    // Note: Some special addresses like program IDs may not be on curve, so we accept both
+                    return [2 /*return*/, pubkey.toBytes().length === 32];
+                }
+                catch (_b) {
+                    return [2 /*return*/, false];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    // Get Associated Token Address for a wallet
+    SolanaSPLTokenProtocolImpl.prototype.getAssociatedTokenAddress = function (walletAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var walletPubkey, mintPubkey, ata;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        walletPubkey = new solanaWeb3.PublicKey(walletAddress);
+                        mintPubkey = new solanaWeb3.PublicKey(this.options.contractAddress);
+                        return [4 /*yield*/, solanaWeb3.PublicKey.findProgramAddress([
+                                walletPubkey.toBuffer(),
+                                TOKEN_PROGRAM_ID.toBuffer(),
+                                mintPubkey.toBuffer()
+                            ], ASSOCIATED_TOKEN_PROGRAM_ID)];
+                    case 1:
+                        ata = (_a.sent())[0];
+                        return [2 /*return*/, ata];
+                }
+            });
+        });
+    };
+    // Get wallet address from ATA by fetching account info
+    // Returns the owner (wallet) address of a token account
+    SolanaSPLTokenProtocolImpl.prototype.getWalletAddressFromAta = function (ataAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var ataPubkey_1, accountInfo, ownerBytes, ownerPubkey, e_2;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        ataPubkey_1 = new solanaWeb3.PublicKey(ataAddress);
+                        return [4 /*yield*/, this.withFallback(function (connection) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                                return [2 /*return*/, connection.getAccountInfo(ataPubkey_1)];
+                            }); }); })];
+                    case 1:
+                        accountInfo = _a.sent();
+                        if (!accountInfo || !accountInfo.data) {
+                            return [2 /*return*/, null];
+                        }
+                        ownerBytes = accountInfo.data.slice(32, 64);
+                        ownerPubkey = new solanaWeb3.PublicKey(ownerBytes);
+                        return [2 /*return*/, ownerPubkey.toBase58()];
+                    case 2:
+                        e_2 = _a.sent();
+                        console.warn('[solana-spl][getWalletAddressFromAta] Failed to get wallet address:', e_2);
+                        return [2 /*return*/, null];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.getBalanceOfAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var walletPubkey_1, mintPubkey_1, tokenAccounts, totalBalance, _i, _a, account, data, amountBytes, amount, e_3;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        walletPubkey_1 = new solanaWeb3.PublicKey(address);
+                        mintPubkey_1 = new solanaWeb3.PublicKey(this.options.contractAddress);
+                        return [4 /*yield*/, this.withFallback(function (connection) { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    return [2 /*return*/, connection.getTokenAccountsByOwner(walletPubkey_1, { mint: mintPubkey_1 })];
+                                });
+                            }); })];
+                    case 1:
+                        tokenAccounts = _b.sent();
+                        totalBalance = new bignumber_1.BigNumber(0);
+                        for (_i = 0, _a = tokenAccounts.value; _i < _a.length; _i++) {
+                            account = _a[_i].account;
+                            data = account.data;
+                            amountBytes = data.slice(64, 72);
+                            amount = this.readU64LE(amountBytes);
+                            totalBalance = totalBalance.plus(amount);
+                        }
+                        return [2 /*return*/, {
+                                total: (0, module_kit_1.newAmount)(totalBalance.toString(), 'blockchain')
+                            }];
+                    case 2:
+                        e_3 = _b.sent();
+                        console.error('[solana-spl][balance][error]', e_3);
+                        return [2 /*return*/, { total: (0, module_kit_1.newAmount)(0, 'blockchain') }];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // Helper to read u64 little-endian (browser compatible)
+    SolanaSPLTokenProtocolImpl.prototype.readU64LE = function (bytes) {
+        var result = new bignumber_1.BigNumber(0);
+        for (var i = 7; i >= 0; i--) {
+            result = result.times(256).plus(bytes[i] || 0);
+        }
+        return result;
+    };
+    // Helper to write u64 little-endian (browser compatible)
+    SolanaSPLTokenProtocolImpl.prototype.writeU64LE = function (buffer, value, offset) {
+        var remaining = value;
+        for (var i = 0; i < 8; i++) {
+            buffer[offset + i] = Number(remaining & BigInt(0xff));
+            remaining = remaining >> BigInt(8);
+        }
+    };
+    SolanaSPLTokenProtocolImpl.prototype.getBalanceOfPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.getBalanceOfAddress(address)];
+                }
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.getDetailsFromTransaction = function (transaction, publicKey) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        return __awaiter(this, void 0, void 0, function () {
+            var tx, fallbackFeePayer, _k, _l, _m, feePayer, fee, connection, feeInfo, e_4, _i, _o, ix, amountBytes, amount, destAta, ownerWallet, toWallet, resolvedWallet, _p, amountBytes, amount, destAta, ownerWallet, toWallet, resolvedWallet, _q, e_5;
+            return __generator(this, function (_r) {
+                switch (_r.label) {
+                    case 0:
+                        _r.trys.push([0, 20, , 21]);
+                        tx = solanaWeb3.Transaction.from(Buffer.from(transaction.serialized, 'hex'));
+                        if (!(publicKey !== null && publicKey !== undefined)) return [3 /*break*/, 2];
+                        _m = (_l = solanaWeb3.PublicKey).bind;
+                        return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        _k = new (_m.apply(_l, [void 0, _r.sent()]))();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _k = undefined;
+                        _r.label = 3;
+                    case 3:
+                        fallbackFeePayer = _k;
+                        feePayer = (tx === null || tx === void 0 ? void 0 : tx.feePayer) || (tx.signatures.length > 0 ? tx.signatures[0].publicKey : fallbackFeePayer);
+                        fee = (0, module_kit_1.newAmount)(5000, 'Lamports');
+                        _r.label = 4;
+                    case 4:
+                        _r.trys.push([4, 6, , 7]);
+                        connection = new solanaWeb3.Connection(this.options.network.rpcUrl);
+                        return [4 /*yield*/, connection.getFeeForMessage(tx.compileMessage())];
+                    case 5:
+                        feeInfo = _r.sent();
+                        fee = (0, module_kit_1.newAmount)((_a = feeInfo === null || feeInfo === void 0 ? void 0 : feeInfo.value) !== null && _a !== void 0 ? _a : 5000, 'Lamports');
+                        return [3 /*break*/, 7];
+                    case 6:
+                        e_4 = _r.sent();
+                        console.warn('[solana-spl][getDetailsFromTransaction] Network unavailable, using default fee');
+                        return [3 /*break*/, 7];
+                    case 7:
+                        _i = 0, _o = tx.instructions;
+                        _r.label = 8;
+                    case 8:
+                        if (!(_i < _o.length)) return [3 /*break*/, 19];
+                        ix = _o[_i];
+                        if (!ix.programId.equals(TOKEN_PROGRAM_ID)) return [3 /*break*/, 18];
+                        if (!(ix.data.length >= 9 && ix.data[0] === 3)) return [3 /*break*/, 13];
+                        amountBytes = ix.data.slice(1, 9);
+                        amount = this.readU64LE(amountBytes).toString();
+                        destAta = ((_c = (_b = ix.keys[1]) === null || _b === void 0 ? void 0 : _b.pubkey) === null || _c === void 0 ? void 0 : _c.toBase58()) || '';
+                        ownerWallet = ((_e = (_d = ix.keys[2]) === null || _d === void 0 ? void 0 : _d.pubkey) === null || _e === void 0 ? void 0 : _e.toBase58()) || (feePayer === null || feePayer === void 0 ? void 0 : feePayer.toBase58()) || '';
+                        toWallet = destAta;
+                        _r.label = 9;
+                    case 9:
+                        _r.trys.push([9, 11, , 12]);
+                        return [4 /*yield*/, this.getWalletAddressFromAta(destAta)];
+                    case 10:
+                        resolvedWallet = _r.sent();
+                        if (resolvedWallet) {
+                            toWallet = resolvedWallet;
+                        }
+                        return [3 /*break*/, 12];
+                    case 11:
+                        _p = _r.sent();
+                        return [3 /*break*/, 12];
+                    case 12: return [2 /*return*/, [{
+                                from: [ownerWallet],
+                                to: [toWallet],
+                                amount: (0, module_kit_1.newAmount)(amount, 'blockchain'),
+                                fee: fee,
+                                isInbound: false,
+                                network: this.options.network
+                            }]];
+                    case 13:
+                        if (!(ix.data.length >= 10 && ix.data[0] === 12)) return [3 /*break*/, 18];
+                        amountBytes = ix.data.slice(1, 9);
+                        amount = this.readU64LE(amountBytes).toString();
+                        destAta = ((_g = (_f = ix.keys[2]) === null || _f === void 0 ? void 0 : _f.pubkey) === null || _g === void 0 ? void 0 : _g.toBase58()) || '';
+                        ownerWallet = ((_j = (_h = ix.keys[3]) === null || _h === void 0 ? void 0 : _h.pubkey) === null || _j === void 0 ? void 0 : _j.toBase58()) || (feePayer === null || feePayer === void 0 ? void 0 : feePayer.toBase58()) || '';
+                        toWallet = destAta;
+                        _r.label = 14;
+                    case 14:
+                        _r.trys.push([14, 16, , 17]);
+                        return [4 /*yield*/, this.getWalletAddressFromAta(destAta)];
+                    case 15:
+                        resolvedWallet = _r.sent();
+                        if (resolvedWallet) {
+                            toWallet = resolvedWallet;
+                        }
+                        return [3 /*break*/, 17];
+                    case 16:
+                        _q = _r.sent();
+                        return [3 /*break*/, 17];
+                    case 17: return [2 /*return*/, [{
+                                from: [ownerWallet],
+                                to: [toWallet],
+                                amount: (0, module_kit_1.newAmount)(amount, 'blockchain'),
+                                fee: fee,
+                                isInbound: false,
+                                network: this.options.network
+                            }]];
+                    case 18:
+                        _i++;
+                        return [3 /*break*/, 8];
+                    case 19: 
+                    // Fallback
+                    return [2 /*return*/, [{
+                                from: [(feePayer === null || feePayer === void 0 ? void 0 : feePayer.toBase58()) || ''],
+                                to: [],
+                                amount: (0, module_kit_1.newAmount)(0, 'blockchain'),
+                                fee: fee,
+                                isInbound: false,
+                                network: this.options.network
+                            }]];
+                    case 20:
+                        e_5 = _r.sent();
+                        console.error('[solana-spl][getDetailsFromTransaction] Failed:', e_5);
+                        return [2 /*return*/, [{
+                                    from: [],
+                                    to: [],
+                                    amount: (0, module_kit_1.newAmount)(0, 'blockchain'),
+                                    fee: (0, module_kit_1.newAmount)(0, 'Lamports'),
+                                    isInbound: false,
+                                    network: this.options.network
+                                }]];
+                    case 21: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.getTransactionDetailsFromSigned = function (signedTx) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getDetailsFromTransaction(signedTx.transaction, null)];
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.verifyMessageWithPublicKey = function (message, signature, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var messageBytes, signatureBytes, pubKeyBytes;
+            return __generator(this, function (_a) {
+                try {
+                    messageBytes = Buffer.from(message);
+                    signatureBytes = Buffer.from(signature.value, signature.format === 'hex' ? 'hex' : undefined);
+                    pubKeyBytes = this.getPublicKeyBuffer(publicKey);
+                    return [2 /*return*/, nacl.sign.detached.verify(messageBytes, signatureBytes, pubKeyBytes)];
+                }
+                catch (e) {
+                    return [2 /*return*/, false];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.encryptAsymmetricWithPublicKey = function (payload, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('Not implemented');
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.getCryptoConfiguration = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, { algorithm: 'ed25519' }];
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.getKeyPairFromDerivative = function (derivative) {
+        return __awaiter(this, void 0, void 0, function () {
+            var secretKeyBuffer, publicKeyBuffer;
+            return __generator(this, function (_a) {
+                secretKeyBuffer = Buffer.from(derivative.secretKey, 'hex');
+                publicKeyBuffer = Buffer.from(derivative.publicKey, 'hex');
+                return [2 /*return*/, {
+                        publicKey: {
+                            value: publicKeyBuffer.toString('hex'),
+                            format: 'hex',
+                            type: 'pub'
+                        },
+                        secretKey: {
+                            value: secretKeyBuffer.toString('hex'),
+                            format: 'hex',
+                            type: 'priv'
+                        }
+                    }];
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.signTransactionWithSecretKey = function (transaction, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tx, keyHex, secretKeyBytes, keyPair;
+            return __generator(this, function (_a) {
+                tx = solanaWeb3.Transaction.from(Buffer.from(transaction.serialized, 'hex'));
+                keyHex = secretKey.value;
+                secretKeyBytes = Buffer.from(keyHex, secretKey.format === 'hex' ? 'hex' : undefined);
+                try {
+                    if (secretKeyBytes.length === 64) {
+                        keyPair = solanaWeb3.Keypair.fromSecretKey(secretKeyBytes);
+                    }
+                    else if (secretKeyBytes.length === 32) {
+                        keyPair = solanaWeb3.Keypair.fromSeed(secretKeyBytes);
+                    }
+                    else {
+                        throw new Error("Invalid secret key length: ".concat(secretKeyBytes.length));
+                    }
+                }
+                catch (e) {
+                    throw new Error("Could not create keypair from secret key: ".concat(e));
+                }
+                tx.sign(keyPair);
+                return [2 /*return*/, {
+                        serialized: tx.serialize().toString('hex'),
+                        type: 'signed'
+                    }];
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.signMessageWithKeyPair = function (message, keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            var messageBytes, secretKeyBytes, signingKey, signature;
+            return __generator(this, function (_a) {
+                messageBytes = Buffer.from(message);
+                secretKeyBytes = Buffer.from(keyPair.secretKey.value, keyPair.secretKey.format === 'hex' ? 'hex' : undefined);
+                if (secretKeyBytes.length === 64) {
+                    signingKey = secretKeyBytes;
+                }
+                else if (secretKeyBytes.length === 32) {
+                    signingKey = nacl.sign.keyPair.fromSeed(secretKeyBytes).secretKey;
+                }
+                else {
+                    throw new Error('Invalid secret key length');
+                }
+                signature = nacl.sign.detached(messageBytes, signingKey);
+                return [2 /*return*/, (0, module_kit_1.newSignature)(Buffer.from(signature).toString('hex'), 'hex')];
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.decryptAsymmetricWithKeyPair = function (payload, keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('Not implemented');
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.encryptAESWithSecretKey = function (payload, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('Not implemented');
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.decryptAESWithSecretKey = function (payload, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('Not implemented');
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.getNetwork = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.network];
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.getTransactionsForAddress = function (address, limit, cursor) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        return __awaiter(this, void 0, void 0, function () {
+            var walletPubkey_2, mintPubkey_2, effectiveLimit, tokenAccounts, txs, myAtaAddresses, _i, _k, pubkey, queryOptions_1, allSignatures, _loop_2, this_1, _l, _m, tokenAccountPubkey, uniqueSignatures, limitedSignatures, _loop_3, this_2, _o, limitedSignatures_1, sigInfo, hasNext, lastSignature, newCursor, e_6;
+            var _this = this;
+            return __generator(this, function (_p) {
+                switch (_p.label) {
+                    case 0:
+                        _p.trys.push([0, 10, , 11]);
+                        walletPubkey_2 = new solanaWeb3.PublicKey(address);
+                        mintPubkey_2 = new solanaWeb3.PublicKey(this.options.contractAddress);
+                        effectiveLimit = limit || SolanaSPLTokenProtocolImpl.DEFAULT_TX_LIMIT;
+                        return [4 /*yield*/, this.withFallback(function (connection) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                                return [2 /*return*/, connection.getTokenAccountsByOwner(walletPubkey_2, { mint: mintPubkey_2 })];
+                            }); }); })];
+                    case 1:
+                        tokenAccounts = _p.sent();
+                        if (tokenAccounts.value.length === 0) {
+                            return [2 /*return*/, {
+                                    transactions: [],
+                                    cursor: { hasNext: false }
+                                }];
+                        }
+                        txs = [];
+                        myAtaAddresses = new Set();
+                        for (_i = 0, _k = tokenAccounts.value; _i < _k.length; _i++) {
+                            pubkey = _k[_i].pubkey;
+                            myAtaAddresses.add(pubkey.toBase58());
+                        }
+                        queryOptions_1 = {
+                            limit: effectiveLimit
+                        };
+                        // If cursor has lastSignature, use it for pagination
+                        if (cursor === null || cursor === void 0 ? void 0 : cursor.lastSignature) {
+                            queryOptions_1.before = cursor.lastSignature;
+                        }
+                        allSignatures = [];
+                        _loop_2 = function (tokenAccountPubkey) {
+                            var signatures, _q, signatures_1, sig;
+                            return __generator(this, function (_r) {
+                                switch (_r.label) {
+                                    case 0: return [4 /*yield*/, this_1.withFallback(function (connection) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                                            return [2 /*return*/, connection.getSignaturesForAddress(tokenAccountPubkey, queryOptions_1)];
+                                        }); }); })];
+                                    case 1:
+                                        signatures = _r.sent();
+                                        for (_q = 0, signatures_1 = signatures; _q < signatures_1.length; _q++) {
+                                            sig = signatures_1[_q];
+                                            if (sig.signature) {
+                                                allSignatures.push({
+                                                    signature: sig.signature,
+                                                    blockTime: sig.blockTime,
+                                                    confirmationStatus: sig.confirmationStatus
+                                                });
+                                            }
+                                        }
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        _l = 0, _m = tokenAccounts.value;
+                        _p.label = 2;
+                    case 2:
+                        if (!(_l < _m.length)) return [3 /*break*/, 5];
+                        tokenAccountPubkey = _m[_l].pubkey;
+                        return [5 /*yield**/, _loop_2(tokenAccountPubkey)];
+                    case 3:
+                        _p.sent();
+                        _p.label = 4;
+                    case 4:
+                        _l++;
+                        return [3 /*break*/, 2];
+                    case 5:
+                        uniqueSignatures = Array.from(new Map(allSignatures.map(function (s) { return [s.signature, s]; })).values());
+                        // Sort by blockTime descending (most recent first)
+                        uniqueSignatures.sort(function (a, b) { return (b.blockTime || 0) - (a.blockTime || 0); });
+                        limitedSignatures = uniqueSignatures.slice(0, effectiveLimit);
+                        _loop_3 = function (sigInfo) {
+                            var parsed, amount, fromWallet, toWallet, isInbound, instructions, _s, instructions_1, ix, parsedIx, info, sourceAta, destAta, authorityWallet, resolvedFrom, resolvedTo, blockTime, timestamp, e_7;
+                            return __generator(this, function (_t) {
+                                switch (_t.label) {
+                                    case 0:
+                                        _t.trys.push([0, 11, , 12]);
+                                        return [4 /*yield*/, this_2.withFallback(function (connection) { return __awaiter(_this, void 0, void 0, function () {
+                                                return __generator(this, function (_a) {
+                                                    return [2 /*return*/, connection.getParsedTransaction(sigInfo.signature, {
+                                                            commitment: 'confirmed',
+                                                            maxSupportedTransactionVersion: 0
+                                                        })];
+                                                });
+                                            }); })];
+                                    case 1:
+                                        parsed = _t.sent();
+                                        if (!parsed)
+                                            return [2 /*return*/, "continue"];
+                                        amount = (0, module_kit_1.newAmount)(0, 'blockchain');
+                                        fromWallet = address;
+                                        toWallet = address;
+                                        isInbound = false;
+                                        instructions = ((_b = (_a = parsed.transaction) === null || _a === void 0 ? void 0 : _a.message) === null || _b === void 0 ? void 0 : _b.instructions) || [];
+                                        _s = 0, instructions_1 = instructions;
+                                        _t.label = 2;
+                                    case 2:
+                                        if (!(_s < instructions_1.length)) return [3 /*break*/, 10];
+                                        ix = instructions_1[_s];
+                                        if (!('parsed' in ix && ix.parsed)) return [3 /*break*/, 9];
+                                        parsedIx = ix;
+                                        if (!(parsedIx.program === 'spl-token')) return [3 /*break*/, 9];
+                                        info = (_c = parsedIx.parsed) === null || _c === void 0 ? void 0 : _c.info;
+                                        if (!(((_d = parsedIx.parsed) === null || _d === void 0 ? void 0 : _d.type) === 'transfer' || ((_e = parsedIx.parsed) === null || _e === void 0 ? void 0 : _e.type) === 'transferChecked')) return [3 /*break*/, 9];
+                                        if (!((info === null || info === void 0 ? void 0 : info.mint) === this_2.options.contractAddress || !(info === null || info === void 0 ? void 0 : info.mint))) return [3 /*break*/, 9];
+                                        amount = (0, module_kit_1.newAmount)((info === null || info === void 0 ? void 0 : info.amount) || ((_f = info === null || info === void 0 ? void 0 : info.tokenAmount) === null || _f === void 0 ? void 0 : _f.amount) || '0', 'blockchain');
+                                        sourceAta = (info === null || info === void 0 ? void 0 : info.source) || '';
+                                        destAta = (info === null || info === void 0 ? void 0 : info.destination) || '';
+                                        authorityWallet = (info === null || info === void 0 ? void 0 : info.authority) || '';
+                                        // Determine if this is inbound or outbound based on ATA ownership
+                                        isInbound = myAtaAddresses.has(destAta) && !myAtaAddresses.has(sourceAta);
+                                        if (!isInbound) return [3 /*break*/, 6];
+                                        // Inbound: we received tokens
+                                        // from = sender's wallet (need to resolve from source ATA)
+                                        // to = our wallet address
+                                        toWallet = address;
+                                        if (!authorityWallet) return [3 /*break*/, 3];
+                                        fromWallet = authorityWallet;
+                                        return [3 /*break*/, 5];
+                                    case 3: return [4 /*yield*/, this_2.getWalletAddressFromAta(sourceAta).catch(function () { return null; })];
+                                    case 4:
+                                        resolvedFrom = _t.sent();
+                                        fromWallet = resolvedFrom || sourceAta;
+                                        _t.label = 5;
+                                    case 5: return [3 /*break*/, 8];
+                                    case 6:
+                                        // Outbound: we sent tokens
+                                        // from = our wallet address
+                                        // to = recipient's wallet (need to resolve from dest ATA)
+                                        fromWallet = authorityWallet || address;
+                                        return [4 /*yield*/, this_2.getWalletAddressFromAta(destAta).catch(function () { return null; })];
+                                    case 7:
+                                        resolvedTo = _t.sent();
+                                        toWallet = resolvedTo || destAta;
+                                        _t.label = 8;
+                                    case 8: return [3 /*break*/, 10];
+                                    case 9:
+                                        _s++;
+                                        return [3 /*break*/, 2];
+                                    case 10:
+                                        blockTime = (_g = sigInfo.blockTime) !== null && _g !== void 0 ? _g : parsed.blockTime;
+                                        timestamp = blockTime ? blockTime : Math.floor(Date.now() / 1000);
+                                        txs.push({
+                                            hash: sigInfo.signature,
+                                            timestamp: timestamp,
+                                            status: sigInfo.confirmationStatus || 'processed',
+                                            amount: amount,
+                                            fee: (0, module_kit_1.newAmount)((_j = (_h = parsed.meta) === null || _h === void 0 ? void 0 : _h.fee) !== null && _j !== void 0 ? _j : 0, 'Lamports'),
+                                            from: [fromWallet],
+                                            to: [toWallet],
+                                            isInbound: isInbound,
+                                            network: this_2.options.network
+                                        });
+                                        return [3 /*break*/, 12];
+                                    case 11:
+                                        e_7 = _t.sent();
+                                        console.warn('[solana-spl][getTransactionsForAddress] Failed to parse tx:', sigInfo.signature);
+                                        return [3 /*break*/, 12];
+                                    case 12: return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_2 = this;
+                        _o = 0, limitedSignatures_1 = limitedSignatures;
+                        _p.label = 6;
+                    case 6:
+                        if (!(_o < limitedSignatures_1.length)) return [3 /*break*/, 9];
+                        sigInfo = limitedSignatures_1[_o];
+                        return [5 /*yield**/, _loop_3(sigInfo)];
+                    case 7:
+                        _p.sent();
+                        _p.label = 8;
+                    case 8:
+                        _o++;
+                        return [3 /*break*/, 6];
+                    case 9:
+                        hasNext = limitedSignatures.length === effectiveLimit;
+                        lastSignature = limitedSignatures.length > 0 ? limitedSignatures[limitedSignatures.length - 1].signature : undefined;
+                        newCursor = {
+                            hasNext: hasNext,
+                            lastSignature: lastSignature
+                        };
+                        return [2 /*return*/, {
+                                transactions: txs,
+                                cursor: newCursor
+                            }];
+                    case 10:
+                        e_6 = _p.sent();
+                        console.error('[solana-spl][getTransactionsForAddress] Failed:', e_6);
+                        return [2 /*return*/, {
+                                transactions: [],
+                                cursor: { hasNext: false }
+                            }];
+                    case 11: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.getTransactionsForPublicKey = function (publicKey, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.getTransactionsForAddress(address, limit, cursor)];
+                }
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.getTransactionStatus = function (transactionIds) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var statuses, result, i, id, status_1;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.withFallback(function (connection) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, connection.getSignatureStatuses(transactionIds)];
+                                    case 1: return [2 /*return*/, (_a.sent()).value];
+                                }
+                            });
+                        }); })];
+                    case 1:
+                        statuses = _b.sent();
+                        result = {};
+                        for (i = 0; i < transactionIds.length; i++) {
+                            id = transactionIds[i];
+                            status_1 = statuses[i];
+                            result[id] = { status: (_a = status_1 === null || status_1 === void 0 ? void 0 : status_1.confirmationStatus) !== null && _a !== void 0 ? _a : 'unknown' };
+                        }
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.getTransactionMaxAmountWithPublicKey = function (publicKey, to, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var balance;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
+                    case 1:
+                        balance = _a.sent();
+                        return [2 /*return*/, balance.total];
+                }
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.getTransactionFeeWithPublicKey = function (publicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var baseFee, totalAtaCreationCost, mintPubkey, _loop_4, this_3, _i, details_1, detail, e_8, totalFee;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        baseFee = 5000 // lamports
+                        ;
+                        totalAtaCreationCost = 0;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 6, , 7]);
+                        mintPubkey = new solanaWeb3.PublicKey(this.options.contractAddress);
+                        _loop_4 = function (detail) {
+                            var toPubkey, destAta, destAtaInfo;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        toPubkey = new solanaWeb3.PublicKey(detail.to);
+                                        return [4 /*yield*/, solanaWeb3.PublicKey.findProgramAddress([
+                                                toPubkey.toBuffer(),
+                                                TOKEN_PROGRAM_ID.toBuffer(),
+                                                mintPubkey.toBuffer()
+                                            ], ASSOCIATED_TOKEN_PROGRAM_ID)
+                                            // Check if destination ATA exists
+                                        ];
+                                    case 1:
+                                        destAta = (_b.sent())[0];
+                                        return [4 /*yield*/, this_3.withFallback(function (connection) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                                                return [2 /*return*/, connection.getAccountInfo(destAta)];
+                                            }); }); }).catch(function () { return null; })];
+                                    case 2:
+                                        destAtaInfo = _b.sent();
+                                        if (!destAtaInfo) {
+                                            // ATA doesn't exist, need to pay rent exemption to create it
+                                            totalAtaCreationCost += TOKEN_ACCOUNT_RENT_EXEMPTION_LAMPORTS;
+                                        }
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_3 = this;
+                        _i = 0, details_1 = details;
+                        _a.label = 2;
+                    case 2:
+                        if (!(_i < details_1.length)) return [3 /*break*/, 5];
+                        detail = details_1[_i];
+                        return [5 /*yield**/, _loop_4(detail)];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        _i++;
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        e_8 = _a.sent();
+                        console.warn('[solana-spl][getTransactionFeeWithPublicKey] Failed to check ATA existence, assuming worst case');
+                        // Assume all destinations need ATA creation (worst case)
+                        totalAtaCreationCost = details.length * TOKEN_ACCOUNT_RENT_EXEMPTION_LAMPORTS;
+                        return [3 /*break*/, 7];
+                    case 7:
+                        totalFee = baseFee + totalAtaCreationCost;
+                        return [2 /*return*/, {
+                                low: (0, module_kit_1.newAmount)(totalFee, 'Lamports'),
+                                medium: (0, module_kit_1.newAmount)(totalFee, 'Lamports'),
+                                high: (0, module_kit_1.newAmount)(totalFee, 'Lamports')
+                            }];
+                }
+            });
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.prepareTransactionWithPublicKey = function (publicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fromAddress, fromPubkey, mintPubkey, transaction, _loop_5, this_4, _i, details_2, detail, blockhash, serialized;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        fromAddress = _a.sent();
+                        fromPubkey = new solanaWeb3.PublicKey(fromAddress);
+                        mintPubkey = new solanaWeb3.PublicKey(this.options.contractAddress);
+                        transaction = new solanaWeb3.Transaction();
+                        _loop_5 = function (detail) {
+                            var toPubkey, sourceAta, destAta, destAtaInfo, createAtaIx, amount, transferIx;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        toPubkey = new solanaWeb3.PublicKey(detail.to);
+                                        return [4 /*yield*/, this_4.getAssociatedTokenAddress(fromAddress)
+                                            // Get destination token account (ATA)
+                                        ];
+                                    case 1:
+                                        sourceAta = _b.sent();
+                                        return [4 /*yield*/, solanaWeb3.PublicKey.findProgramAddress([
+                                                toPubkey.toBuffer(),
+                                                TOKEN_PROGRAM_ID.toBuffer(),
+                                                mintPubkey.toBuffer()
+                                            ], ASSOCIATED_TOKEN_PROGRAM_ID)
+                                            // Check if destination ATA exists, if not create it
+                                        ];
+                                    case 2:
+                                        destAta = (_b.sent())[0];
+                                        return [4 /*yield*/, this_4.withFallback(function (connection) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                                                return [2 /*return*/, connection.getAccountInfo(destAta)];
+                                            }); }); })];
+                                    case 3:
+                                        destAtaInfo = _b.sent();
+                                        if (!destAtaInfo) {
+                                            createAtaIx = this_4.createAssociatedTokenAccountInstruction(fromPubkey, // payer
+                                            destAta, // ata
+                                            toPubkey, // owner
+                                            mintPubkey // mint
+                                            );
+                                            transaction.add(createAtaIx);
+                                        }
+                                        amount = new bignumber_1.BigNumber((0, module_kit_1.newAmount)(detail.amount).blockchain(this_4.units).value);
+                                        transferIx = this_4.createTransferInstruction(sourceAta, destAta, fromPubkey, BigInt(amount.toFixed(0)));
+                                        transaction.add(transferIx);
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_4 = this;
+                        _i = 0, details_2 = details;
+                        _a.label = 2;
+                    case 2:
+                        if (!(_i < details_2.length)) return [3 /*break*/, 5];
+                        detail = details_2[_i];
+                        return [5 /*yield**/, _loop_5(detail)];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        _i++;
+                        return [3 /*break*/, 2];
+                    case 5:
+                        transaction.feePayer = fromPubkey;
+                        return [4 /*yield*/, this.withFallback(function (connection) { return __awaiter(_this, void 0, void 0, function () {
+                                var result;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, connection.getLatestBlockhash()];
+                                        case 1:
+                                            result = _a.sent();
+                                            return [2 /*return*/, result.blockhash];
+                                    }
+                                });
+                            }); })];
+                    case 6:
+                        blockhash = _a.sent();
+                        transaction.recentBlockhash = blockhash;
+                        serialized = transaction.serialize({ requireAllSignatures: false }).toString('hex');
+                        return [2 /*return*/, {
+                                serialized: serialized,
+                                type: 'unsigned'
+                            }];
+                }
+            });
+        });
+    };
+    // Helper: Create Associated Token Account instruction
+    SolanaSPLTokenProtocolImpl.prototype.createAssociatedTokenAccountInstruction = function (payer, associatedToken, owner, mint) {
+        return new solanaWeb3.TransactionInstruction({
+            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: solanaWeb3.SystemProgram.programId, isSigner: false, isWritable: false },
+                { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+            ],
+            programId: ASSOCIATED_TOKEN_PROGRAM_ID,
+            data: Buffer.alloc(0)
+        });
+    };
+    // Helper: Create SPL Token transfer instruction
+    SolanaSPLTokenProtocolImpl.prototype.createTransferInstruction = function (source, destination, owner, amount) {
+        var data = Buffer.alloc(9);
+        data.writeUInt8(3, 0); // Transfer instruction
+        this.writeU64LE(data, amount, 1); // Browser-compatible u64 write
+        return new solanaWeb3.TransactionInstruction({
+            keys: [
+                { pubkey: source, isSigner: false, isWritable: true },
+                { pubkey: destination, isSigner: false, isWritable: true },
+                { pubkey: owner, isSigner: true, isWritable: false }
+            ],
+            programId: TOKEN_PROGRAM_ID,
+            data: data
+        });
+    };
+    SolanaSPLTokenProtocolImpl.prototype.broadcastTransaction = function (transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txBuffer, signature;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        txBuffer = Buffer.from(transaction.serialized, 'hex');
+                        return [4 /*yield*/, this.withFallback(function (connection) { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    return [2 /*return*/, connection.sendRawTransaction(txBuffer)];
+                                });
+                            }); })];
+                    case 1:
+                        signature = _a.sent();
+                        return [2 /*return*/, signature];
+                }
+            });
+        });
+    };
+    // Fallback RPC endpoints for reliability
+    SolanaSPLTokenProtocolImpl.FALLBACK_RPC_URLS = [
+        'https://solana.drpc.org'
+    ];
+    // Default number of transactions to fetch per page
+    SolanaSPLTokenProtocolImpl.DEFAULT_TX_LIMIT = 10;
+    return SolanaSPLTokenProtocolImpl;
+}());
+exports.SolanaSPLTokenProtocolImpl = SolanaSPLTokenProtocolImpl;
+// Factory function
+function createSolanaSPLTokenProtocol(options) {
+    return new SolanaSPLTokenProtocolImpl(options);
+}
+exports.createSolanaSPLTokenProtocol = createSolanaSPLTokenProtocol;
+//# sourceMappingURL=SolanaSPLTokenProtocol.js.map