@airgap/base 0.13.45-beta.4

package/v1/protocol/BaseProtocol.js

@@ -0,0 +1,86 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBaseProtocolOptions = exports.BASE_MAINNET_PROTOCOL_NETWORK = exports.createBaseProtocol = void 0;
+var coinlib_core_1 = require("@airgap/coinlib-core");
+var v1_1 = require("@airgap/ethereum/v1");
+var module_kit_1 = require("@airgap/module-kit");
+var HttpBaseNodeClient_1 = require("../client/node/HttpBaseNodeClient");
+var BaseBaseProtocol_1 = require("./BaseBaseProtocol");
+// Implementation
+var BaseProtocolImpl = /** @class */ (function (_super) {
+    __extends(BaseProtocolImpl, _super);
+    function BaseProtocolImpl(options) {
+        var completeOptions = createBaseProtocolOptions(options.network);
+        var nodeClient = new HttpBaseNodeClient_1.HttpBaseNodeClient(completeOptions.network.rpcUrl);
+        var infoClient = new v1_1.EtherscanInfoClient(completeOptions.network.blockExplorerApi);
+        var baseProtocolOptions = {
+            network: completeOptions.network,
+            identifier: coinlib_core_1.MainProtocolSymbols.BASE,
+            name: 'Base',
+            units: __assign(__assign({}, v1_1.DEFAULT_ETHEREUM_UNITS_METADATA), { ETH: {
+                    symbol: __assign(__assign({}, v1_1.DEFAULT_ETHEREUM_UNITS_METADATA.ETH.symbol), { asset: 'BASE' }),
+                    decimals: v1_1.DEFAULT_ETHEREUM_UNITS_METADATA.ETH.decimals
+                } }),
+            mainUnit: 'ETH',
+            // The layer 2 gas price is normally 0.001 gwei, but it increases when experiencing heavy congestion
+            feeDefaults: {
+                low: (0, module_kit_1.newAmount)(15.75 /* 21000 GAS * 0.00075 GWEI */, 'GWEI').blockchain(v1_1.DEFAULT_ETHEREUM_UNITS_METADATA),
+                medium: (0, module_kit_1.newAmount)(22.05 /* 21000 GAS * 0.00105 GWEI */, 'GWEI').blockchain(v1_1.DEFAULT_ETHEREUM_UNITS_METADATA),
+                high: (0, module_kit_1.newAmount)(44.1 /* 21000 GAS * 0.0021 GWEI */, 'GWEI').blockchain(v1_1.DEFAULT_ETHEREUM_UNITS_METADATA)
+            }
+        };
+        var ethereumProtocol = new v1_1.EthereumBaseProtocolImpl(nodeClient, infoClient, baseProtocolOptions);
+        return _super.call(this, ethereumProtocol, nodeClient, infoClient, completeOptions) || this;
+    }
+    return BaseProtocolImpl;
+}(BaseBaseProtocol_1.BaseBaseProtocolImpl));
+// Factory
+function createBaseProtocol(options) {
+    if (options === void 0) { options = {}; }
+    return new BaseProtocolImpl(options);
+}
+exports.createBaseProtocol = createBaseProtocol;
+exports.BASE_MAINNET_PROTOCOL_NETWORK = {
+    name: 'Mainnet',
+    type: 'mainnet',
+    rpcUrl: 'https://base-rpc.publicnode.com',
+    chainId: 8453,
+    blockExplorerUrl: 'https://basescan.org',
+    blockExplorerApi: 'https://api.basescan.org/api',
+    gasPriceOracleAddress: '0x420000000000000000000000000000000000000F'
+};
+var DEFAULT_BASE_PROTOCOL_NETWORK = exports.BASE_MAINNET_PROTOCOL_NETWORK;
+function createBaseProtocolOptions(network) {
+    if (network === void 0) { network = {}; }
+    return {
+        network: __assign(__assign({}, DEFAULT_BASE_PROTOCOL_NETWORK), network)
+    };
+}
+exports.createBaseProtocolOptions = createBaseProtocolOptions;
+//# sourceMappingURL=BaseProtocol.js.map

