@wallfree-dev/aptos 0.13.43-beta.11

package/.npm-cache/_logs/2026-01-11T13_30_26_409Z-debug-0.log

@@ -0,0 +1,14 @@
+0 verbose cli /opt/hostedtoolcache/node/18.20.8/x64/bin/node /opt/hostedtoolcache/node/18.20.8/x64/bin/npm
+1 info using npm@10.8.2
+2 info using node@v18.20.8
+3 silly config load:file:/opt/hostedtoolcache/node/18.20.8/x64/lib/node_modules/npm/npmrc
+4 silly config load:file:/home/runner/work/airgap-coin-lib/airgap-coin-lib/packages/aptos/dist/.npmrc
+5 silly config load:file:/home/runner/work/airgap-coin-lib/airgap-coin-lib/.npmrc.publish
+6 silly config load:file:/opt/hostedtoolcache/node/18.20.8/x64/etc/npmrc
+7 verbose title npm publish
+8 verbose argv "publish" "--cache" ".npm-cache" "--tag" "next" "--access" "public"
+9 verbose logfile logs-max:10 dir:/home/runner/work/airgap-coin-lib/airgap-coin-lib/packages/aptos/dist/.npm-cache/_logs/2026-01-11T13_30_26_409Z-
+10 verbose logfile /home/runner/work/airgap-coin-lib/airgap-coin-lib/packages/aptos/dist/.npm-cache/_logs/2026-01-11T13_30_26_409Z-debug-0.log
+11 verbose publish [ '.' ]
+12 silly logfile done cleaning log files
+13 silly packumentCache heap:2197815296 maxSize:549453824 maxEntrySize:274726912

package/README.md

@@ -0,0 +1,32 @@
+# @airgap/aptos
+
+This package provides Aptos blockchain support for the AirGap wallet ecosystem.
+
+## Features
+
+- APT (Aptos) native coin support
+- Transaction signing and broadcasting
+- Balance and transaction history queries
+- Block explorer integration
+
+## Installation
+
+```bash
+npm install @airgap/aptos
+```
+
+## Usage
+
+```typescript
+import { AptosModule } from '@airgap/aptos'
+
+const aptosModule = new AptosModule()
+```
+
+## Supported Networks
+
+- Aptos Mainnet
+
+## License
+
+MIT

package/index.d.ts

@@ -0,0 +1,6 @@
+import { AptosModule } from './v1/module/AptosModule';
+import { AptosProtocol, createAptosProtocol } from './v1/protocol/AptosProtocol';
+import { AptosCoinTokenProtocol, AptosCoinTokenProtocolImpl, createAptosCoinTokenProtocol } from './v1/protocol/AptosCoinTokenProtocol';
+import { APTOS_COIN_TOKENS, APTOS_COIN_TOKEN_USDT, APTOS_COIN_TOKEN_USDC, createCoinTokenOptionsFromMetadata } from './v1/module/AptosCoinTokens';
+export { AptosModule, AptosProtocol, createAptosProtocol, AptosCoinTokenProtocol, AptosCoinTokenProtocolImpl, createAptosCoinTokenProtocol, APTOS_COIN_TOKENS, APTOS_COIN_TOKEN_USDT, APTOS_COIN_TOKEN_USDC, createCoinTokenOptionsFromMetadata };
+export * from './v1/types/protocol';

package/index.js

