@wallfree-dev/ethereum 0.13.42

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

@@ -0,0 +1,82 @@
+"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 __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.ethereumTransactionSignResponseToSigned = exports.ethereumTransactionSignRequestToUnsigned = exports.ethereumSignedTransactionToResponse = exports.ethereumUnsignedTransactionToRequest = void 0;
+var module_kit_1 = require("@wallfree-dev/module-kit");
+function isEthereumTypedTransactionSignRequest(request) {
+    return (0, module_kit_1.implementsInterface)(request.transaction, {
+        derivationPath: 'required',
+        masterFingerprint: 'required',
+        serialized: 'required'
+    });
+}
+function ethereumUnsignedTransactionToRequest(unsigned, publicKey, callbackUrl) {
+    return unsigned.ethereumType === 'raw'
+        ? ethereumRawUnsignedTransactionToRequest(unsigned, publicKey, callbackUrl)
+        : ethereumTypedUnsignedTransactionToRequest(unsigned, publicKey, callbackUrl);
+}
+exports.ethereumUnsignedTransactionToRequest = ethereumUnsignedTransactionToRequest;
+function ethereumRawUnsignedTransactionToRequest(unsigned, publicKey, callbackUrl) {
+    var _ = unsigned.type, to = unsigned.to, rest = __rest(unsigned, ["type", "to"]);
+    var toHEX = Buffer.from(to, 'utf-8').toString('hex');
+    var transaction = __assign(__assign({}, rest), { to: toHEX });
+    return {
+        transaction: transaction,
+        publicKey: publicKey,
+        callbackURL: callbackUrl
+    };
+}
+function ethereumTypedUnsignedTransactionToRequest(unsigned, publicKey, callbackUrl) {
+    var _ = unsigned.type, rest = __rest(unsigned, ["type"]);
+    return {
+        transaction: rest,
+        publicKey: publicKey,
+        callbackURL: callbackUrl
+    };
+}
+function ethereumSignedTransactionToResponse(signed, accountIdentifier) {
+    return { transaction: signed.serialized, accountIdentifier: accountIdentifier };
+}
+exports.ethereumSignedTransactionToResponse = ethereumSignedTransactionToResponse;
+function ethereumTransactionSignRequestToUnsigned(request) {
+    return isEthereumTypedTransactionSignRequest(request)
+        ? ethereumTransactionSignRequestToTypedUnsigned(request)
+        : ethereumTransactionSignRequestToRawUnsigned(request);
+}
+exports.ethereumTransactionSignRequestToUnsigned = ethereumTransactionSignRequestToUnsigned;
+function ethereumTransactionSignRequestToRawUnsigned(request) {
+    var _a = request.transaction, to = _a.to, rest = __rest(_a, ["to"]);
+    var isStringAddress = /^0x[0-9a-fA-F]{40}$/.test(to);
+    var toUTF8 = Buffer.from(to, 'hex').toString('utf-8');
+    var transaction = __assign(__assign({}, rest), { to: isStringAddress ? to : toUTF8 });
+    return (0, module_kit_1.newUnsignedTransaction)(__assign({ ethereumType: 'raw' }, transaction));
+}
+function ethereumTransactionSignRequestToTypedUnsigned(request) {
+    return (0, module_kit_1.newUnsignedTransaction)(__assign({ ethereumType: 'typed' }, request.transaction));
+}
+function ethereumTransactionSignResponseToSigned(response) {
+    return (0, module_kit_1.newSignedTransaction)({ serialized: response.transaction });
+}
+exports.ethereumTransactionSignResponseToSigned = ethereumTransactionSignResponseToSigned;
+//# 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":"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"}

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

@@ -0,0 +1,10 @@
+import { TransactionSignRequest } from '@wallfree-dev/serializer';
+import { HexString } from '@wallfree-dev/serializer/v3/schemas/definitions/hex-string';
+import { EthereumTypedUnsignedTransaction } from '../../../../types/transaction';
+export interface SerializableEthereumTypedUnsignedTransaction extends Omit<EthereumTypedUnsignedTransaction, 'type' | 'ethereumType'> {
+    serialized: HexString;
+    derivationPath: string;
+    masterFingerprint: string;
+}
+export interface EthereumTypedTransactionSignRequest extends TransactionSignRequest<SerializableEthereumTypedUnsignedTransaction> {
+}

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

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

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

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

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