package/v1/protocol/BaseProtocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseProtocol.js","sourceRoot":"","sources":["../../../src/v1/protocol/BaseProtocol.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,qDAA0D;AAC1D,0CAM4B;AAC5B,iDAAgE;AAEhE,wEAAsE;AAGtE,uDAA2E;AAM3E,iBAAiB;AAEjB;IAA+B,oCAAoB;IACjD,0BAAY,OAA8C;QACxD,IAAM,eAAe,GAAG,yBAAyB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;QAElE,IAAM,UAAU,GAAG,IAAI,uCAAkB,CAAC,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;QACzE,IAAM,UAAU,GAAG,IAAI,wBAAmB,CAAC,eAAe,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAA;QAEpF,IAAM,mBAAmB,GAAoE;YAC3F,OAAO,EAAE,eAAe,CAAC,OAAO;YAEhC,UAAU,EAAE,kCAAmB,CAAC,IAAI;YACpC,IAAI,EAAE,MAAM;YAEZ,KAAK,wBACA,oCAA+B,KAClC,GAAG,EAAE;oBACH,MAAM,wBAAO,oCAA+B,CAAC,GAAG,CAAC,MAAM,KAAE,KAAK,EAAE,MAAM,GAAE;oBACxE,QAAQ,EAAE,oCAA+B,CAAC,GAAG,CAAC,QAAQ;iBACvD,GACF;YACD,QAAQ,EAAE,KAAK;YAEf,oGAAoG;YACpG,WAAW,EAAE;gBACX,GAAG,EAAE,IAAA,sBAAS,EAAC,KAAK,CAAC,8BAA8B,EAAE,MAAM,CAAC,CAAC,UAAU,CAAC,oCAA+B,CAAC;gBACxG,MAAM,EAAE,IAAA,sBAAS,EAAC,KAAK,CAAC,8BAA8B,EAAE,MAAM,CAAC,CAAC,UAAU,CAAC,oCAA+B,CAAC;gBAC3G,IAAI,EAAE,IAAA,sBAAS,EAAC,IAAI,CAAC,6BAA6B,EAAE,MAAM,CAAC,CAAC,UAAU,CAAC,oCAA+B,CAAC;aACxG;SACF,CAAA;QAED,IAAM,gBAAgB,GAAG,IAAI,6BAAwB,CAAC,UAAU,EAAE,UAAU,EAAE,mBAAmB,CAAC,CAAA;eAElG,kBAAM,gBAAgB,EAAE,UAAU,EAAE,UAAU,EAAE,eAAe,CAAC;IAClE,CAAC;IACH,uBAAC;AAAD,CAAC,AAlCD,CAA+B,uCAAoB,GAkClD;AAED,UAAU;AAEV,SAAgB,kBAAkB,CAAC,OAAmD;IAAnD,wBAAA,EAAA,YAAmD;IACpF,OAAO,IAAI,gBAAgB,CAAC,OAAO,CAAC,CAAA;AACtC,CAAC;AAFD,gDAEC;AAEY,QAAA,6BAA6B,GAAwB;IAChE,IAAI,EAAE,SAAS;IACf,IAAI,EAAE,SAAS;IACf,MAAM,EAAE,iCAAiC;IACzC,OAAO,EAAE,IAAI;IACb,gBAAgB,EAAE,sBAAsB;IACxC,gBAAgB,EAAE,8BAA8B;IAChD,qBAAqB,EAAE,4CAA4C;CACpE,CAAA;AAED,IAAM,6BAA6B,GAAwB,qCAA6B,CAAA;AAExF,SAAgB,yBAAyB,CAAC,OAA0C;IAA1C,wBAAA,EAAA,YAA0C;IAClF,OAAO;QACL,OAAO,wBAAO,6BAA6B,GAAK,OAAO,CAAE;KAC1D,CAAA;AACH,CAAC;AAJD,8DAIC"}

package/v1/protocol/erc20/ERC20Token.d.ts