@@ -0,0 +1,32 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCoinTokenOptionsFromMetadata = exports.APTOS_COIN_TOKEN_USDC = exports.APTOS_COIN_TOKEN_USDT = exports.APTOS_COIN_TOKENS = exports.createAptosCoinTokenProtocol = exports.AptosCoinTokenProtocolImpl = exports.createAptosProtocol = exports.AptosProtocol = exports.AptosModule = void 0;
+var AptosModule_1 = require("./v1/module/AptosModule");
+Object.defineProperty(exports, "AptosModule", { enumerable: true, get: function () { return AptosModule_1.AptosModule; } });
+var AptosProtocol_1 = require("./v1/protocol/AptosProtocol");
+Object.defineProperty(exports, "AptosProtocol", { enumerable: true, get: function () { return AptosProtocol_1.AptosProtocol; } });
+Object.defineProperty(exports, "createAptosProtocol", { enumerable: true, get: function () { return AptosProtocol_1.createAptosProtocol; } });
+var AptosCoinTokenProtocol_1 = require("./v1/protocol/AptosCoinTokenProtocol");
+Object.defineProperty(exports, "AptosCoinTokenProtocolImpl", { enumerable: true, get: function () { return AptosCoinTokenProtocol_1.AptosCoinTokenProtocolImpl; } });
+Object.defineProperty(exports, "createAptosCoinTokenProtocol", { enumerable: true, get: function () { return AptosCoinTokenProtocol_1.createAptosCoinTokenProtocol; } });
+var AptosCoinTokens_1 = require("./v1/module/AptosCoinTokens");
+Object.defineProperty(exports, "APTOS_COIN_TOKENS", { enumerable: true, get: function () { return AptosCoinTokens_1.APTOS_COIN_TOKENS; } });
+Object.defineProperty(exports, "APTOS_COIN_TOKEN_USDT", { enumerable: true, get: function () { return AptosCoinTokens_1.APTOS_COIN_TOKEN_USDT; } });
+Object.defineProperty(exports, "APTOS_COIN_TOKEN_USDC", { enumerable: true, get: function () { return AptosCoinTokens_1.APTOS_COIN_TOKEN_USDC; } });
+Object.defineProperty(exports, "createCoinTokenOptionsFromMetadata", { enumerable: true, get: function () { return AptosCoinTokens_1.createCoinTokenOptionsFromMetadata; } });
+__exportStar(require("./v1/types/protocol"), exports);
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,uDAAqD;AAWnD,4FAXO,yBAAW,OAWP;AAVb,6DAAgF;AAW9E,8FAXO,6BAAa,OAWP;AACb,oGAZsB,mCAAmB,OAYtB;AAXrB,+EAAuI;AAarI,2GAb+B,mDAA0B,OAa/B;AAC1B,6GAd2D,qDAA4B,OAc3D;AAb9B,+DAKoC;AASlC,kGAbA,mCAAiB,OAaA;AACjB,sGAbA,uCAAqB,OAaA;AACrB,sGAbA,uCAAqB,OAaA;AACrB,mHAbA,oDAAkC,OAaA;AAGpC,sDAAmC"}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@wallfree-dev/aptos",
+  "version": "0.13.43-beta.11",
+  "description": "The @wallfree-dev/aptos is an Aptos implementation of the ICoinProtocol interface from @wallfree-dev/coinlib-core.",
+  "keywords": [
+    "airgap",
+    "blockchain",
+    "crypto",
+    "aptos"
+  ],
+  "homepage": "https://www.airgap.it",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/airgap-it/airgap-coin-lib.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rimraf ./dist && tsc && node scripts/copy-files-after-build.js",
+    "build-scripts": "tsc scripts/copy-files-after-build.ts",
+    "lint": "tslint -c ./tslint.json --project ./tsconfig.json --format stylish --fix",
+    "lint:prettier": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "lint-ci": "tslint -t json -o ../../lint-reports/aptos.json --project . || true",
+    "lint-ci:prettier": "prettier \"src/**/*.ts\" \"test/**/*.ts\" --list-different",
+    "test": "",
+    "test-ci": "nyc --reporter=lcov npm test",
+    "browserify": "browserify ./dist/index.js -s airgapCoinLibAptos > ./dist/airgap-coinlib-aptos.min.js"
+  },
+  "author": "Papers AG <contact@papers.ch> (https://papers.ch)",
+  "dependencies": {
+    "@wallfree-dev/coinlib-core": "^0.13.43-beta.11",
+    "@wallfree-dev/module-kit": "^0.13.43-beta.11",
+    "@wallfree-dev/serializer": "^0.13.43-beta.11",
+    "js-sha3": "^0.9.3",
+    "tweetnacl": "^1.0.3"
+  },
+  "nyc": {
+    "include": [
+      "src/**/*.ts"
+    ],
+    "exclude": [
+      "test/**/*.spec.ts"
+    ],
+    "extension": [
+      ".ts"
+    ],
+    "require": [
+      "ts-node/register"
+    ],
+    "reporter": [
+      "text",
+      "text-summary"
+    ],
+    "report-dir": "../../coverage/aptos",
+    "sourceMap": true,
+    "instrument": true
+  },
+  "devDependencies": {
+    "rimraf": "^6.0.1"
+  }
+}