@@ -0,0 +1,14 @@
+import { TransactionSignRequest } from '@wallfree-dev/serializer';
+import { HexString } from '@wallfree-dev/serializer/v3/schemas/definitions/hex-string';
+import { EthereumRawUnsignedTransaction } from '../../../../types/transaction';
+export interface SerializableEthereumRawUnsignedTransaction extends Omit<EthereumRawUnsignedTransaction, 'type' | 'ethereumType'> {
+    nonce: HexString;
+    gasPrice: HexString;
+    gasLimit: HexString;
+    to: HexString;
+    value: HexString;
+    chainId: number;
+    data: HexString;
+}
+export interface EthereumTransactionSignRequest extends TransactionSignRequest<SerializableEthereumRawUnsignedTransaction> {
+}

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

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

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

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

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

@@ -0,0 +1,3 @@
+import { TransactionSignResponse } from '@wallfree-dev/serializer';
+export interface EthereumTransactionSignResponse extends TransactionSignResponse {
+}

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

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

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

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

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

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

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

@@ -0,0 +1,58 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "EthereumTransactionSignRequest": {
+      "additionalProperties": false,
+      "properties": {
+        "callbackURL": {
+          "type": "string"
+        },
+        "publicKey": {
+          "type": "string"
+        },
+        "transaction": {
+          "$ref": "#/definitions/SerializableEthereumRawUnsignedTransaction"
+        }
+      },
+      "required": ["publicKey", "transaction"],
+      "type": "object"
+    },
+    "HexString": {
+      "type": "string"
+    },
+    "SerializableEthereumRawUnsignedTransaction": {
+      "additionalProperties": false,
+      "properties": {
+        "chainId": {
+          "type": "number"
+        },
+        "data": {
+          "$ref": "#/definitions/HexString",
+          "type": "string"
+        },
+        "gasLimit": {
+          "$ref": "#/definitions/HexString",
+          "type": "string"
+        },
+        "gasPrice": {
+          "$ref": "#/definitions/HexString",
+          "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", "nonce", "to", "value"],
+      "type": "object"
+    }
+  }
+}

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