@@ -0,0 +1,20 @@
+import { ERC20TokenMetadata, ERC20TokenOptions, EthereumProtocolNetwork } from '@airgap/ethereum/v1';
+import { AirGapInterface, RecursivePartial } from '@airgap/module-kit';
+import { BaseProtocolNetwork, BaseProtocolOptions } from '../../types/protocol';
+import { BaseBaseProtocol } from '../BaseBaseProtocol';
+export interface ERC20Token extends AirGapInterface<BaseBaseProtocol<string>, 'SingleTokenSubProtocol'> {
+    name(): Promise<string | undefined>;
+    symbol(): Promise<string | undefined>;
+    decimals(): Promise<number | undefined>;
+    tokenMetadata(): Promise<ERC20TokenMetadata>;
+}
+export declare function createERC20Token(metadata: ERC20TokenMetadata, options?: RecursivePartial<BaseProtocolOptions>): ERC20Token;
+export declare const BASE_ERC20_MAINNET_PROTOCOL_NETWORK: BaseProtocolNetwork;
+export declare function createERC20TokenOptions(metadata: ERC20TokenMetadata, network?: Partial<EthereumProtocolNetwork>): ERC20TokenOptions<BaseProtocolNetwork>;
+export interface SerializedERC20Token {
+    metadata: ERC20TokenMetadata;
+    network: BaseProtocolNetwork;
+}
+export declare function serializeERC20Token(erc20Token: ERC20Token): Promise<SerializedERC20Token>;
+export declare function deserializeERC20Token(serialized: SerializedERC20Token): ERC20Token;
+export declare function isSerializedERC20Token(serialized: unknown): serialized is SerializedERC20Token;

package/v1/protocol/erc20/ERC20Token.js

@@ -0,0 +1,198 @@
+"use strict";
+// Factory
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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.isSerializedERC20Token = exports.deserializeERC20Token = exports.serializeERC20Token = exports.createERC20TokenOptions = exports.BASE_ERC20_MAINNET_PROTOCOL_NETWORK = exports.createERC20Token = void 0;
+var coinlib_core_1 = require("@airgap/coinlib-core");
+var v1_1 = require("@airgap/ethereum/v1");
+var module_kit_1 = require("@airgap/module-kit");
+var HttpBaseNodeClient_1 = require("../../client/node/HttpBaseNodeClient");
+var BaseBaseProtocol_1 = require("../BaseBaseProtocol");
+var BaseProtocol_1 = require("../BaseProtocol");
+// Implementation
+var ERC20TokenImpl = /** @class */ (function (_super) {
+    __extends(ERC20TokenImpl, _super);
+    function ERC20TokenImpl(options) {
+        var nodeClient = new HttpBaseNodeClient_1.HttpBaseNodeClient(options.network.rpcUrl);
+        var infoClient = new v1_1.EtherscanInfoClient(options.network.blockExplorerApi);
+        var ethereumProtocol = new v1_1.ERC20TokenImpl(nodeClient, infoClient, options);
+        return _super.call(this, ethereumProtocol, nodeClient, infoClient, options) || this;
+    }
+    // SubProtocol
+    ERC20TokenImpl.prototype.getType = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getType()];
+            });
+        });
+    };
+    ERC20TokenImpl.prototype.mainProtocol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.mainProtocol()];
+            });
+        });
+    };
+    ERC20TokenImpl.prototype.getContractAddress = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.getContractAddress()];
+            });
+        });
+    };
+    // Custom
+    ERC20TokenImpl.prototype.name = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.name()];
+            });
+        });
+    };
+    ERC20TokenImpl.prototype.symbol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.symbol()];
+            });
+        });
+    };
+    ERC20TokenImpl.prototype.decimals = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ethereumProtocol.decimals()];
+            });
+        });
+    };
+    ERC20TokenImpl.prototype.tokenMetadata = function () {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var mainUnit;
+            return __generator(this, function (_b) {
+                mainUnit = this.options.units[this.options.mainUnit];
+                return [2 /*return*/, {
+                        name: this.options.name,
+                        identifier: this.options.identifier,
+                        symbol: mainUnit.symbol.value,
+                        marketSymbol: (_a = mainUnit.symbol.market) !== null && _a !== void 0 ? _a : mainUnit.symbol.value,
+                        contractAddress: this.options.contractAddress,
+                        decimals: mainUnit.decimals
+                    }];
+            });
+        });
+    };
+    return ERC20TokenImpl;
+}(BaseBaseProtocol_1.BaseBaseProtocolImpl));
+// Factory
+function createERC20Token(metadata, options) {
+    if (options === void 0) { options = {}; }
+    var completeOptions = createERC20TokenOptions(metadata, options.network);
+    return new ERC20TokenImpl(completeOptions);
+}
+exports.createERC20Token = createERC20Token;
+exports.BASE_ERC20_MAINNET_PROTOCOL_NETWORK = BaseProtocol_1.BASE_MAINNET_PROTOCOL_NETWORK;
+var DEFAULT_ERC20_PROTOCOL_NETWORK = exports.BASE_ERC20_MAINNET_PROTOCOL_NETWORK;
+function createERC20TokenOptions(metadata, network) {
+    var _a;
+    if (network === void 0) { network = {}; }
+    return {
+        network: __assign(__assign({}, DEFAULT_ERC20_PROTOCOL_NETWORK), network),
+        name: metadata.name,
+        identifier: metadata.identifier,
+        mainIdentifier: coinlib_core_1.MainProtocolSymbols.BASE,
+        contractAddress: metadata.contractAddress,
+        units: (_a = {},
+            _a[metadata.symbol] = {
+                symbol: { value: metadata.symbol, market: metadata.marketSymbol },
+                decimals: metadata.decimals
+            },
+            _a),
+        mainUnit: metadata.symbol
+    };
+}
+exports.createERC20TokenOptions = createERC20TokenOptions;
+function serializeERC20Token(erc20Token) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, tokenMetadata, network;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, Promise.all([
+                        erc20Token.tokenMetadata(),
+                        erc20Token.getNetwork()
+                    ])];
+                case 1:
+                    _a = _b.sent(), tokenMetadata = _a[0], network = _a[1];
+                    return [2 /*return*/, { metadata: tokenMetadata, network: network }];
+            }
+        });
+    });
+}
+exports.serializeERC20Token = serializeERC20Token;
+function deserializeERC20Token(serialized) {
+    return createERC20Token(serialized.metadata, { network: serialized.network });
+}
+exports.deserializeERC20Token = deserializeERC20Token;
+function isSerializedERC20Token(serialized) {
+    return (0, module_kit_1.implementsInterface)(serialized, { metadata: 'required', network: 'required' });
+}
+exports.isSerializedERC20Token = isSerializedERC20Token;
+//# sourceMappingURL=ERC20Token.js.map