package/v1/block-explorer/AptosBlockExplorer.d.ts

@@ -0,0 +1,9 @@
+import { AirGapBlockExplorer, BlockExplorerMetadata } from '@wallfree-dev/module-kit';
+export declare class AptosBlockExplorer implements AirGapBlockExplorer {
+    private readonly url;
+    private readonly metadata;
+    constructor(url: string);
+    getMetadata(): Promise<BlockExplorerMetadata>;
+    createAddressUrl(address: string): Promise<string>;
+    createTransactionUrl(transactionId: string): Promise<string>;
+}

package/v1/block-explorer/AptosBlockExplorer.js

@@ -0,0 +1,72 @@
+"use strict";
+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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AptosBlockExplorer = void 0;
+var AptosBlockExplorer = /** @class */ (function () {
+    function AptosBlockExplorer(url) {
+        this.url = url;
+        this.metadata = {
+            name: 'Aptos Explorer',
+            url: this.url
+        };
+    }
+    AptosBlockExplorer.prototype.getMetadata = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.metadata];
+            });
+        });
+    };
+    AptosBlockExplorer.prototype.createAddressUrl = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, "".concat(this.url, "/account/").concat(address)];
+            });
+        });
+    };
+    AptosBlockExplorer.prototype.createTransactionUrl = function (transactionId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, "".concat(this.url, "/txn/").concat(transactionId)];
+            });
+        });
+    };
+    return AptosBlockExplorer;
+}());
+exports.AptosBlockExplorer = AptosBlockExplorer;
+//# sourceMappingURL=AptosBlockExplorer.js.map

package/v1/block-explorer/AptosBlockExplorer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AptosBlockExplorer.js","sourceRoot":"","sources":["../../../src/v1/block-explorer/AptosBlockExplorer.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA;IAME,4BAAoC,GAAW;QAAX,QAAG,GAAH,GAAG,CAAQ;QAL9B,aAAQ,GAA0B;YACjD,IAAI,EAAE,gBAAgB;YACtB,GAAG,EAAE,IAAI,CAAC,GAAG;SACd,CAAA;IAEiD,CAAC;IAEtC,wCAAW,GAAxB;;;gBACE,sBAAO,IAAI,CAAC,QAAQ,EAAA;;;KACrB;IAEY,6CAAgB,GAA7B,UAA8B,OAAe;;;gBAC3C,sBAAO,UAAG,IAAI,CAAC,GAAG,sBAAY,OAAO,CAAE,EAAA;;;KACxC;IAEY,iDAAoB,GAAjC,UAAkC,aAAqB;;;gBACrD,sBAAO,UAAG,IAAI,CAAC,GAAG,kBAAQ,aAAa,CAAE,EAAA;;;KAC1C;IACH,yBAAC;AAAD,CAAC,AAnBD,IAmBC;AAnBY,gDAAkB"}

package/v1/module/AptosCoinTokens.d.ts

@@ -0,0 +1,5 @@
+import { AptosCoinTokenMetadata, AptosCoinTokenOptions, AptosProtocolNetwork } from '../types/protocol';
+export declare const APTOS_COIN_TOKEN_USDT: AptosCoinTokenMetadata;
+export declare const APTOS_COIN_TOKEN_USDC: AptosCoinTokenMetadata;
+export declare const APTOS_COIN_TOKENS: AptosCoinTokenMetadata[];
+export declare function createCoinTokenOptionsFromMetadata(metadata: AptosCoinTokenMetadata, network: AptosProtocolNetwork): AptosCoinTokenOptions<string>;