@@ -0,0 +1,19 @@
+{
+  "$ref": "#/definitions/EthereumTransactionSignResponse",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "EthereumTransactionSignResponse": {
+      "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 '@wallfree-dev/module-kit';
+import { V3SchemaConfiguration } from '@wallfree-dev/module-kit/types/serializer';
+import { TransactionSignRequest, TransactionSignResponse } from '@wallfree-dev/serializer';
+export declare class EthereumV3SerializerCompanion 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>;
+}

package/v1/serializer/v3/serializer-companion.js

@@ -0,0 +1,182 @@
+"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.EthereumV3SerializerCompanion = void 0;
+var coinlib_core_1 = require("@wallfree-dev/coinlib-core");
+var errors_1 = require("@wallfree-dev/coinlib-core/errors");
+var serializer_1 = require("@wallfree-dev/serializer");
+var transaction_converter_1 = require("./schemas/converter/transaction-converter");
+var transaction_validator_1 = require("./validators/transaction-validator");
+var ethereumTransactionSignRequest = require('./schemas/generated/transaction-sign-request-ethereum.json');
+var ethereumTypedTransactionSignRequest = require('./schemas/generated/transaction-sign-request-ethereum-typed.json');
+var ethereumTransactionSignResponse = require('./schemas/generated/transaction-sign-response-ethereum.json');
+var EthereumV3SerializerCompanion = /** @class */ (function () {
+    function EthereumV3SerializerCompanion() {
+        this.schemas = [
+            {
+                type: serializer_1.IACMessageType.TransactionSignRequest,
+                schema: { schema: ethereumTransactionSignRequest },
+                protocolIdentifier: coinlib_core_1.MainProtocolSymbols.ETH
+            },
+            {
+                type: serializer_1.IACMessageType.TransactionSignRequest,
+                schema: { schema: ethereumTypedTransactionSignRequest },
+                protocolIdentifier: coinlib_core_1.MainProtocolSymbols.ETH
+            },
+            {
+                type: serializer_1.IACMessageType.TransactionSignResponse,
+                schema: { schema: ethereumTransactionSignResponse },
+                protocolIdentifier: coinlib_core_1.MainProtocolSymbols.ETH
+            },
+            {
+                type: serializer_1.IACMessageType.TransactionSignRequest,
+                schema: { schema: ethereumTransactionSignRequest },
+                protocolIdentifier: coinlib_core_1.SubProtocolSymbols.ETH_ERC20
+            },
+            {
+                type: serializer_1.IACMessageType.TransactionSignResponse,
+                schema: { schema: ethereumTransactionSignResponse },
+                protocolIdentifier: coinlib_core_1.SubProtocolSymbols.ETH_ERC20
+            }
+        ];
+        this.ethereumTransactionValidator = new transaction_validator_1.EthereumTransactionValidator();
+    }
+    EthereumV3SerializerCompanion.prototype.toTransactionSignRequest = function (identifier, unsignedTransaction, publicKey, callbackUrl) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (identifier === coinlib_core_1.MainProtocolSymbols.ETH || identifier.startsWith(coinlib_core_1.SubProtocolSymbols.ETH_ERC20)) {
+                    return [2 /*return*/, (0, transaction_converter_1.ethereumUnsignedTransactionToRequest)(unsignedTransaction, publicKey, callbackUrl)];
+                }
+                else {
+                    throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ETHEREUM, "Protocol ".concat(identifier, " not supported"));
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    EthereumV3SerializerCompanion.prototype.fromTransactionSignRequest = function (identifier, transactionSignRequest) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (identifier === coinlib_core_1.MainProtocolSymbols.ETH || identifier.startsWith(coinlib_core_1.SubProtocolSymbols.ETH_ERC20)) {
+                    return [2 /*return*/, (0, transaction_converter_1.ethereumTransactionSignRequestToUnsigned)(transactionSignRequest)];
+                }
+                else {
+                    throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ETHEREUM, "Protocol ".concat(identifier, " not supported"));
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    EthereumV3SerializerCompanion.prototype.validateTransactionSignRequest = function (identifier, transactionSignRequest) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(identifier === coinlib_core_1.MainProtocolSymbols.ETH || identifier.startsWith(coinlib_core_1.SubProtocolSymbols.ETH_ERC20))) return [3 /*break*/, 5];
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.ethereumTransactionValidator.validateUnsignedTransaction(transactionSignRequest)];
+                    case 2:
+                        _b.sent();
+                        return [2 /*return*/, true];
+                    case 3:
+                        _a = _b.sent();
+                        return [2 /*return*/, false];
+                    case 4: return [3 /*break*/, 6];
+                    case 5: throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ETHEREUM, "Protocol ".concat(identifier, " not supported"));
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EthereumV3SerializerCompanion.prototype.toTransactionSignResponse = function (identifier, signedTransaction, accountIdentifier) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (identifier === coinlib_core_1.MainProtocolSymbols.ETH || identifier.startsWith(coinlib_core_1.SubProtocolSymbols.ETH_ERC20)) {
+                    return [2 /*return*/, (0, transaction_converter_1.ethereumSignedTransactionToResponse)(signedTransaction, accountIdentifier)];
+                }
+                else {
+                    throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ETHEREUM, "Protocol ".concat(identifier, " not supported"));
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    EthereumV3SerializerCompanion.prototype.fromTransactionSignResponse = function (identifier, transactionSignResponse) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (identifier === coinlib_core_1.MainProtocolSymbols.ETH || identifier.startsWith(coinlib_core_1.SubProtocolSymbols.ETH_ERC20)) {
+                    return [2 /*return*/, (0, transaction_converter_1.ethereumTransactionSignResponseToSigned)(transactionSignResponse)];
+                }
+                else {
+                    throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ETHEREUM, "Protocol ".concat(identifier, " not supported"));
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    EthereumV3SerializerCompanion.prototype.validateTransactionSignResponse = function (identifier, transactionSignResponse) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(identifier === coinlib_core_1.MainProtocolSymbols.ETH || identifier.startsWith(coinlib_core_1.SubProtocolSymbols.ETH_ERC20))) return [3 /*break*/, 5];
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.ethereumTransactionValidator.validateSignedTransaction(transactionSignResponse)];
+                    case 2:
+                        _b.sent();
+                        return [2 /*return*/, true];
+                    case 3:
+                        _a = _b.sent();
+                        return [2 /*return*/, false];
+                    case 4: return [3 /*break*/, 6];
+                    case 5: throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ETHEREUM, "Protocol ".concat(identifier, " not supported"));
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return EthereumV3SerializerCompanion;
+}());
+exports.EthereumV3SerializerCompanion = EthereumV3SerializerCompanion;
+//# sourceMappingURL=serializer-companion.js.map