package/v1/protocol/erc20/ERC20Token.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ERC20Token.js","sourceRoot":"","sources":["../../../../src/v1/protocol/erc20/ERC20Token.ts"],"names":[],"mappings":";AAAA,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEV,qDAA0D;AAC1D,0CAM4B;AAC5B,iDAA2F;AAE3F,2EAAyE;AAEzE,wDAA4E;AAC5E,gDAA+D;AAY/D,iBAAiB;AAEjB;IACU,kCAAiH;IAGzH,wBAAY,OAA+C;QACzD,IAAM,UAAU,GAAG,IAAI,uCAAkB,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;QACjE,IAAM,UAAU,GAAG,IAAI,wBAAmB,CAAC,OAAO,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAA;QAE5E,IAAM,gBAAgB,GAAG,IAAI,mBAAsB,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,CAAC,CAAA;eAEpF,kBAAM,gBAAgB,EAAE,UAAU,EAAE,UAAU,EAAE,OAAO,CAAC;IAC1D,CAAC;IAED,cAAc;IAED,gCAAO,GAApB;;;gBACE,sBAAO,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,EAAA;;;KACvC;IAEY,qCAAY,GAAzB;;;gBACE,sBAAO,IAAI,CAAC,gBAAgB,CAAC,YAAY,EAAE,EAAA;;;KAC5C;IAEY,2CAAkB,GAA/B;;;gBACE,sBAAO,IAAI,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,EAAA;;;KAClD;IAED,SAAS;IAEI,6BAAI,GAAjB;;;gBACE,sBAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,EAAA;;;KACpC;IAEY,+BAAM,GAAnB;;;gBACE,sBAAO,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,EAAA;;;KACtC;IAEY,iCAAQ,GAArB;;;gBACE,sBAAO,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,EAAA;;;KACxC;IAEY,sCAAa,GAA1B;;;;;gBACQ,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;gBAE1D,sBAAO;wBACL,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;wBACvB,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU;wBACnC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK;wBAC7B,YAAY,EAAE,MAAA,QAAQ,CAAC,MAAM,CAAC,MAAM,mCAAI,QAAQ,CAAC,MAAM,CAAC,KAAK;wBAC7D,eAAe,EAAE,IAAI,CAAC,OAAO,CAAC,eAAe;wBAC7C,QAAQ,EAAE,QAAQ,CAAC,QAAQ;qBAC5B,EAAA;;;KACF;IACH,qBAAC;AAAD,CAAC,AArDD,CACU,uCAAoB,GAoD7B;AAED,UAAU;AAEV,SAAgB,gBAAgB,CAAC,QAA4B,EAAE,OAAmD;IAAnD,wBAAA,EAAA,YAAmD;IAChH,IAAM,eAAe,GAAG,uBAAuB,CAAC,QAAQ,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;IAE1E,OAAO,IAAI,cAAc,CAAC,eAAe,CAAC,CAAA;AAC5C,CAAC;AAJD,4CAIC;AAEY,QAAA,mCAAmC,GAAwB,4CAA6B,CAAA;AAErG,IAAM,8BAA8B,GAAwB,2CAAmC,CAAA;AAE/F,SAAgB,uBAAuB,CACrC,QAA4B,EAC5B,OAA8C;;IAA9C,wBAAA,EAAA,YAA8C;IAE9C,OAAO;QACL,OAAO,wBAAO,8BAA8B,GAAK,OAAO,CAAE;QAC1D,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,UAAU,EAAE,QAAQ,CAAC,UAAU;QAC/B,cAAc,EAAE,kCAAmB,CAAC,IAAI;QAExC,eAAe,EAAE,QAAQ,CAAC,eAAe;QAEzC,KAAK;YACH,GAAC,QAAQ,CAAC,MAAM,IAAG;gBACjB,MAAM,EAAE,EAAE,KAAK,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,YAAY,EAAE;gBACjE,QAAQ,EAAE,QAAQ,CAAC,QAAQ;aAC5B;eACF;QACD,QAAQ,EAAE,QAAQ,CAAC,MAAM;KAC1B,CAAA;AACH,CAAC;AApBD,0DAoBC;AASD,SAAsB,mBAAmB,CAAC,UAAsB;;;;;wBACc,qBAAM,OAAO,CAAC,GAAG,CAAC;wBAC5F,UAAU,CAAC,aAAa,EAAE;wBAC1B,UAAU,CAAC,UAAU,EAAE;qBACxB,CAAC,EAAA;;oBAHI,KAAsE,SAG1E,EAHK,aAAa,QAAA,EAAE,OAAO,QAAA;oBAK7B,sBAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,OAAO,SAAA,EAAE,EAAA;;;;CAC5C;AAPD,kDAOC;AAED,SAAgB,qBAAqB,CAAC,UAAgC;IACpE,OAAO,gBAAgB,CAAC,UAAU,CAAC,QAAQ,EAAE,EAAE,OAAO,EAAE,UAAU,CAAC,OAAO,EAAE,CAAC,CAAA;AAC/E,CAAC;AAFD,sDAEC;AAED,SAAgB,sBAAsB,CAAC,UAAmB;IACxD,OAAO,IAAA,gCAAmB,EAAuB,UAAU,EAAE,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,CAAA;AAC7G,CAAC;AAFD,wDAEC"}