package/v1/module/AptosCoinTokens.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCoinTokenOptionsFromMetadata = exports.APTOS_COIN_TOKENS = exports.APTOS_COIN_TOKEN_USDC = exports.APTOS_COIN_TOKEN_USDT = void 0;
+var coinlib_core_1 = require("@wallfree-dev/coinlib-core");
+// Aptos Mainnet token metadata addresses (Fungible Asset format)
+// USDT: 0x357b0b74bc833e95a115ad22604854d6b0fca151cecd94111770e5d6ffc9dc2b
+// USDC: 0xbae207659db88bea0cbead6da0ed00aac12edcdda169e591cd41c94180b46f3b
+exports.APTOS_COIN_TOKEN_USDT = {
+    name: 'Tether USD (Aptos)',
+    identifier: coinlib_core_1.SubProtocolSymbols.APTOS_COIN_USDT,
+    symbol: 'USDT',
+    marketSymbol: 'usdt',
+    contractAddress: '0x357b0b74bc833e95a115ad22604854d6b0fca151cecd94111770e5d6ffc9dc2b',
+    decimals: 6
+};
+exports.APTOS_COIN_TOKEN_USDC = {
+    name: 'USD Coin (Aptos)',
+    identifier: coinlib_core_1.SubProtocolSymbols.APTOS_COIN_USDC,
+    symbol: 'USDC',
+    marketSymbol: 'usdc',
+    contractAddress: '0xbae207659db88bea0cbead6da0ed00aac12edcdda169e591cd41c94180b46f3b',
+    decimals: 6
+};
+// List of all predefined Aptos Coin tokens
+exports.APTOS_COIN_TOKENS = [
+    exports.APTOS_COIN_TOKEN_USDT,
+    exports.APTOS_COIN_TOKEN_USDC
+];
+// Helper function to create Aptos Coin token options from metadata
+function createCoinTokenOptionsFromMetadata(metadata, network) {
+    var _a;
+    var units = (_a = {},
+        _a[metadata.symbol] = {
+            symbol: { value: metadata.symbol, market: metadata.marketSymbol, asset: metadata.marketSymbol },
+            decimals: metadata.decimals
+        },
+        _a);
+    return {
+        network: network,
+        name: metadata.name,
+        identifier: metadata.identifier,
+        mainIdentifier: coinlib_core_1.MainProtocolSymbols.APTOS,
+        contractAddress: metadata.contractAddress,
+        units: units,
+        mainUnit: metadata.symbol
+    };
+}
+exports.createCoinTokenOptionsFromMetadata = createCoinTokenOptionsFromMetadata;
+//# sourceMappingURL=AptosCoinTokens.js.map

package/v1/module/AptosCoinTokens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AptosCoinTokens.js","sourceRoot":"","sources":["../../../src/v1/module/AptosCoinTokens.ts"],"names":[],"mappings":";;;AAEA,2DAAoF;AAEpF,iEAAiE;AACjE,2EAA2E;AAC3E,2EAA2E;AAE9D,QAAA,qBAAqB,GAA2B;IAC3D,IAAI,EAAE,oBAAoB;IAC1B,UAAU,EAAE,iCAAkB,CAAC,eAAe;IAC9C,MAAM,EAAE,MAAM;IACd,YAAY,EAAE,MAAM;IACpB,eAAe,EAAE,oEAAoE;IACrF,QAAQ,EAAE,CAAC;CACZ,CAAA;AAEY,QAAA,qBAAqB,GAA2B;IAC3D,IAAI,EAAE,kBAAkB;IACxB,UAAU,EAAE,iCAAkB,CAAC,eAAe;IAC9C,MAAM,EAAE,MAAM;IACd,YAAY,EAAE,MAAM;IACpB,eAAe,EAAE,oEAAoE;IACrF,QAAQ,EAAE,CAAC;CACZ,CAAA;AAED,2CAA2C;AAC9B,QAAA,iBAAiB,GAA6B;IACzD,6BAAqB;IACrB,6BAAqB;CACtB,CAAA;AAED,mEAAmE;AACnE,SAAgB,kCAAkC,CAChD,QAAgC,EAChC,OAA6B;;IAE7B,IAAM,KAAK;QACT,GAAC,QAAQ,CAAC,MAAM,IAAG;YACjB,MAAM,EAAE,EAAE,KAAK,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,YAAY,EAAE,KAAK,EAAE,QAAQ,CAAC,YAAY,EAAE;YAC/F,QAAQ,EAAE,QAAQ,CAAC,QAAQ;SAC5B;WACF,CAAA;IAED,OAAO;QACL,OAAO,SAAA;QACP,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,UAAU,EAAE,QAAQ,CAAC,UAAU;QAC/B,cAAc,EAAE,kCAAmB,CAAC,KAAK;QACzC,eAAe,EAAE,QAAQ,CAAC,eAAe;QACzC,KAAK,OAAA;QACL,QAAQ,EAAE,QAAQ,CAAC,MAAM;KAC1B,CAAA;AACH,CAAC;AApBD,gFAoBC"}