package/v1/serializer/v3/serializer-companion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer-companion.js","sourceRoot":"","sources":["../../../../src/v1/serializer/v3/serializer-companion.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2DAA4F;AAC5F,4DAAoE;AAGpE,uDAAsH;AAItH,mFAKkD;AAClD,4EAAiF;AAEjF,IAAM,8BAA8B,GAAe,OAAO,CAAC,4DAA4D,CAAC,CAAA;AACxH,IAAM,mCAAmC,GAAe,OAAO,CAAC,kEAAkE,CAAC,CAAA;AACnI,IAAM,+BAA+B,GAAe,OAAO,CAAC,6DAA6D,CAAC,CAAA;AAE1H;IAAA;QACkB,YAAO,GAA4B;YACjD;gBACE,IAAI,EAAE,2BAAc,CAAC,sBAAsB;gBAC3C,MAAM,EAAE,EAAE,MAAM,EAAE,8BAA8B,EAAE;gBAClD,kBAAkB,EAAE,kCAAmB,CAAC,GAAG;aAC5C;YACD;gBACE,IAAI,EAAE,2BAAc,CAAC,sBAAsB;gBAC3C,MAAM,EAAE,EAAE,MAAM,EAAE,mCAAmC,EAAE;gBACvD,kBAAkB,EAAE,kCAAmB,CAAC,GAAG;aAC5C;YACD;gBACE,IAAI,EAAE,2BAAc,CAAC,uBAAuB;gBAC5C,MAAM,EAAE,EAAE,MAAM,EAAE,+BAA+B,EAAE;gBACnD,kBAAkB,EAAE,kCAAmB,CAAC,GAAG;aAC5C;YACD;gBACE,IAAI,EAAE,2BAAc,CAAC,sBAAsB;gBAC3C,MAAM,EAAE,EAAE,MAAM,EAAE,8BAA8B,EAAE;gBAClD,kBAAkB,EAAE,iCAAkB,CAAC,SAAS;aACjD;YACD;gBACE,IAAI,EAAE,2BAAc,CAAC,uBAAuB;gBAC5C,MAAM,EAAE,EAAE,MAAM,EAAE,+BAA+B,EAAE;gBACnD,kBAAkB,EAAE,iCAAkB,CAAC,SAAS;aACjD;SACF,CAAA;QAEgB,iCAA4B,GAAiC,IAAI,oDAA4B,EAAE,CAAA;IA4ElH,CAAC;IA1Ec,gEAAwB,GAArC,UACE,UAAkB,EAClB,mBAAwC,EACxC,SAAiB,EACjB,WAAoB;;;gBAEpB,IAAI,UAAU,KAAK,kCAAmB,CAAC,GAAG,IAAI,UAAU,CAAC,UAAU,CAAC,iCAAkB,CAAC,SAAS,CAAC,EAAE;oBACjG,sBAAO,IAAA,4DAAoC,EAAC,mBAAkD,EAAE,SAAS,EAAE,WAAW,CAAC,EAAA;iBACxH;qBAAM;oBACL,MAAM,IAAI,yBAAgB,CAAC,qBAAM,CAAC,QAAQ,EAAE,mBAAY,UAAU,mBAAgB,CAAC,CAAA;iBACpF;;;;KACF;IAEY,kEAA0B,GAAvC,UACE,UAAkB,EAClB,sBAA8C;;;gBAE9C,IAAI,UAAU,KAAK,kCAAmB,CAAC,GAAG,IAAI,UAAU,CAAC,UAAU,CAAC,iCAAkB,CAAC,SAAS,CAAC,EAAE;oBACjG,sBAAO,IAAA,gEAAwC,EAAC,sBAAsB,CAAC,EAAA;iBACxE;qBAAM;oBACL,MAAM,IAAI,yBAAgB,CAAC,qBAAM,CAAC,QAAQ,EAAE,mBAAY,UAAU,mBAAgB,CAAC,CAAA;iBACpF;;;;KACF;IAEY,sEAA8B,GAA3C,UAA4C,UAAkB,EAAE,sBAA8C;;;;;;6BACxG,CAAA,UAAU,KAAK,kCAAmB,CAAC,GAAG,IAAI,UAAU,CAAC,UAAU,CAAC,iCAAkB,CAAC,SAAS,CAAC,CAAA,EAA7F,wBAA6F;;;;wBAE7F,qBAAM,IAAI,CAAC,4BAA4B,CAAC,2BAA2B,CAAC,sBAAsB,CAAC,EAAA;;wBAA3F,SAA2F,CAAA;wBAE3F,sBAAO,IAAI,EAAA;;;wBAEX,sBAAO,KAAK,EAAA;;4BAGd,MAAM,IAAI,yBAAgB,CAAC,qBAAM,CAAC,QAAQ,EAAE,mBAAY,UAAU,mBAAgB,CAAC,CAAA;;;;;KAEtF;IAEY,iEAAyB,GAAtC,UACE,UAAkB,EAClB,iBAAoC,EACpC,iBAAyB;;;gBAEzB,IAAI,UAAU,KAAK,kCAAmB,CAAC,GAAG,IAAI,UAAU,CAAC,UAAU,CAAC,iCAAkB,CAAC,SAAS,CAAC,EAAE;oBACjG,sBAAO,IAAA,2DAAmC,EAAC,iBAA8C,EAAE,iBAAiB,CAAC,EAAA;iBAC9G;qBAAM;oBACL,MAAM,IAAI,yBAAgB,CAAC,qBAAM,CAAC,QAAQ,EAAE,mBAAY,UAAU,mBAAgB,CAAC,CAAA;iBACpF;;;;KACF;IAEY,mEAA2B,GAAxC,UACE,UAAkB,EAClB,uBAAgD;;;gBAEhD,IAAI,UAAU,KAAK,kCAAmB,CAAC,GAAG,IAAI,UAAU,CAAC,UAAU,CAAC,iCAAkB,CAAC,SAAS,CAAC,EAAE;oBACjG,sBAAO,IAAA,+DAAuC,EAAC,uBAAuB,CAAC,EAAA;iBACxE;qBAAM;oBACL,MAAM,IAAI,yBAAgB,CAAC,qBAAM,CAAC,QAAQ,EAAE,mBAAY,UAAU,mBAAgB,CAAC,CAAA;iBACpF;;;;KACF;IAEY,uEAA+B,GAA5C,UAA6C,UAAkB,EAAE,uBAAgD;;;;;;6BAC3G,CAAA,UAAU,KAAK,kCAAmB,CAAC,GAAG,IAAI,UAAU,CAAC,UAAU,CAAC,iCAAkB,CAAC,SAAS,CAAC,CAAA,EAA7F,wBAA6F;;;;wBAE7F,qBAAM,IAAI,CAAC,4BAA4B,CAAC,yBAAyB,CAAC,uBAAuB,CAAC,EAAA;;wBAA1F,SAA0F,CAAA;wBAE1F,sBAAO,IAAI,EAAA;;;wBAEX,sBAAO,KAAK,EAAA;;4BAGd,MAAM,IAAI,yBAAgB,CAAC,qBAAM,CAAC,QAAQ,EAAE,mBAAY,UAAU,mBAAgB,CAAC,CAAA;;;;;KAEtF;IACH,oCAAC;AAAD,CAAC,AAzGD,IAyGC;AAzGY,sEAA6B"}

