@wallfree-dev/aptos 0.13.43-beta.11

package/v1/protocol/AptosProtocol.js

@@ -0,0 +1,912 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAptosProtocol = exports.AptosProtocol = exports.APTOS_UNITS_METADATA = void 0;
+var module_kit_1 = require("@wallfree-dev/module-kit");
+var nacl = __importStar(require("tweetnacl"));
+var bignumber_1 = require("@wallfree-dev/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber");
+var js_sha3_1 = require("js-sha3");
+exports.APTOS_UNITS_METADATA = {
+    APT: {
+        symbol: { value: 'APT', market: 'apt' },
+        decimals: 8
+    },
+    Octas: {
+        symbol: { value: 'Octas' },
+        decimals: 0
+    }
+};
+// Default gas settings for Aptos
+var DEFAULT_MAX_GAS_AMOUNT = 2000;
+var DEFAULT_GAS_UNIT_PRICE = 100;
+var AptosProtocol = /** @class */ (function () {
+    function AptosProtocol(options) {
+        this.options = options;
+    }
+    AptosProtocol.prototype.fetchJson = function (endpoint, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, response, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        url = "".concat(this.options.network.rpcUrl).concat(endpoint);
+                        return [4 /*yield*/, fetch(url, __assign(__assign({}, options), { headers: __assign({ 'Content-Type': 'application/json' }, options === null || options === void 0 ? void 0 : options.headers) }))];
+                    case 1:
+                        response = _d.sent();
+                        if (!!response.ok) return [3 /*break*/, 3];
+                        _a = Error.bind;
+                        _c = (_b = "HTTP ".concat(response.status, ": ")).concat;
+                        return [4 /*yield*/, response.text()];
+                    case 2: throw new (_a.apply(Error, [void 0, _c.apply(_b, [_d.sent()])]))();
+                    case 3: return [2 /*return*/, response.json()];
+                }
+            });
+        });
+    };
+    AptosProtocol.prototype.getMetadata = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        identifier: 'aptos',
+                        name: 'Aptos',
+                        units: exports.APTOS_UNITS_METADATA,
+                        mainUnit: 'APT',
+                        fee: {
+                            defaults: {
+                                low: (0, module_kit_1.newAmount)(0.0002, 'APT'),
+                                medium: (0, module_kit_1.newAmount)(0.0002, 'APT'),
+                                high: (0, module_kit_1.newAmount)(0.0004, 'APT')
+                            },
+                            units: exports.APTOS_UNITS_METADATA,
+                            mainUnit: 'APT'
+                        },
+                        account: {
+                            standardDerivationPath: "m/44'/637'/0'/0'/0'",
+                            address: {
+                                isCaseSensitive: false,
+                                placeholder: '0x...',
+                                regex: '^0x[a-fA-F0-9]{64}$'
+                            }
+                        },
+                        transaction: {
+                            arbitraryData: {
+                                inner: { name: 'data' }
+                            }
+                        }
+                    }];
+            });
+        });
+    };
+    AptosProtocol.prototype.getPublicKeyBuffer = function (publicKey) {
+        if (publicKey.format === 'hex') {
+            return Buffer.from(publicKey.value, 'hex');
+        }
+        else if (publicKey.format === 'encoded') {
+            return Buffer.from(publicKey.value, 'hex');
+        }
+        return Buffer.from(publicKey.value, 'hex');
+    };
+    AptosProtocol.prototype.getAddressFromPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pubKeyBytes, dataToHash, hash;
+            return __generator(this, function (_a) {
+                pubKeyBytes = this.getPublicKeyBuffer(publicKey);
+                dataToHash = Buffer.concat([pubKeyBytes, Buffer.from([0x00])]);
+                hash = (0, js_sha3_1.sha3_256)(dataToHash);
+                return [2 /*return*/, '0x' + hash];
+            });
+        });
+    };
+    AptosProtocol.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 }
+                                }]];
+                }
+            });
+        });
+    };
+    AptosProtocol.prototype.validateAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                try {
+                    // Check if it's a valid hex address (0x followed by 1-64 hex characters)
+                    return [2 /*return*/, /^0x[a-fA-F0-9]{1,64}$/.test(address)];
+                }
+                catch (_b) {
+                    return [2 /*return*/, false];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    AptosProtocol.prototype.getBalanceOfAddress = function (address) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function () {
+            var indexerUrl, query, response, result, balances, balance, e_1, resources, balance, e_2;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 4, , 5]);
+                        indexerUrl = 'https://indexer.mainnet.aptoslabs.com/v1/graphql';
+                        query = {
+                            query: "\n          query GetAccountCoins {\n            current_fungible_asset_balances(\n              where: {owner_address: {_eq: \"".concat(address, "\"}, asset_type: {_eq: \"0x1::aptos_coin::AptosCoin\"}}\n            ) {\n              amount\n            }\n          }\n        ")
+                        };
+                        return [4 /*yield*/, fetch(indexerUrl, {
+                                method: 'POST',
+                                headers: { 'Content-Type': 'application/json' },
+                                body: JSON.stringify(query)
+                            })];
+                    case 1:
+                        response = _d.sent();
+                        if (!response.ok) return [3 /*break*/, 3];
+                        return [4 /*yield*/, response.json()];
+                    case 2:
+                        result = _d.sent();
+                        balances = (_a = result === null || result === void 0 ? void 0 : result.data) === null || _a === void 0 ? void 0 : _a.current_fungible_asset_balances;
+                        if (balances && balances.length > 0) {
+                            balance = balances[0].amount || '0';
+                            return [2 /*return*/, {
+                                    total: (0, module_kit_1.newAmount)(balance, 'Octas')
+                                }];
+                        }
+                        _d.label = 3;
+                    case 3: return [3 /*break*/, 5];
+                    case 4:
+                        e_1 = _d.sent();
+                        return [3 /*break*/, 5];
+                    case 5:
+                        _d.trys.push([5, 7, , 8]);
+                        return [4 /*yield*/, this.fetchJson("/accounts/".concat(address, "/resource/0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>"))];
+                    case 6:
+                        resources = _d.sent();
+                        balance = ((_c = (_b = resources === null || resources === void 0 ? void 0 : resources.data) === null || _b === void 0 ? void 0 : _b.coin) === null || _c === void 0 ? void 0 : _c.value) || '0';
+                        return [2 /*return*/, {
+                                total: (0, module_kit_1.newAmount)(balance, 'Octas')
+                            }];
+                    case 7:
+                        e_2 = _d.sent();
+                        // Account might not exist yet or has no balance
+                        return [2 /*return*/, { total: (0, module_kit_1.newAmount)(0, 'Octas') }];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AptosProtocol.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)];
+                }
+            });
+        });
+    };
+    AptosProtocol.prototype.getDetailsFromTransaction = function (transaction, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txData, fromAddress, fee, toAddress, amount, args, fallbackTx;
+            return __generator(this, function (_a) {
+                try {
+                    txData = JSON.parse(transaction.serialized);
+                    fromAddress = txData.sender || '';
+                    fee = (0, module_kit_1.newAmount)((BigInt(txData.max_gas_amount || 0) * BigInt(txData.gas_unit_price || 0)).toString(), 'Octas');
+                    toAddress = '';
+                    amount = (0, module_kit_1.newAmount)(0, 'Octas');
+                    // Parse payload
+                    if (txData.payload) {
+                        args = txData.payload.arguments || [];
+                        if (args.length >= 2) {
+                            toAddress = args[0];
+                            amount = (0, module_kit_1.newAmount)(args[1], 'Octas');
+                        }
+                    }
+                    return [2 /*return*/, [
+                            {
+                                from: [fromAddress],
+                                to: toAddress ? [toAddress] : [],
+                                amount: amount,
+                                fee: fee,
+                                isInbound: false,
+                                network: this.options.network
+                            }
+                        ]];
+                }
+                catch (e) {
+                    console.error('[aptos][getDetailsFromTransaction] Failed to parse transaction:', e);
+                    fallbackTx = {
+                        from: [],
+                        to: [],
+                        amount: (0, module_kit_1.newAmount)(0, 'Octas'),
+                        fee: (0, module_kit_1.newAmount)(0, 'Octas'),
+                        isInbound: false,
+                        network: this.options.network
+                    };
+                    return [2 /*return*/, [fallbackTx]];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    AptosProtocol.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)];
+            });
+        });
+    };
+    AptosProtocol.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*/];
+            });
+        });
+    };
+    AptosProtocol.prototype.encryptAsymmetricWithPublicKey = function (payload, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('Not implemented');
+            });
+        });
+    };
+    AptosProtocol.prototype.getCryptoConfiguration = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, { algorithm: 'ed25519' }];
+            });
+        });
+    };
+    AptosProtocol.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'
+                        }
+                    }];
+            });
+        });
+    };
+    AptosProtocol.prototype.signTransactionWithSecretKey = function (transaction, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txData, keyHex, secretKeyBytes, signingKey, publicKeyBytes, keyPair, signatureBytes, _signingMessage, unsignedTxData, signedTxData;
+            return __generator(this, function (_a) {
+                txData = JSON.parse(transaction.serialized);
+                keyHex = secretKey.value;
+                secretKeyBytes = Buffer.from(keyHex, secretKey.format === 'hex' ? 'hex' : undefined);
+                if (secretKeyBytes.length === 64) {
+                    signingKey = secretKeyBytes;
+                    publicKeyBytes = secretKeyBytes.slice(32);
+                }
+                else if (secretKeyBytes.length === 32) {
+                    keyPair = nacl.sign.keyPair.fromSeed(secretKeyBytes);
+                    signingKey = keyPair.secretKey;
+                    publicKeyBytes = keyPair.publicKey;
+                }
+                else {
+                    throw new Error('Invalid secret key length');
+                }
+                signatureBytes = nacl.sign.detached(Buffer.from(txData.signing_message, 'hex'), signingKey);
+                _signingMessage = txData.signing_message, unsignedTxData = __rest(txData, ["signing_message"]);
+                signedTxData = __assign(__assign({}, unsignedTxData), { signature: {
+                        type: 'ed25519_signature',
+                        public_key: '0x' + Buffer.from(publicKeyBytes).toString('hex'),
+                        signature: '0x' + Buffer.from(signatureBytes).toString('hex')
+                    } });
+                return [2 /*return*/, {
+                        serialized: JSON.stringify(signedTxData),
+                        type: 'signed'
+                    }];
+            });
+        });
+    };
+    AptosProtocol.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')];
+            });
+        });
+    };
+    AptosProtocol.prototype.decryptAsymmetricWithKeyPair = function (payload, keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('Not implemented');
+            });
+        });
+    };
+    AptosProtocol.prototype.encryptAESWithSecretKey = function (payload, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('Not implemented');
+            });
+        });
+    };
+    AptosProtocol.prototype.decryptAESWithSecretKey = function (payload, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('Not implemented');
+            });
+        });
+    };
+    AptosProtocol.prototype.getNetwork = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.network];
+            });
+        });
+    };
+    AptosProtocol.prototype.getTransactionsForAddress = function (address, limit, cursor) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var effectiveLimit, offset, indexerUrl, versionsQuery, versionsResponse, versionsResult, versionActivities, versions, graphqlQuery, response, result, activities, txMap, _i, activities_1, activity, version, txs_1, hasNext, newCursor, e_3;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _c.trys.push([0, 5, , 6]);
+                        effectiveLimit = limit || AptosProtocol.DEFAULT_TX_LIMIT;
+                        offset = (cursor === null || cursor === void 0 ? void 0 : cursor.offset) || 0;
+                        indexerUrl = 'https://indexer.mainnet.aptoslabs.com/v1/graphql';
+                        versionsQuery = "{\n        fungible_asset_activities(\n          where: {\n            owner_address: { _eq: \"".concat(address, "\" },\n            asset_type: { _in: [\"0xa\", \"0x000000000000000000000000000000000000000000000000000000000000000a\", \"0x1::aptos_coin::AptosCoin\"] }\n          },\n          order_by: { transaction_version: desc },\n          limit: ").concat(effectiveLimit, ",\n          offset: ").concat(offset, "\n        ) {\n          transaction_version\n        }\n      }");
+                        return [4 /*yield*/, fetch(indexerUrl, {
+                                method: 'POST',
+                                headers: { 'Content-Type': 'application/json' },
+                                body: JSON.stringify({ query: versionsQuery })
+                            })];
+                    case 1:
+                        versionsResponse = _c.sent();
+                        if (!versionsResponse.ok) {
+                            throw new Error("Indexer API failed: ".concat(versionsResponse.status));
+                        }
+                        return [4 /*yield*/, versionsResponse.json()];
+                    case 2:
+                        versionsResult = _c.sent();
+                        versionActivities = ((_a = versionsResult === null || versionsResult === void 0 ? void 0 : versionsResult.data) === null || _a === void 0 ? void 0 : _a.fungible_asset_activities) || [];
+                        versions = Array.from(new Set(versionActivities.map(function (a) { return a.transaction_version; })));
+                        if (versions.length === 0) {
+                            return [2 /*return*/, { transactions: [], cursor: { hasNext: false } }];
+                        }
+                        graphqlQuery = "{\n        fungible_asset_activities(\n          where: {\n            transaction_version: { _in: [".concat(versions.join(','), "] },\n            asset_type: { _in: [\"0xa\", \"0x000000000000000000000000000000000000000000000000000000000000000a\", \"0x1::aptos_coin::AptosCoin\"] }\n          },\n          order_by: { transaction_version: desc }\n        ) {\n          transaction_version\n          type\n          amount\n          owner_address\n          transaction_timestamp\n          is_transaction_success\n        }\n      }");
+                        return [4 /*yield*/, fetch(indexerUrl, {
+                                method: 'POST',
+                                headers: { 'Content-Type': 'application/json' },
+                                body: JSON.stringify({ query: graphqlQuery })
+                            })];
+                    case 3:
+                        response = _c.sent();
+                        if (!response.ok) {
+                            throw new Error("Indexer API failed: ".concat(response.status));
+                        }
+                        return [4 /*yield*/, response.json()];
+                    case 4:
+                        result = _c.sent();
+                        activities = ((_b = result === null || result === void 0 ? void 0 : result.data) === null || _b === void 0 ? void 0 : _b.fungible_asset_activities) || [];
+                        txMap = new Map();
+                        for (_i = 0, activities_1 = activities; _i < activities_1.length; _i++) {
+                            activity = activities_1[_i];
+                            version = activity.transaction_version.toString();
+                            if (!txMap.has(version)) {
+                                txMap.set(version, {
+                                    version: version,
+                                    timestamp: activity.transaction_timestamp,
+                                    success: activity.is_transaction_success,
+                                    activities: []
+                                });
+                            }
+                            txMap.get(version).activities.push(activity);
+                        }
+                        txs_1 = [];
+                        txMap.forEach(function (txData, version) {
+                            try {
+                                var acts = txData.activities;
+                                var amount = (0, module_kit_1.newAmount)(0, 'Octas');
+                                var isInbound = false;
+                                var fee = (0, module_kit_1.newAmount)(0, 'Octas');
+                                // Collect all withdraw addresses (senders) and deposit addresses (recipients)
+                                var withdrawAddresses = [];
+                                var depositAddresses = [];
+                                var gasFeePayerAddress = '';
+                                for (var _i = 0, acts_1 = acts; _i < acts_1.length; _i++) {
+                                    var act = acts_1[_i];
+                                    var actType = (act.type || '').toLowerCase();
+                                    var ownerAddr = act.owner_address || '';
+                                    if (actType.includes('gasfee')) {
+                                        fee = (0, module_kit_1.newAmount)(act.amount || '0', 'Octas');
+                                        gasFeePayerAddress = ownerAddr;
+                                    }
+                                    else if (actType.includes('deposit')) {
+                                        // Deposit recipient
+                                        if (ownerAddr && !depositAddresses.includes(ownerAddr)) {
+                                            depositAddresses.push(ownerAddr);
+                                        }
+                                        if (ownerAddr.toLowerCase() === address.toLowerCase()) {
+                                            amount = (0, module_kit_1.newAmount)(act.amount || '0', 'Octas');
+                                            isInbound = true;
+                                        }
+                                    }
+                                    else if (actType.includes('withdraw')) {
+                                        // Withdraw sender
+                                        if (ownerAddr && !withdrawAddresses.includes(ownerAddr)) {
+                                            withdrawAddresses.push(ownerAddr);
+                                        }
+                                        if (ownerAddr.toLowerCase() === address.toLowerCase()) {
+                                            amount = (0, module_kit_1.newAmount)(act.amount || '0', 'Octas');
+                                            isInbound = false;
+                                        }
+                                    }
+                                }
+                                // Determine from and to addresses based on transaction direction
+                                var fromAddresses = [];
+                                var toAddresses = [];
+                                if (isInbound) {
+                                    // Inbound: from = senders (not current user), to = current user
+                                    fromAddresses = withdrawAddresses.filter(function (addr) { return addr.toLowerCase() !== address.toLowerCase(); });
+                                    toAddresses = depositAddresses.filter(function (addr) { return addr.toLowerCase() === address.toLowerCase(); });
+                                    // If no external sender found, use gas fee payer as sender
+                                    if (fromAddresses.length === 0 && gasFeePayerAddress && gasFeePayerAddress.toLowerCase() !== address.toLowerCase()) {
+                                        fromAddresses = [gasFeePayerAddress];
+                                    }
+                                }
+                                else {
+                                    // Outbound: from = current user, to = recipients (not current user)
+                                    fromAddresses = withdrawAddresses.filter(function (addr) { return addr.toLowerCase() === address.toLowerCase(); });
+                                    toAddresses = depositAddresses.filter(function (addr) { return addr.toLowerCase() !== address.toLowerCase(); });
+                                    // If no external sender found for from, use current user if they paid gas
+                                    if (fromAddresses.length === 0 && gasFeePayerAddress && gasFeePayerAddress.toLowerCase() === address.toLowerCase()) {
+                                        fromAddresses = [gasFeePayerAddress];
+                                    }
+                                }
+                                // Fallback: if from is empty, use withdraw addresses; if to is empty, use deposit addresses
+                                if (fromAddresses.length === 0 && withdrawAddresses.length > 0) {
+                                    fromAddresses = withdrawAddresses;
+                                }
+                                if (toAddresses.length === 0 && depositAddresses.length > 0) {
+                                    toAddresses = depositAddresses;
+                                }
+                                // If we couldn't determine amount from our address activities, use any available amount
+                                if (amount.value === '0') {
+                                    for (var _a = 0, acts_2 = acts; _a < acts_2.length; _a++) {
+                                        var act = acts_2[_a];
+                                        var actType = (act.type || '').toLowerCase();
+                                        if (!actType.includes('gasfee') && act.amount) {
+                                            amount = (0, module_kit_1.newAmount)(act.amount, 'Octas');
+                                            break;
+                                        }
+                                    }
+                                }
+                                var timestamp = txData.timestamp
+                                    ? Math.floor(new Date(txData.timestamp).getTime() / 1000)
+                                    : Math.floor(Date.now() / 1000);
+                                txs_1.push({
+                                    hash: version,
+                                    timestamp: timestamp,
+                                    status: txData.success ? 'applied' : 'failed',
+                                    amount: amount,
+                                    fee: fee,
+                                    from: fromAddresses,
+                                    to: toAddresses,
+                                    isInbound: isInbound,
+                                    network: _this.options.network
+                                });
+                            }
+                            catch (e) {
+                                console.warn('[aptos][getTransactionsForAddress] Failed to parse activity');
+                            }
+                        });
+                        // Sort by version descending
+                        txs_1.sort(function (a, b) { return parseInt(b.hash) - parseInt(a.hash); });
+                        hasNext = versionActivities.length === effectiveLimit;
+                        newCursor = {
+                            hasNext: hasNext,
+                            offset: offset + versionActivities.length
+                        };
+                        return [2 /*return*/, {
+                                transactions: txs_1,
+                                cursor: newCursor
+                            }];
+                    case 5:
+                        e_3 = _c.sent();
+                        console.error('[aptos][getTransactionsForAddress] Failed:', e_3);
+                        return [2 /*return*/, {
+                                transactions: [],
+                                cursor: { hasNext: false }
+                            }];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AptosProtocol.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)];
+                }
+            });
+        });
+    };
+    AptosProtocol.prototype.getTransactionStatus = function (transactionIds) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result, _i, transactionIds_1, txHash, tx, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        result = {};
+                        _i = 0, transactionIds_1 = transactionIds;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < transactionIds_1.length)) return [3 /*break*/, 6];
+                        txHash = transactionIds_1[_i];
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.fetchJson("/transactions/by_hash/".concat(txHash))];
+                    case 3:
+                        tx = _b.sent();
+                        result[txHash] = { status: tx.success ? 'applied' : 'failed' };
+                        return [3 /*break*/, 5];
+                    case 4:
+                        _a = _b.sent();
+                        result[txHash] = { status: 'unknown' };
+                        return [3 /*break*/, 5];
+                    case 5:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 6: return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    AptosProtocol.prototype.getTransactionMaxAmountWithPublicKey = function (publicKey, to, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var balance, fee, feeOctas, maxAmount, maxString;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
+                    case 1:
+                        balance = _a.sent();
+                        return [4 /*yield*/, this.getTransactionFeeWithPublicKey(publicKey, [{ to: to === null || to === void 0 ? void 0 : to[0], amount: (0, module_kit_1.newAmount)(0, 'Octas') }])];
+                    case 2:
+                        fee = _a.sent();
+                        feeOctas = fee && fee.medium && fee.medium.value !== undefined ? new bignumber_1.BigNumber(fee.medium.value) : new bignumber_1.BigNumber(20000);
+                        maxAmount = new bignumber_1.BigNumber(balance.total.value).minus(feeOctas);
+                        maxString = maxAmount.gt(0) ? maxAmount.toFixed(0) : '0';
+                        return [2 /*return*/, (0, module_kit_1.newAmount)(maxString, 'Octas')];
+                }
+            });
+        });
+    };
+    AptosProtocol.prototype.getTransactionFeeWithPublicKey = function (publicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var gasEstimate, gasPrice, estimatedGas, fee, _a, defaultFee;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.fetchJson('/estimate_gas_price')];
+                    case 1:
+                        gasEstimate = _b.sent();
+                        gasPrice = parseInt(gasEstimate.gas_estimate || '100');
+                        estimatedGas = DEFAULT_MAX_GAS_AMOUNT;
+                        fee = (estimatedGas * gasPrice).toString();
+                        return [2 /*return*/, {
+                                low: (0, module_kit_1.newAmount)(fee, 'Octas'),
+                                medium: (0, module_kit_1.newAmount)(fee, 'Octas'),
+                                high: (0, module_kit_1.newAmount)((estimatedGas * gasPrice * 2).toString(), 'Octas')
+                            }];
+                    case 2:
+                        _a = _b.sent();
+                        defaultFee = (DEFAULT_MAX_GAS_AMOUNT * DEFAULT_GAS_UNIT_PRICE).toString();
+                        return [2 /*return*/, {
+                                low: (0, module_kit_1.newAmount)(defaultFee, 'Octas'),
+                                medium: (0, module_kit_1.newAmount)(defaultFee, 'Octas'),
+                                high: (0, module_kit_1.newAmount)((DEFAULT_MAX_GAS_AMOUNT * DEFAULT_GAS_UNIT_PRICE * 2).toString(), 'Octas')
+                            }];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AptosProtocol.prototype.prepareTransactionWithPublicKey = function (publicKey, details, configuration) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var fromAddress, sequenceNumber, accountInfo, e_4, gasUnitPrice, gasEstimate, _c, ledgerInfo, currentTimestamp, expirationTimestamp, detail, amountOctas, txPayload, encodingRequest, encodingText, signingMessage;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)
+                        // Get account info for sequence number
+                    ];
+                    case 1:
+                        fromAddress = _d.sent();
+                        sequenceNumber = '0';
+                        _d.label = 2;
+                    case 2:
+                        _d.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.fetchJson("/accounts/".concat(fromAddress))];
+                    case 3:
+                        accountInfo = _d.sent();
+                        sequenceNumber = accountInfo.sequence_number || '0';
+                        return [3 /*break*/, 5];
+                    case 4:
+                        e_4 = _d.sent();
+                        // Account might not exist yet, use 0
+                        if (!((_a = e_4 === null || e_4 === void 0 ? void 0 : e_4.message) === null || _a === void 0 ? void 0 : _a.includes('404')) && !((_b = e_4 === null || e_4 === void 0 ? void 0 : e_4.message) === null || _b === void 0 ? void 0 : _b.includes('not found'))) {
+                            throw e_4;
+                        }
+                        return [3 /*break*/, 5];
+                    case 5:
+                        gasUnitPrice = DEFAULT_GAS_UNIT_PRICE;
+                        _d.label = 6;
+                    case 6:
+                        _d.trys.push([6, 8, , 9]);
+                        return [4 /*yield*/, this.fetchJson('/estimate_gas_price')];
+                    case 7:
+                        gasEstimate = _d.sent();
+                        gasUnitPrice = parseInt(gasEstimate.gas_estimate || '100');
+                        return [3 /*break*/, 9];
+                    case 8:
+                        _c = _d.sent();
+                        return [3 /*break*/, 9];
+                    case 9: return [4 /*yield*/, this.fetchJson('/')];
+                    case 10:
+                        ledgerInfo = _d.sent();
+                        currentTimestamp = parseInt(ledgerInfo.ledger_timestamp || '0') / 1000000;
+                        expirationTimestamp = Math.floor(currentTimestamp) + 600 // 10 minutes expiry
+                        ;
+                        detail = details[0];
+                        amountOctas = (0, module_kit_1.newAmount)(detail.amount).blockchain(exports.APTOS_UNITS_METADATA).value;
+                        txPayload = {
+                            sender: fromAddress,
+                            sequence_number: sequenceNumber,
+                            max_gas_amount: DEFAULT_MAX_GAS_AMOUNT.toString(),
+                            gas_unit_price: gasUnitPrice.toString(),
+                            expiration_timestamp_secs: expirationTimestamp.toString(),
+                            payload: {
+                                type: 'entry_function_payload',
+                                function: '0x1::aptos_account::transfer',
+                                type_arguments: [],
+                                arguments: [detail.to, amountOctas]
+                            }
+                        };
+                        return [4 /*yield*/, fetch("".concat(this.options.network.rpcUrl, "/transactions/encode_submission"), {
+                                method: 'POST',
+                                headers: { 'Content-Type': 'application/json' },
+                                body: JSON.stringify(txPayload)
+                            })];
+                    case 11:
+                        encodingRequest = _d.sent();
+                        return [4 /*yield*/, encodingRequest.text()];
+                    case 12:
+                        encodingText = _d.sent();
+                        if (!encodingRequest.ok) {
+                            throw new Error("Encode submission failed: ".concat(encodingRequest.status, ": ").concat(encodingText));
+                        }
+                        signingMessage = encodingText;
+                        try {
+                            signingMessage = JSON.parse(encodingText);
+                        }
+                        catch (_e) {
+                            // ignore
+                        }
+                        if (typeof signingMessage !== 'string') {
+                            throw new Error("Encode submission failed: unexpected response: ".concat(encodingText));
+                        }
+                        // signingMessage is hex string of the message to sign
+                        return [2 /*return*/, {
+                                serialized: JSON.stringify(__assign(__assign({}, txPayload), { signing_message: signingMessage.replace(/^0x/, '') })),
+                                type: 'unsigned'
+                            }];
+                }
+            });
+        });
+    };
+    AptosProtocol.prototype.broadcastTransaction = function (transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var signedTxData, _signingMessage, txToSubmit, response, _a, _b, result, i, txStatus, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        signedTxData = JSON.parse(transaction.serialized);
+                        _signingMessage = signedTxData.signing_message, txToSubmit = __rest(signedTxData
+                        // Submit to Aptos REST API
+                        , ["signing_message"]);
+                        return [4 /*yield*/, fetch("".concat(this.options.network.rpcUrl, "/transactions"), {
+                                method: 'POST',
+                                headers: { 'Content-Type': 'application/json' },
+                                body: JSON.stringify(txToSubmit)
+                            })];
+                    case 1:
+                        response = _d.sent();
+                        if (!!response.ok) return [3 /*break*/, 3];
+                        _a = Error.bind;
+                        _b = "Broadcast failed: ".concat;
+                        return [4 /*yield*/, response.text()];
+                    case 2: throw new (_a.apply(Error, [void 0, _b.apply("Broadcast failed: ", [_d.sent()])]))();
+                    case 3: return [4 /*yield*/, response.json()
+                        // Wait for transaction to be confirmed
+                    ];
+                    case 4:
+                        result = _d.sent();
+                        i = 0;
+                        _d.label = 5;
+                    case 5:
+                        if (!(i < 30)) return [3 /*break*/, 12];
+                        _d.label = 6;
+                    case 6:
+                        _d.trys.push([6, 8, , 9]);
+                        return [4 /*yield*/, this.fetchJson("/transactions/by_hash/".concat(result.hash))];
+                    case 7:
+                        txStatus = _d.sent();
+                        if (txStatus.type === 'user_transaction') {
+                            return [3 /*break*/, 12];
+                        }
+                        return [3 /*break*/, 9];
+                    case 8:
+                        _c = _d.sent();
+                        return [3 /*break*/, 9];
+                    case 9: return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1000); })];
+                    case 10:
+                        _d.sent();
+                        _d.label = 11;
+                    case 11:
+                        i++;
+                        return [3 /*break*/, 5];
+                    case 12: return [2 /*return*/, result.hash];
+                }
+            });
+        });
+    };
+    AptosProtocol.prototype.getTokenBalancesOfPublicKey = function (publicKey, tokens) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {}];
+            });
+        });
+    };
+    AptosProtocol.DEFAULT_TX_LIMIT = 10;
+    return AptosProtocol;
+}());
+exports.AptosProtocol = AptosProtocol;
+function createAptosProtocol(options) {
+    if (options === void 0) { options = {}; }
+    var defaultNetwork = {
+        name: 'Aptos Mainnet',
+        type: 'mainnet',
+        rpcUrl: 'https://fullnode.mainnet.aptoslabs.com/v1',
+        blockExplorerUrl: 'https://explorer.aptoslabs.com',
+        chainId: 1,
+        blockExplorerApi: ''
+    };
+    return new AptosProtocol({
+        network: __assign(__assign({}, defaultNetwork), options.network)
+    });
+}
+exports.createAptosProtocol = createAptosProtocol;
+//# sourceMappingURL=AptosProtocol.js.map