package/v1/module/AptosModule.d.ts

@@ -0,0 +1,18 @@
+import { AirGapModule, AirGapV3SerializerCompanion, ProtocolConfiguration } from '@wallfree-dev/module-kit';
+import { BlockExplorer } from '@wallfree-dev/module-kit/block-explorer/block-explorer';
+import { OfflineProtocol, OnlineProtocol } from '@wallfree-dev/module-kit/protocol/protocol';
+import { AptosProtocolNetwork } from '../types/protocol';
+export declare class AptosModule implements AirGapModule<{
+    ProtocolNetwork: AptosProtocolNetwork;
+}> {
+    private readonly networkRegistries;
+    readonly supportedProtocols: Record<string, ProtocolConfiguration>;
+    private readonly defaultNetwork;
+    private readonly coinTokens;
+    constructor();
+    createOfflineProtocol(identifier: string): Promise<OfflineProtocol | undefined>;
+    createOnlineProtocol(identifier: string, networkOrId?: AptosProtocolNetwork | string): Promise<OnlineProtocol | undefined>;
+    createBlockExplorer(identifier: string, networkOrId?: AptosProtocolNetwork | string): Promise<BlockExplorer | undefined>;
+    createV3SerializerCompanion(): Promise<AirGapV3SerializerCompanion>;
+    private createProtocol;
+}

package/v1/module/AptosModule.js

@@ -0,0 +1,131 @@
+"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 __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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AptosModule = void 0;
+var coinlib_core_1 = require("@wallfree-dev/coinlib-core");
+var errors_1 = require("@wallfree-dev/coinlib-core/errors");
+var module_kit_1 = require("@wallfree-dev/module-kit");
+var AptosBlockExplorer_1 = require("../block-explorer/AptosBlockExplorer");
+var AptosProtocol_1 = require("../protocol/AptosProtocol");
+var AptosCoinTokenProtocol_1 = require("../protocol/AptosCoinTokenProtocol");
+var serializer_companion_1 = require("../serializer/v3/serializer-companion");
+var AptosCoinTokens_1 = require("./AptosCoinTokens");
+var AptosModule = /** @class */ (function () {
+    function AptosModule() {
+        var _a;
+        this.defaultNetwork = (0, AptosProtocol_1.createAptosProtocol)().options.network;
+        this.coinTokens = AptosCoinTokens_1.APTOS_COIN_TOKENS;
+        var networkRegistry = new module_kit_1.ModuleNetworkRegistry({
+            supportedNetworks: [this.defaultNetwork]
+        });
+        // Register main Aptos protocol and all Coin tokens
+        this.networkRegistries = __assign((_a = {}, _a[coinlib_core_1.MainProtocolSymbols.APTOS] = networkRegistry, _a), this.coinTokens.reduce(function (obj, token) {
+            obj[token.identifier] = networkRegistry;
+            return obj;
+        }, {}));
+        this.supportedProtocols = (0, module_kit_1.createSupportedProtocols)(this.networkRegistries);
+    }
+    AptosModule.prototype.createOfflineProtocol = function (identifier) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.createProtocol(identifier)];
+            });
+        });
+    };
+    AptosModule.prototype.createOnlineProtocol = function (identifier, networkOrId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var network;
+            return __generator(this, function (_b) {
+                network = typeof networkOrId === 'object' ? networkOrId : (_a = this.networkRegistries[identifier]) === null || _a === void 0 ? void 0 : _a.findNetwork(networkOrId);
+                if (network === undefined) {
+                    throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.APTOS, 'Protocol network type not supported.');
+                }
+                return [2 /*return*/, this.createProtocol(identifier, network)];
+            });
+        });
+    };
+    AptosModule.prototype.createBlockExplorer = function (identifier, networkOrId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var network;
+            return __generator(this, function (_b) {
+                network = typeof networkOrId === 'object' ? networkOrId : (_a = this.networkRegistries[identifier]) === null || _a === void 0 ? void 0 : _a.findNetwork(networkOrId);
+                if (network === undefined) {
+                    throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.APTOS, 'Block Explorer network type not supported.');
+                }
+                return [2 /*return*/, new AptosBlockExplorer_1.AptosBlockExplorer(network.blockExplorerUrl)];
+            });
+        });
+    };
+    AptosModule.prototype.createV3SerializerCompanion = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new serializer_companion_1.AptosV3SerializerCompanion()];
+            });
+        });
+    };
+    AptosModule.prototype.createProtocol = function (identifier, network) {
+        var resolvedNetwork = network || this.defaultNetwork;
+        // Check if it's the main Aptos protocol
+        if (identifier === coinlib_core_1.MainProtocolSymbols.APTOS) {
+            return (0, AptosProtocol_1.createAptosProtocol)({ network: resolvedNetwork });
+        }
+        // Check if it's a Coin token
+        var coinToken = this.coinTokens.find(function (token) { return token.identifier === identifier; });
+        if (coinToken) {
+            var options = (0, AptosCoinTokens_1.createCoinTokenOptionsFromMetadata)(coinToken, resolvedNetwork);
+            return (0, AptosCoinTokenProtocol_1.createAptosCoinTokenProtocol)(options);
+        }
+        throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.APTOS, "Protocol ".concat(identifier, " not supported."));
+    };
+    return AptosModule;
+}());
+exports.AptosModule = AptosModule;
+//# sourceMappingURL=AptosModule.js.map