package/v1/serializer/v3/schemas/converter/transaction-converter.d.ts

@@ -0,0 +1,8 @@
+import { BaseSignedTransaction, BaseUnsignedTransaction } from '../../../../types/transaction';
+import { BaseTransactionSignRequest } from '../definitions/transaction-sign-request-base';
+import { BaseTypedTransactionSignRequest } from '../definitions/transaction-sign-request-base-typed';
+import { BaseTransactionSignResponse } from '../definitions/transaction-sign-response-base';
+export declare function baseUnsignedTransactionToRequest(unsigned: BaseUnsignedTransaction, publicKey: string, callbackUrl?: string): BaseTransactionSignRequest | BaseTypedTransactionSignRequest;
+export declare function baseSignedTransactionToResponse(signed: BaseSignedTransaction, accountIdentifier: string): BaseTransactionSignResponse;
+export declare function baseTransactionSignRequestToUnsigned(request: BaseTransactionSignRequest | BaseTypedTransactionSignRequest): BaseUnsignedTransaction;
+export declare function baseTransactionSignResponseToSigned(response: BaseTransactionSignResponse): BaseSignedTransaction;

package/v1/serializer/v3/schemas/converter/transaction-converter.js

@@ -0,0 +1,54 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseTransactionSignResponseToSigned = exports.baseTransactionSignRequestToUnsigned = exports.baseSignedTransactionToResponse = exports.baseUnsignedTransactionToRequest = void 0;
+var v1_1 = require("@airgap/ethereum/v1");
+var module_kit_1 = require("@airgap/module-kit");
+function baseUnsignedTransactionToRequest(unsigned, publicKey, callbackUrl) {
+    var ethereumAnyTransactionSignRequest = (0, v1_1.ethereumUnsignedTransactionToRequest)(unsigned, publicKey, callbackUrl);
+    if (unsigned.ethereumType === 'raw') {
+        var ethereumTransactionSignRequest = ethereumAnyTransactionSignRequest;
+        var baseTransactionSignRequest = __assign(__assign({}, ethereumTransactionSignRequest), { transaction: __assign(__assign({}, ethereumTransactionSignRequest.transaction), { l1DataFee: unsigned.l1DataFee }) });
+        return baseTransactionSignRequest;
+    }
+    return ethereumAnyTransactionSignRequest;
+}
+exports.baseUnsignedTransactionToRequest = baseUnsignedTransactionToRequest;
+function baseSignedTransactionToResponse(signed, accountIdentifier) {
+    return (0, v1_1.ethereumSignedTransactionToResponse)(__assign(__assign({}, signed), { serialized: signed.l1DataFee ? JSON.stringify({ serialized: signed.serialized, l1DataFee: signed.l1DataFee }) : signed.serialized }), accountIdentifier);
+}
+exports.baseSignedTransactionToResponse = baseSignedTransactionToResponse;
+function baseTransactionSignRequestToUnsigned(request) {
+    var ethereumUnsignedTransaction = (0, v1_1.ethereumTransactionSignRequestToUnsigned)(request);
+    if (ethereumUnsignedTransaction.ethereumType === 'raw') {
+        var baseRawRequest = request;
+        return (0, module_kit_1.newUnsignedTransaction)(__assign(__assign({}, ethereumUnsignedTransaction), { l1DataFee: baseRawRequest.transaction.l1DataFee }));
+    }
+    return ethereumUnsignedTransaction;
+}
+exports.baseTransactionSignRequestToUnsigned = baseTransactionSignRequestToUnsigned;
+function baseTransactionSignResponseToSigned(response) {
+    var ethereumSignedTransaction = (0, v1_1.ethereumTransactionSignResponseToSigned)(response);
+    try {
+        var _a = JSON.parse(ethereumSignedTransaction.serialized), serialized = _a.serialized, l1DataFee = _a.l1DataFee;
+        return (0, module_kit_1.newSignedTransaction)({
+            serialized: serialized,
+            l1DataFee: l1DataFee
+        });
+    }
+    catch (_b) {
+        return ethereumSignedTransaction;
+    }
+}
+exports.baseTransactionSignResponseToSigned = baseTransactionSignResponseToSigned;
+//# sourceMappingURL=transaction-converter.js.map