package/v1/serializer/v3/validators/transaction-validator.d.ts

@@ -0,0 +1,7 @@
+import { TransactionValidator, TransactionValidatorV2 } from '@wallfree-dev/serializer';
+import { EthereumTransactionSignRequest } from '../schemas/definitions/transaction-sign-request-ethereum';
+import { EthereumTransactionSignResponse } from '../schemas/definitions/transaction-sign-response-ethereum';
+export declare class EthereumTransactionValidator implements TransactionValidator, TransactionValidatorV2 {
+    validateUnsignedTransaction(request: EthereumTransactionSignRequest): Promise<any>;
+    validateSignedTransaction(signedTx: EthereumTransactionSignResponse): any;
+}

package/v1/serializer/v3/validators/transaction-validator.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EthereumTransactionValidator = void 0;
+// tslint:disable: max-classes-per-file
+var validate_1 = require("@wallfree-dev/coinlib-core/dependencies/src/validate.js-0.13.1/validate");
+var serializer_1 = require("@wallfree-dev/serializer");
+var unsignedTransactionConstraints = {
+    nonce: {
+        presence: { allowEmpty: false },
+        type: 'String',
+        isHexStringWithPrefix: true
+    },
+    gasPrice: {
+        presence: { allowEmpty: false },
+        type: 'String',
+        isHexStringWithPrefix: true
+    },
+    gasLimit: {
+        presence: { allowEmpty: false },
+        type: 'String',
+        isHexStringWithPrefix: true
+    },
+    to: {
+        presence: { allowEmpty: false },
+        type: 'String',
+        isHexStringWithPrefix: true,
+        format: {
+            pattern: '^0x[a-fA-F0-9]{40}$',
+            flags: 'i',
+            message: 'is not a valid ethereum address'
+        }
+    },
+    value: {
+        presence: { allowEmpty: false },
+        type: 'String',
+        isHexStringWithPrefix: true
+    },
+    chainId: {
+        presence: { allowEmpty: false },
+        numericality: { noStrings: true, onlyInteger: true, greaterThanOrEqualTo: 0 }
+    },
+    data: {
+        presence: { allowEmpty: false },
+        type: 'String',
+        isHexStringWithPrefix: true
+    }
+};
+var signedTransactionConstraints = {
+    transaction: {
+        presence: { allowEmpty: false },
+        type: 'String',
+        isValidEthereumTransactionString: true
+    }
+};
+var success = function () { return undefined; };
+var error = function (errors) { return errors; };
+var EthereumTransactionValidator = /** @class */ (function () {
+    function EthereumTransactionValidator() {
+    }
+    EthereumTransactionValidator.prototype.validateUnsignedTransaction = function (request) {
+        var transaction = request.transaction;
+        (0, serializer_1.validateSyncScheme)({});
+        return (0, validate_1.async)(transaction, unsignedTransactionConstraints).then(success, error);
+    };
+    EthereumTransactionValidator.prototype.validateSignedTransaction = function (signedTx) {
+        return (0, validate_1.async)(signedTx, signedTransactionConstraints).then(success, error);
+    };
+    return EthereumTransactionValidator;
+}());
+exports.EthereumTransactionValidator = EthereumTransactionValidator;
+//# sourceMappingURL=transaction-validator.js.map