package/v1/module/AptosModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AptosModule.js","sourceRoot":"","sources":["../../../src/v1/module/AptosModule.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2DAAwE;AACxE,4DAA2E;AAC3E,uDAOiC;AAIjC,2EAAyE;AACzE,2DAA+D;AAC/D,6EAAiF;AACjF,8EAAkF;AAElF,qDAAyF;AAEzF;IAME;;QACE,IAAI,CAAC,cAAc,GAAG,IAAA,mCAAmB,GAAE,CAAC,OAAO,CAAC,OAAO,CAAA;QAC3D,IAAI,CAAC,UAAU,GAAG,mCAAiB,CAAA;QAEnC,IAAM,eAAe,GAA0B,IAAI,kCAAqB,CAAC;YACvE,iBAAiB,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC;SACzC,CAAC,CAAA;QAEF,mDAAmD;QACnD,IAAI,CAAC,iBAAiB,yBACnB,kCAAmB,CAAC,KAAK,IAAG,eAAe,OACzC,IAAI,CAAC,UAAU,CAAC,MAAM,CACvB,UAAC,GAA0C,EAAE,KAAK;YAChD,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,eAAe,CAAA;YACvC,OAAO,GAAG,CAAA;QACZ,CAAC,EACD,EAAE,CACH,CACF,CAAA;QACD,IAAI,CAAC,kBAAkB,GAAG,IAAA,qCAAwB,EAAC,IAAI,CAAC,iBAAiB,CAAC,CAAA;IAC5E,CAAC;IAEY,2CAAqB,GAAlC,UAAmC,UAAkB;;;gBACnD,sBAAO,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,EAAA;;;KACvC;IAEY,0CAAoB,GAAjC,UACE,UAAkB,EAClB,WAA2C;;;;;gBAErC,OAAO,GACX,OAAO,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,MAAA,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,0CAAE,WAAW,CAAC,WAAW,CAAC,CAAA;gBAE9G,IAAI,OAAO,KAAK,SAAS,EAAE;oBACzB,MAAM,IAAI,gCAAuB,CAAC,qBAAM,CAAC,KAAK,EAAE,sCAAsC,CAAC,CAAA;iBACxF;gBAED,sBAAO,IAAI,CAAC,cAAc,CAAC,UAAU,EAAE,OAA+B,CAAC,EAAA;;;KACxE;IAEY,yCAAmB,GAAhC,UAAiC,UAAkB,EAAE,WAA2C;;;;;gBACxF,OAAO,GACX,OAAO,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,MAAA,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,0CAAE,WAAW,CAAC,WAAW,CAAC,CAAA;gBAE9G,IAAI,OAAO,KAAK,SAAS,EAAE;oBACzB,MAAM,IAAI,gCAAuB,CAAC,qBAAM,CAAC,KAAK,EAAE,4CAA4C,CAAC,CAAA;iBAC9F;gBAED,sBAAO,IAAI,uCAAkB,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAA;;;KACxD;IAEY,iDAA2B,GAAxC;;;gBACE,sBAAO,IAAI,iDAA0B,EAAE,EAAA;;;KACxC;IAEO,oCAAc,GAAtB,UAAuB,UAAkB,EAAE,OAA8B;QACvE,IAAM,eAAe,GAAG,OAAO,IAAI,IAAI,CAAC,cAAc,CAAA;QAEtD,wCAAwC;QACxC,IAAI,UAAU,KAAK,kCAAmB,CAAC,KAAK,EAAE;YAC5C,OAAO,IAAA,mCAAmB,EAAC,EAAE,OAAO,EAAE,eAAe,EAAE,CAAC,CAAA;SACzD;QAED,6BAA6B;QAC7B,IAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,UAAA,KAAK,IAAI,OAAA,KAAK,CAAC,UAAU,KAAK,UAAU,EAA/B,CAA+B,CAAC,CAAA;QAChF,IAAI,SAAS,EAAE;YACb,IAAM,OAAO,GAAG,IAAA,oDAAkC,EAAC,SAAS,EAAE,eAAe,CAAC,CAAA;YAC9E,OAAO,IAAA,qDAA4B,EAAC,OAAO,CAAC,CAAA;SAC7C;QAED,MAAM,IAAI,gCAAuB,CAAC,qBAAM,CAAC,KAAK,EAAE,mBAAY,UAAU,oBAAiB,CAAC,CAAA;IAC1F,CAAC;IACH,kBAAC;AAAD,CAAC,AA9ED,IA8EC;AA9EY,kCAAW"}