package/v1/serializer/v3/schemas/converter/transaction-converter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-converter.js","sourceRoot":"","sources":["../../../../../../src/v1/serializer/v3/schemas/converter/transaction-converter.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAAA,0CAM4B;AAC5B,iDAAiF;AAOjF,SAAgB,gCAAgC,CAC9C,QAAiC,EACjC,SAAiB,EACjB,WAAoB;IAEpB,IAAM,iCAAiC,GAAG,IAAA,yCAAoC,EAAC,QAAQ,EAAE,SAAS,EAAE,WAAW,CAAC,CAAA;IAEhH,IAAI,QAAQ,CAAC,YAAY,KAAK,KAAK,EAAE;QACnC,IAAM,8BAA8B,GAAG,iCAAmE,CAAA;QAC1G,IAAM,0BAA0B,yBAC3B,8BAA8B,KACjC,WAAW,wBACN,8BAA8B,CAAC,WAAW,KAC7C,SAAS,EAAE,QAAQ,CAAC,SAAS,MAEhC,CAAA;QAED,OAAO,0BAA0B,CAAA;KAClC;IAED,OAAO,iCAAoE,CAAA;AAC7E,CAAC;AArBD,4EAqBC;AAED,SAAgB,+BAA+B,CAAC,MAA6B,EAAE,iBAAyB;IACtG,OAAO,IAAA,wCAAmC,wBAEnC,MAAM,KACT,UAAU,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,KAEnI,iBAAiB,CAClB,CAAA;AACH,CAAC;AARD,0EAQC;AAED,SAAgB,oCAAoC,CAClD,OAAqE;IAErE,IAAM,2BAA2B,GAAG,IAAA,6CAAwC,EAAC,OAAO,CAAC,CAAA;IAErF,IAAI,2BAA2B,CAAC,YAAY,KAAK,KAAK,EAAE;QACtD,IAAM,cAAc,GAAG,OAAqC,CAAA;QAC5D,OAAO,IAAA,mCAAsB,wBACxB,2BAA2B,KAC9B,SAAS,EAAE,cAAc,CAAC,WAAW,CAAC,SAAS,IAC/C,CAAA;KACH;IAED,OAAO,2BAA2B,CAAA;AACpC,CAAC;AAdD,oFAcC;AAED,SAAgB,mCAAmC,CAAC,QAAqC;IACvF,IAAM,yBAAyB,GAAG,IAAA,4CAAuC,EAAC,QAAQ,CAAC,CAAA;IAEnF,IAAI;QACI,IAAA,KAA4B,IAAI,CAAC,KAAK,CAAC,yBAAyB,CAAC,UAAU,CAAC,EAA1E,UAAU,gBAAA,EAAE,SAAS,eAAqD,CAAA;QAElF,OAAO,IAAA,iCAAoB,EAAwB;YACjD,UAAU,YAAA;YACV,SAAS,WAAA;SACV,CAAC,CAAA;KACH;IAAC,WAAM;QACN,OAAO,yBAAyB,CAAA;KACjC;AACH,CAAC;AAbD,kFAaC"}