package/v1/serializer/v3/validators/transaction-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-validator.js","sourceRoot":"","sources":["../../../../../src/v1/serializer/v3/validators/transaction-validator.ts"],"names":[],"mappings":";;;AAAA,uCAAuC;AACvC,oGAA+F;AAC/F,uDAA2G;AAK3G,IAAM,8BAA8B,GAAG;IACrC,KAAK,EAAE;QACL,QAAQ,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE;QAC/B,IAAI,EAAE,QAAQ;QACd,qBAAqB,EAAE,IAAI;KAC5B;IACD,QAAQ,EAAE;QACR,QAAQ,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE;QAC/B,IAAI,EAAE,QAAQ;QACd,qBAAqB,EAAE,IAAI;KAC5B;IACD,QAAQ,EAAE;QACR,QAAQ,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE;QAC/B,IAAI,EAAE,QAAQ;QACd,qBAAqB,EAAE,IAAI;KAC5B;IACD,EAAE,EAAE;QACF,QAAQ,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE;QAC/B,IAAI,EAAE,QAAQ;QACd,qBAAqB,EAAE,IAAI;QAC3B,MAAM,EAAE;YACN,OAAO,EAAE,qBAAqB;YAC9B,KAAK,EAAE,GAAG;YACV,OAAO,EAAE,iCAAiC;SAC3C;KACF;IACD,KAAK,EAAE;QACL,QAAQ,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE;QAC/B,IAAI,EAAE,QAAQ;QACd,qBAAqB,EAAE,IAAI;KAC5B;IACD,OAAO,EAAE;QACP,QAAQ,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE;QAC/B,YAAY,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,oBAAoB,EAAE,CAAC,EAAE;KAC9E;IACD,IAAI,EAAE;QACJ,QAAQ,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE;QAC/B,IAAI,EAAE,QAAQ;QACd,qBAAqB,EAAE,IAAI;KAC5B;CACF,CAAA;AAED,IAAM,4BAA4B,GAAG;IACnC,WAAW,EAAE;QACX,QAAQ,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE;QAC/B,IAAI,EAAE,QAAQ;QACd,gCAAgC,EAAE,IAAI;KACvC;CACF,CAAA;AACD,IAAM,OAAO,GAAG,cAAM,OAAA,SAAS,EAAT,CAAS,CAAA;AAC/B,IAAM,KAAK,GAAG,UAAC,MAAW,IAAK,OAAA,MAAM,EAAN,CAAM,CAAA;AAErC;IAAA;IAUA,CAAC;IATQ,kEAA2B,GAAlC,UAAmC,OAAuC;QACxE,IAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAA;QACvC,IAAA,+BAAkB,EAAC,EAAE,CAAC,CAAA;QAEtB,OAAO,IAAA,gBAAK,EAAC,WAAW,EAAE,8BAA8B,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;IAChF,CAAC;IACM,gEAAyB,GAAhC,UAAiC,QAAyC;QACxE,OAAO,IAAA,gBAAK,EAAC,QAAQ,EAAE,4BAA4B,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;IAC3E,CAAC;IACH,mCAAC;AAAD,CAAC,AAVD,IAUC;AAVY,oEAA4B"}

