@wallfree-dev/evmc 0.13.42

package/v1/protocol/erc20/ERC20Token.js

@@ -0,0 +1,134 @@
+"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 __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.createERC20Token = exports.ERC20TokenImpl = void 0;
+var EtherscanInfoClient_1 = require("@wallfree-dev/ethereum/v1/clients/info/EtherscanInfoClient");
+var HttpEthereumNodeClient_1 = require("@wallfree-dev/ethereum/v1/clients/node/HttpEthereumNodeClient");
+var ERC20Protocol_1 = require("./ERC20Protocol");
+// Implementation
+var ERC20TokenImpl = /** @class */ (function (_super) {
+    __extends(ERC20TokenImpl, _super);
+    function ERC20TokenImpl(nodeClient, infoClient, options) {
+        var _this = _super.call(this, nodeClient, infoClient, options) || this;
+        _this._mainProtocol = options.mainIdentifier;
+        return _this;
+    }
+    // SubProtocol
+    ERC20TokenImpl.prototype.getType = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, 'token'];
+            });
+        });
+    };
+    ERC20TokenImpl.prototype.mainProtocol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this._mainProtocol];
+            });
+        });
+    };
+    ERC20TokenImpl.prototype.getContractAddress = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.contractAddress];
+            });
+        });
+    };
+    return ERC20TokenImpl;
+}(ERC20Protocol_1.ERC20ProtocolImpl));
+exports.ERC20TokenImpl = ERC20TokenImpl;
+// Factory
+// type ERC20TokenOptionsWithoutMetadata = Omit<
+//   ERC20TokenOptions,
+//   'name' | 'identifier' | 'contractAddress' | 'symbol' | 'marketSymbol' | 'decimals'
+// >
+function createERC20Token(
+// metadata: ERC20TokenMetadata,
+// options: RecursivePartial<ERC20TokenOptionsWithoutMetadata> = {}
+completeOptions) {
+    // const completeOptions: ERC20TokenOptions = createERC20TokenOptions(metadata, options.network, options.mainIdentifier)
+    return new ERC20TokenImpl(new HttpEthereumNodeClient_1.HttpEthereumNodeClient(completeOptions.network.rpcUrl), new EtherscanInfoClient_1.EtherscanInfoClient(completeOptions.network.blockExplorerApi), completeOptions);
+}
+exports.createERC20Token = createERC20Token;
+// export const CONFLUX_ERC20_MAINNET_PROTOCOL_NETWORK: EvmcProtocolNetwork = {
+//   // ...CONFLUX_MAINNET_PROTOCOL_NETWORK
+//   name: 'Conflux eSpace (Hydra)',
+//   type: 'mainnet',
+//   chainId: 1030,
+//   rpcUrl: 'https://evm.confluxrpc.com',
+//   blockExplorerUrl: 'https://evm.confluxscan.org',
+//   blockExplorerApi: 'https://evmapi.confluxscan.org'
+// }
+// const DEFAULT_ERC20_PROTOCOL_NETWORK: EvmcProtocolNetwork = CONFLUX_ERC20_MAINNET_PROTOCOL_NETWORK
+// export function createERC20TokenOptions(
+//   metadata: ERC20TokenMetadata,
+//   network: Partial<EvmcProtocolNetwork> = {},
+//   mainIdentifier?: string
+// ): ERC20TokenOptions {
+//   return {
+//     network: { ...DEFAULT_ERC20_PROTOCOL_NETWORK, ...network },
+//     name: metadata.name,
+//     identifier: metadata.identifier,
+//     mainIdentifier: mainIdentifier ?? MainProtocolSymbols.CONFLUX,
+//     contractAddress: metadata.contractAddress,
+//     units: {
+//       [metadata.symbol]: {
+//         symbol: { value: metadata.symbol, market: metadata.marketSymbol },
+//         decimals: metadata.decimals
+//       }
+//     },
+//     mainUnit: metadata.symbol
+//   }
+// }
+//# 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,kGAAgG;AAChG,wGAAsG;AAItG,iDAAkE;AAOlE,iBAAiB;AAEjB;IACU,kCAA2C;IAGnD,wBAAmB,UAA8B,EAAE,UAA8B,EAAE,OAA4C;QAA/H,YACE,kBAAM,UAAU,EAAE,UAAU,EAAE,OAAO,CAAC,SAGvC;QADC,KAAI,CAAC,aAAa,GAAG,OAAO,CAAC,cAAc,CAAA;;IAC7C,CAAC;IAED,cAAc;IAED,gCAAO,GAApB;;;gBACE,sBAAO,OAAO,EAAA;;;KACf;IAGY,qCAAY,GAAzB;;;gBACE,sBAAO,IAAI,CAAC,aAAa,EAAA;;;KAC1B;IAEY,2CAAkB,GAA/B;;;gBACE,sBAAO,IAAI,CAAC,eAAe,EAAA;;;KAC5B;IACH,qBAAC;AAAD,CAAC,AAxBD,CACU,iCAAiB,GAuB1B;AAxBY,wCAAc;AA0B3B,UAAU;AAEV,gDAAgD;AAChD,uBAAuB;AACvB,uFAAuF;AACvF,IAAI;AAEJ,SAAgB,gBAAgB;AAC9B,gCAAgC;AAChC,mEAAmE;AACnE,eAAkC;IAElC,wHAAwH;IAExH,OAAO,IAAI,cAAc,CACvB,IAAI,+CAAsB,CAAC,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,EAC1D,IAAI,yCAAmB,CAAC,eAAe,CAAC,OAAO,CAAC,gBAAgB,CAAC,EACjE,eAAe,CAChB,CAAA;AACH,CAAC;AAZD,4CAYC;AAED,+EAA+E;AAC/E,2CAA2C;AAC3C,oCAAoC;AACpC,qBAAqB;AACrB,mBAAmB;AACnB,0CAA0C;AAC1C,qDAAqD;AACrD,uDAAuD;AACvD,IAAI;AAEJ,qGAAqG;AAErG,2CAA2C;AAC3C,kCAAkC;AAClC,gDAAgD;AAChD,4BAA4B;AAC5B,yBAAyB;AACzB,aAAa;AACb,kEAAkE;AAClE,2BAA2B;AAC3B,uCAAuC;AACvC,qEAAqE;AAErE,iDAAiD;AAEjD,eAAe;AACf,6BAA6B;AAC7B,6EAA6E;AAC7E,sCAAsC;AACtC,UAAU;AACV,SAAS;AACT,gCAAgC;AAChC,MAAM;AACN,IAAI"}

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