package/v1/serializer/v3/schemas/definitions/transaction-sign-request-base-typed.d.ts

@@ -0,0 +1,3 @@
+import { EthereumTypedTransactionSignRequest } from '@airgap/ethereum/v1';
+export interface BaseTypedTransactionSignRequest extends EthereumTypedTransactionSignRequest {
+}

package/v1/serializer/v3/schemas/definitions/transaction-sign-request-base-typed.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=transaction-sign-request-base-typed.js.map

package/v1/serializer/v3/schemas/definitions/transaction-sign-request-base-typed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-sign-request-base-typed.js","sourceRoot":"","sources":["../../../../../../src/v1/serializer/v3/schemas/definitions/transaction-sign-request-base-typed.ts"],"names":[],"mappings":""}

package/v1/serializer/v3/schemas/definitions/transaction-sign-request-base.d.ts

@@ -0,0 +1,15 @@
+import { TransactionSignRequest } from '@airgap/serializer';
+import { HexString } from '@airgap/serializer/v3/schemas/definitions/hex-string';
+import { BaseRawUnsignedTransaction } from '../../../../types/transaction';
+export interface SerializableBaseRawUnsignedTransaction extends Omit<BaseRawUnsignedTransaction, 'type' | 'ethereumType'> {
+    nonce: HexString;
+    gasPrice: HexString;
+    gasLimit: HexString;
+    to: HexString;
+    value: HexString;
+    chainId: number;
+    data: HexString;
+    l1DataFee: string;
+}
+export interface BaseTransactionSignRequest extends TransactionSignRequest<SerializableBaseRawUnsignedTransaction> {
+}

package/v1/serializer/v3/schemas/definitions/transaction-sign-request-base.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=transaction-sign-request-base.js.map

package/v1/serializer/v3/schemas/definitions/transaction-sign-request-base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-sign-request-base.js","sourceRoot":"","sources":["../../../../../../src/v1/serializer/v3/schemas/definitions/transaction-sign-request-base.ts"],"names":[],"mappings":""}

package/v1/serializer/v3/schemas/definitions/transaction-sign-response-base.d.ts

@@ -0,0 +1,3 @@
+import { EthereumTransactionSignResponse } from '@airgap/ethereum/v1';
+export interface BaseTransactionSignResponse extends EthereumTransactionSignResponse {
+}

package/v1/serializer/v3/schemas/definitions/transaction-sign-response-base.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=transaction-sign-response-base.js.map

package/v1/serializer/v3/schemas/definitions/transaction-sign-response-base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-sign-response-base.js","sourceRoot":"","sources":["../../../../../../src/v1/serializer/v3/schemas/definitions/transaction-sign-response-base.ts"],"names":[],"mappings":""}

package/v1/serializer/v3/schemas/generated/transaction-sign-request-base-typed.json