package/v1/types/crypto.d.ts

@@ -0,0 +1,2 @@
+import { Secp256K1CryptoConfiguration } from '@wallfree-dev/module-kit';
+export declare type EthereumCryptoConfiguration = Secp256K1CryptoConfiguration;

package/v1/types/crypto.js

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

package/v1/types/crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.js","sourceRoot":"","sources":["../../../src/v1/types/crypto.ts"],"names":[],"mappings":""}

package/v1/types/protocol.d.ts

@@ -0,0 +1,35 @@
+import { FeeDefaults, ProtocolNetwork, ProtocolUnitsMetadata } from '@wallfree-dev/module-kit';
+export declare type EthereumUnits = 'ETH' | 'GWEI' | 'WEI';
+export interface EthereumProtocolNetwork extends ProtocolNetwork {
+    chainId: number;
+    blockExplorerApi: string;
+}
+export interface EthereumProtocolOptions<_ProtocolNetwork extends EthereumProtocolNetwork = EthereumProtocolNetwork> {
+    network: _ProtocolNetwork;
+}
+export interface EthereumBaseProtocolOptions<_Units extends string = EthereumUnits, _ProtocolNetwork extends EthereumProtocolNetwork = EthereumProtocolNetwork> extends EthereumProtocolOptions<_ProtocolNetwork> {
+    identifier: string;
+    name: string;
+    units: ProtocolUnitsMetadata<_Units>;
+    mainUnit: _Units;
+    feeDefaults?: FeeDefaults<EthereumUnits>;
+    standardDerivationPath?: string;
+}
+export interface ERC20ProtocolOptions<_Units extends string, _ProtocolNetwork extends EthereumProtocolNetwork = EthereumProtocolNetwork> extends EthereumProtocolOptions<_ProtocolNetwork> {
+    name: string;
+    identifier: string;
+    contractAddress: string;
+    units: ProtocolUnitsMetadata<_Units>;
+    mainUnit: _Units;
+}
+export interface ERC20TokenOptions<_ProtocolNetwork extends EthereumProtocolNetwork = EthereumProtocolNetwork> extends ERC20ProtocolOptions<string, _ProtocolNetwork> {
+    mainIdentifier: string;
+}
+export interface ERC20TokenMetadata {
+    name: string;
+    identifier: string;
+    symbol: string;
+    marketSymbol: string;
+    contractAddress: string;
+    decimals: number;
+}

package/v1/types/protocol.js

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

package/v1/types/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../../src/v1/types/protocol.ts"],"names":[],"mappings":""}

package/v1/types/transaction.d.ts

@@ -0,0 +1,24 @@
+import { SignedTransaction, TransactionCursor, UnsignedTransaction } from '@wallfree-dev/module-kit';
+export interface EthereumRawUnsignedTransaction extends UnsignedTransaction {
+    ethereumType: 'raw';
+    nonce: string;
+    gasPrice: string;
+    gasLimit: string;
+    to: string;
+    value: string;
+    chainId: number;
+    data: string;
+}
+export interface EthereumTypedUnsignedTransaction extends UnsignedTransaction {
+    ethereumType: 'typed';
+    serialized: string;
+    derivationPath: string;
+    masterFingerprint: string;
+}
+export declare type EthereumUnsignedTransaction = EthereumRawUnsignedTransaction | EthereumTypedUnsignedTransaction;
+export interface EthereumSignedTransaction extends SignedTransaction {
+    serialized: string;
+}
+export interface EthereumTransactionCursor extends TransactionCursor {
+    page?: number;
+}