package/v1/protocol/AptosCoinTokenProtocol.d.ts

@@ -0,0 +1,89 @@
+import { AirGapInterface, AirGapProtocol, AirGapTransaction, AirGapTransactionsWithCursor, Amount, Balance, CryptoDerivative, FeeDefaults, KeyPair, ProtocolMetadata, PublicKey, SecretKey, Signature, TransactionDetails, TransactionFullConfiguration, TransactionSimpleConfiguration, ExtendedKeyPair, ExtendedPublicKey, ExtendedSecretKey } from '@wallfree-dev/module-kit';
+import { AptosProtocolNetwork, AptosCoinTokenOptions, AptosTransactionCursor, AptosUnits } from '../types/protocol';
+export interface AptosCoinTokenProtocol<_Units extends string = string> extends AirGapInterface<AirGapProtocol<{
+    AddressResult: string;
+    ProtocolNetwork: AptosProtocolNetwork;
+    CryptoConfiguration: {
+        algorithm: 'ed25519';
+    };
+    Units: _Units;
+    FeeUnits: AptosUnits;
+    FeeEstimation: FeeDefaults<AptosUnits>;
+    SignedTransaction: {
+        serialized: string;
+        type: 'signed';
+    };
+    UnsignedTransaction: {
+        serialized: string;
+        type: 'unsigned';
+    };
+    TransactionCursor: any;
+}, 'Crypto'>, 'SingleTokenSubProtocol'> {
+}
+export declare class AptosCoinTokenProtocolImpl<_Units extends string = string> implements AptosCoinTokenProtocol<_Units> {
+    readonly options: AptosCoinTokenOptions<_Units>;
+    private readonly units;
+    private readonly mainUnit;
+    private readonly contractAddress;
+    private readonly isCoinType;
+    constructor(options: AptosCoinTokenOptions<_Units>);
+    private fetchJson;
+    getType(): Promise<'token'>;
+    mainProtocol(): Promise<string>;
+    getContractAddress(): Promise<string>;
+    getMetadata(): Promise<ProtocolMetadata<_Units, AptosUnits>>;
+    private getPublicKeyBuffer;
+    getAddressFromPublicKey(publicKey: PublicKey | ExtendedPublicKey): Promise<string>;
+    getAddressesFromPublicKey(publicKey: PublicKey | ExtendedPublicKey): Promise<{
+        address: string;
+        cursor: {
+            hasNext: false;
+        };
+    }[]>;
+    validateAddress(address: string): Promise<boolean>;
+    getBalanceOfAddress(address: string): Promise<Balance<_Units>>;
+    getBalanceOfPublicKey(publicKey: PublicKey | ExtendedPublicKey): Promise<Balance<_Units>>;
+    getDetailsFromTransaction(transaction: {
+        serialized: string;
+        type: 'signed' | 'unsigned';
+    }, publicKey: PublicKey | ExtendedPublicKey): Promise<AirGapTransaction<_Units, AptosUnits>[]>;
+    getTransactionDetailsFromSigned(signedTx: {
+        transaction: {
+            serialized: string;
+            type: 'signed' | 'unsigned';
+        };
+    }): Promise<AirGapTransaction<_Units, AptosUnits>[]>;
+    verifyMessageWithPublicKey(message: string, signature: Signature, publicKey: PublicKey | ExtendedPublicKey): Promise<boolean>;
+    encryptAsymmetricWithPublicKey(payload: string, publicKey: PublicKey | ExtendedPublicKey): Promise<string>;
+    getCryptoConfiguration(): Promise<{
+        algorithm: 'ed25519';
+    }>;
+    getKeyPairFromDerivative(derivative: CryptoDerivative): Promise<KeyPair>;
+    signTransactionWithSecretKey(transaction: {
+        serialized: string;
+        type: 'unsigned';
+    }, secretKey: SecretKey | ExtendedSecretKey): Promise<{
+        serialized: string;
+        type: 'signed';
+    }>;
+    signMessageWithKeyPair(message: string, keyPair: KeyPair | ExtendedKeyPair): Promise<Signature>;
+    decryptAsymmetricWithKeyPair(payload: string, keyPair: KeyPair | ExtendedKeyPair): Promise<string>;
+    encryptAESWithSecretKey(payload: string, secretKey: SecretKey | ExtendedSecretKey): Promise<string>;
+    decryptAESWithSecretKey(payload: string, secretKey: SecretKey | ExtendedSecretKey): Promise<string>;
+    getNetwork(): Promise<AptosProtocolNetwork>;
+    private static readonly DEFAULT_TX_LIMIT;
+    getTransactionsForAddress(address: string, limit: number, cursor?: AptosTransactionCursor): Promise<AirGapTransactionsWithCursor<AptosTransactionCursor, _Units, AptosUnits>>;
+    getTransactionsForPublicKey(publicKey: PublicKey | ExtendedPublicKey, limit: number, cursor?: AptosTransactionCursor): Promise<AirGapTransactionsWithCursor<AptosTransactionCursor, _Units, AptosUnits>>;
+    getTransactionStatus(transactionIds: string[]): Promise<Record<string, any>>;
+    getTransactionMaxAmountWithPublicKey(publicKey: PublicKey | ExtendedPublicKey, to: string[], configuration?: TransactionFullConfiguration<AptosUnits>): Promise<Amount<_Units>>;
+    getTransactionFeeWithPublicKey(publicKey: PublicKey | ExtendedPublicKey, details: TransactionDetails<_Units>[], configuration?: TransactionSimpleConfiguration): Promise<FeeDefaults<AptosUnits>>;
+    prepareTransactionWithPublicKey(publicKey: PublicKey | ExtendedPublicKey, details: TransactionDetails<_Units>[], configuration?: TransactionFullConfiguration<AptosUnits>): Promise<{
+        serialized: string;
+        type: 'unsigned';
+    }>;
+    broadcastTransaction(transaction: {
+        serialized: string;
+        type: 'signed';
+    }): Promise<string>;
+}
+export declare function createAptosCoinTokenProtocol<_Units extends string = string>(options: AptosCoinTokenOptions<_Units>): AptosCoinTokenProtocol<_Units>;