@@ -0,0 +1,39 @@
+{
+  "$ref": "#/definitions/BaseTypedTransactionSignRequest",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "HexString": {
+      "type": "string"
+    },
+    "BaseTypedTransactionSignRequest": {
+      "additionalProperties": false,
+      "properties": {
+        "callbackURL": {
+          "type": "string"
+        },
+        "publicKey": {
+          "type": "string"
+        },
+        "transaction": {
+          "additionalProperties": false,
+          "properties": {
+            "derivationPath": {
+              "type": "string"
+            },
+            "masterFingerprint": {
+              "type": "string"
+            },
+            "serialized": {
+              "$ref": "#/definitions/HexString",
+              "type": "string"
+            }
+          },
+          "required": ["derivationPath", "masterFingerprint", "serialized"],
+          "type": "object"
+        }
+      },
+      "required": ["publicKey", "transaction"],
+      "type": "object"
+    }
+  }
+}

package/v1/serializer/v3/schemas/generated/transaction-sign-request-base.json

@@ -0,0 +1,59 @@
+{
+  "$ref": "#/definitions/BaseTransactionSignRequest",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "HexString": {
+      "type": "string"
+    },
+    "BaseTransactionSignRequest": {
+      "additionalProperties": false,
+      "properties": {
+        "callbackURL": {
+          "type": "string"
+        },
+        "publicKey": {
+          "type": "string"
+        },
+        "transaction": {
+          "additionalProperties": false,
+          "properties": {
+            "chainId": {
+              "type": "number"
+            },
+            "data": {
+              "$ref": "#/definitions/HexString",
+              "type": "string"
+            },
+            "gasLimit": {
+              "$ref": "#/definitions/HexString",
+              "type": "string"
+            },
+            "gasPrice": {
+              "$ref": "#/definitions/HexString",
+              "type": "string"
+            },
+            "l1DataFee": {
+              "type": "string"
+            },
+            "nonce": {
+              "$ref": "#/definitions/HexString",
+              "type": "string"
+            },
+            "to": {
+              "$ref": "#/definitions/HexString",
+              "type": "string"
+            },
+            "value": {
+              "$ref": "#/definitions/HexString",
+              "type": "string"
+            }
+          },
+          "required": ["chainId", "data", "gasLimit", "gasPrice", "l1DataFee", "nonce", "to", "value"],
+          "type": "object"
+        }
+      },
+      "required": ["publicKey", "transaction"],
+      "type": "object"
+    }
+  }
+}

package/v1/serializer/v3/schemas/generated/transaction-sign-response-base.json

@@ -0,0 +1,19 @@
+{
+  "$ref": "#/definitions/BaseTransactionSignResponse",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "BaseTransactionSignResponse": {
+      "additionalProperties": false,
+      "properties": {
+        "accountIdentifier": {
+          "type": "string"
+        },
+        "transaction": {
+          "type": "string"
+        }
+      },
+      "required": ["accountIdentifier", "transaction"],
+      "type": "object"
+    }
+  }
+}

package/v1/serializer/v3/serializer-companion.d.ts

@@ -0,0 +1,13 @@
+import { AirGapV3SerializerCompanion, SignedTransaction, UnsignedTransaction } from '@airgap/module-kit';
+import { V3SchemaConfiguration } from '@airgap/module-kit/types/serializer';
+import { TransactionSignRequest, TransactionSignResponse } from '@airgap/serializer';
+export declare class BaseV3SerializerCompanion implements AirGapV3SerializerCompanion {
+    readonly schemas: V3SchemaConfiguration[];
+    private readonly ethereumTransactionValidator;
+    toTransactionSignRequest(identifier: string, unsignedTransaction: UnsignedTransaction, publicKey: string, callbackUrl?: string): Promise<TransactionSignRequest>;
+    fromTransactionSignRequest(identifier: string, transactionSignRequest: TransactionSignRequest): Promise<UnsignedTransaction>;
+    validateTransactionSignRequest(identifier: string, transactionSignRequest: TransactionSignRequest): Promise<boolean>;
+    toTransactionSignResponse(identifier: string, signedTransaction: SignedTransaction, accountIdentifier: string): Promise<TransactionSignResponse>;
+    fromTransactionSignResponse(identifier: string, transactionSignResponse: TransactionSignResponse): Promise<SignedTransaction>;
+    validateTransactionSignResponse(identifier: string, transactionSignResponse: TransactionSignResponse): Promise<boolean>;
+}