@@ -0,0 +1,39 @@
+{
+  "$ref": "#/definitions/EthereumTypedTransactionSignRequest",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "EthereumTypedTransactionSignRequest": {
+      "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"
+    },
+    "HexString": {
+      "type": "string"
+    }
+  }
+}

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

@@ -0,0 +1,56 @@
+{
+  "$ref": "#/definitions/EthereumTransactionSignRequest",
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "EthereumTransactionSignRequest": {
+      "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"
+            },
+            "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"
+        }
+      },
+      "required": ["publicKey", "transaction"],
+      "type": "object"
+    },
+    "HexString": {
+      "type": "string"
+    }
+  }
+}

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,16 @@
+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 EvmcV3SerializerCompanion implements AirGapV3SerializerCompanion {
+    private readonly protocolIdentifier;
+    constructor(protocolIdentifier: string);
+    private isSupportedProtocol;
+    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,186 @@
+"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.EvmcV3SerializerCompanion = 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("@wallfree-dev/ethereum/v1/serializer/v3/schemas/converter/transaction-converter");
+var transaction_validator_1 = require("@wallfree-dev/ethereum/v1/serializer/v3/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 EvmcV3SerializerCompanion = /** @class */ (function () {
+    function EvmcV3SerializerCompanion(protocolIdentifier) {
+        this.protocolIdentifier = protocolIdentifier;
+        this.schemas = [
+            {
+                type: serializer_1.IACMessageType.TransactionSignRequest,
+                schema: { schema: ethereumTransactionSignRequest },
+                protocolIdentifier: this.protocolIdentifier
+            },
+            {
+                type: serializer_1.IACMessageType.TransactionSignRequest,
+                schema: { schema: ethereumTypedTransactionSignRequest },
+                protocolIdentifier: this.protocolIdentifier
+            },
+            {
+                type: serializer_1.IACMessageType.TransactionSignResponse,
+                schema: { schema: ethereumTransactionSignResponse },
+                protocolIdentifier: this.protocolIdentifier
+            },
+            {
+                type: serializer_1.IACMessageType.TransactionSignRequest,
+                schema: { schema: ethereumTransactionSignRequest },
+                protocolIdentifier: "".concat(this.protocolIdentifier, "-erc20")
+            },
+            {
+                type: serializer_1.IACMessageType.TransactionSignResponse,
+                schema: { schema: ethereumTransactionSignResponse },
+                protocolIdentifier: "".concat(this.protocolIdentifier, "-erc20")
+            }
+        ];
+        this.ethereumTransactionValidator = new transaction_validator_1.EthereumTransactionValidator();
+    }
+    EvmcV3SerializerCompanion.prototype.isSupportedProtocol = function (identifier) {
+        return identifier === this.protocolIdentifier || identifier.startsWith("".concat(this.protocolIdentifier, "-erc20-"));
+    };
+    EvmcV3SerializerCompanion.prototype.toTransactionSignRequest = function (identifier, unsignedTransaction, publicKey, callbackUrl) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (this.isSupportedProtocol(identifier)) {
+                    return [2 /*return*/, (0, transaction_converter_1.ethereumUnsignedTransactionToRequest)(unsignedTransaction, publicKey, callbackUrl)];
+                }
+                else {
+                    throw new errors_1.UnsupportedError(coinlib_core_1.Domain.EVMC, "Protocol ".concat(identifier, " not supported"));
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    EvmcV3SerializerCompanion.prototype.fromTransactionSignRequest = function (identifier, transactionSignRequest) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (this.isSupportedProtocol(identifier)) {
+                    return [2 /*return*/, (0, transaction_converter_1.ethereumTransactionSignRequestToUnsigned)(transactionSignRequest)];
+                }
+                else {
+                    throw new errors_1.UnsupportedError(coinlib_core_1.Domain.EVMC, "Protocol ".concat(identifier, " not supported"));
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    EvmcV3SerializerCompanion.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 (!this.isSupportedProtocol(identifier)) 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.EVMC, "Protocol ".concat(identifier, " not supported"));
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EvmcV3SerializerCompanion.prototype.toTransactionSignResponse = function (identifier, signedTransaction, accountIdentifier) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (this.isSupportedProtocol(identifier)) {
+                    return [2 /*return*/, (0, transaction_converter_1.ethereumSignedTransactionToResponse)(signedTransaction, accountIdentifier)];
+                }
+                else {
+                    throw new errors_1.UnsupportedError(coinlib_core_1.Domain.EVMC, "Protocol ".concat(identifier, " not supported"));
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    EvmcV3SerializerCompanion.prototype.fromTransactionSignResponse = function (identifier, transactionSignResponse) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (this.isSupportedProtocol(identifier)) {
+                    return [2 /*return*/, (0, transaction_converter_1.ethereumTransactionSignResponseToSigned)(transactionSignResponse)];
+                }
+                else {
+                    throw new errors_1.UnsupportedError(coinlib_core_1.Domain.EVMC, "Protocol ".concat(identifier, " not supported"));
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    EvmcV3SerializerCompanion.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 (!this.isSupportedProtocol(identifier)) 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.EVMC, "Protocol ".concat(identifier, " not supported"));
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return EvmcV3SerializerCompanion;
+}());
+exports.EvmcV3SerializerCompanion = EvmcV3SerializerCompanion;
+//# 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":"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"}

package/v1/types/options.d.ts

@@ -0,0 +1,18 @@
+import { ProtocolUnitsMetadata, FeeDefaults } from '@wallfree-dev/module-kit';
+import { EvmcUnits, EvmcProtocolNetwork } from './protocol';
+export interface EvmcErc20Options {
+    identifier: string;
+    name: string;
+    contractAddress: string;
+    units: ProtocolUnitsMetadata<EvmcUnits>;
+    mainUnit: EvmcUnits;
+}
+export interface EvmcOptions {
+    identifier: string;
+    name: string;
+    network: EvmcProtocolNetwork;
+    units: ProtocolUnitsMetadata<EvmcUnits>;
+    mainUnit: EvmcUnits;
+    feeDefaults?: FeeDefaults<EvmcUnits>;
+    erc20Tokens: EvmcErc20Options[];
+}

package/v1/types/options.js

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

package/v1/types/options.js.map

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

package/v1/types/protocol.d.ts

@@ -0,0 +1,29 @@
+import { FeeDefaults, ProtocolNetwork, ProtocolUnitsMetadata } from '@wallfree-dev/module-kit';
+export declare type EvmcUnits = string;
+export interface EvmcProtocolNetwork extends ProtocolNetwork {
+    chainId: number;
+    blockExplorerApi: string;
+}
+export interface EvmcProtocolOptions<_ProtocolNetwork extends EvmcProtocolNetwork = EvmcProtocolNetwork> {
+    network: _ProtocolNetwork;
+}
+export interface EvmcBaseProtocolOptions<_Units extends string = EvmcUnits, _ProtocolNetwork extends EvmcProtocolNetwork = EvmcProtocolNetwork> extends EvmcProtocolOptions<_ProtocolNetwork> {
+    identifier: string;
+    name: string;
+    units: ProtocolUnitsMetadata<_Units>;
+    mainUnit: _Units;
+    feeUnits: ProtocolUnitsMetadata<_Units>;
+    feeDefaults?: FeeDefaults<EvmcUnits>;
+    standardDerivationPath?: string;
+}
+export interface ERC20ProtocolOptions<_Units extends string, _ProtocolNetwork extends EvmcProtocolNetwork = EvmcProtocolNetwork> extends EvmcProtocolOptions<_ProtocolNetwork> {
+    name: string;
+    identifier: string;
+    contractAddress: string;
+    units: ProtocolUnitsMetadata<_Units>;
+    mainUnit: _Units;
+    feeUnits: ProtocolUnitsMetadata<_Units>;
+}
+export interface ERC20TokenOptions<_ProtocolNetwork extends EvmcProtocolNetwork = EvmcProtocolNetwork> extends ERC20ProtocolOptions<string, _ProtocolNetwork> {
+    mainIdentifier: string;
+}

package/v1/types/protocol.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// export interface ERC20TokenMetadata {
+//   name: string
+//   identifier: string
+//   symbol: string
+//   marketSymbol: string
+//   contractAddress: string
+//   decimals: number
+// }
+//# 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":";;AA8CA,wCAAwC;AACxC,iBAAiB;AACjB,uBAAuB;AAEvB,mBAAmB;AACnB,yBAAyB;AAEzB,4BAA4B;AAE5B,qBAAqB;AACrB,IAAI"}