@airgap/ethereum 0.13.7-beta.21 → 0.13.7-beta.23

package/v1/module/EthereumBaseModule.js

@@ -0,0 +1,83 @@
+"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.EthereumBaseModule = void 0;
+var coinlib_core_1 = require("@airgap/coinlib-core");
+var errors_1 = require("@airgap/coinlib-core/errors");
+var module_kit_1 = require("@airgap/module-kit");
+var EtherscanBlockExplorer_1 = require("../block-explorer/EtherscanBlockExplorer");
+var EthereumBaseModule = /** @class */ (function () {
+    function EthereumBaseModule(supportedNetworks, defaultNetwork) {
+        this.networkRegistry = new module_kit_1.ModuleNetworkRegistry({ supportedNetworks: supportedNetworks, defaultNetwork: defaultNetwork });
+        this.supportedNetworks = this.networkRegistry.supportedNetworks;
+    }
+    EthereumBaseModule.prototype.createOfflineProtocol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.createEthereumProtocol()];
+            });
+        });
+    };
+    EthereumBaseModule.prototype.createOnlineProtocol = function (networkId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var network;
+            return __generator(this, function (_a) {
+                network = this.networkRegistry.findNetwork(networkId);
+                if (network === undefined) {
+                    throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.ETHEREUM, 'Protocol network type not supported.');
+                }
+                return [2 /*return*/, this.createEthereumProtocol(network)];
+            });
+        });
+    };
+    EthereumBaseModule.prototype.createBlockExplorer = function (networkId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var network;
+            return __generator(this, function (_a) {
+                network = this.networkRegistry.findNetwork(networkId);
+                if (network === undefined) {
+                    throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.ETHEREUM, 'Block Explorer network type not supported.');
+                }
+                return [2 /*return*/, new EtherscanBlockExplorer_1.EtherscanBlockExplorer()];
+            });
+        });
+    };
+    return EthereumBaseModule;
+}());
+exports.EthereumBaseModule = EthereumBaseModule;
+//# sourceMappingURL=EthereumBaseModule.js.map

package/v1/module/EthereumBaseModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EthereumBaseModule.js","sourceRoot":"","sources":["../../../src/v1/module/EthereumBaseModule.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,qDAA6C;AAC7C,sDAAqE;AACrE,iDAAyF;AAIzF,mFAAiF;AAGjF;IAKE,4BAAsB,iBAAoC,EAAE,cAAgC;QAC1F,IAAI,CAAC,eAAe,GAAG,IAAI,kCAAqB,CAAC,EAAE,iBAAiB,mBAAA,EAAE,cAAc,gBAAA,EAAE,CAAC,CAAA;QACvF,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,eAAe,CAAC,iBAAiB,CAAA;IACjE,CAAC;IAIY,kDAAqB,GAAlC;;;gBACE,sBAAO,IAAI,CAAC,sBAAsB,EAAE,EAAA;;;KACrC;IAEY,iDAAoB,GAAjC,UAAkC,SAA8B;;;;gBACxD,OAAO,GAAgC,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,SAAS,CAAC,CAAA;gBACxF,IAAI,OAAO,KAAK,SAAS,EAAE;oBACzB,MAAM,IAAI,gCAAuB,CAAC,qBAAM,CAAC,QAAQ,EAAE,sCAAsC,CAAC,CAAA;iBAC3F;gBAED,sBAAO,IAAI,CAAC,sBAAsB,CAAC,OAAO,CAAC,EAAA;;;KAC5C;IAEY,gDAAmB,GAAhC,UAAiC,SAA8B;;;;gBACvD,OAAO,GAAgC,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,SAAS,CAAC,CAAA;gBACxF,IAAI,OAAO,KAAK,SAAS,EAAE;oBACzB,MAAM,IAAI,gCAAuB,CAAC,qBAAM,CAAC,QAAQ,EAAE,4CAA4C,CAAC,CAAA;iBACjG;gBAED,sBAAO,IAAI,+CAAsB,EAAE,EAAA;;;KACpC;IACH,yBAAC;AAAD,CAAC,AAjCD,IAiCC;AAjCqB,gDAAkB"}

package/v1/module/EthereumClassicModule.d.ts

@@ -0,0 +1,7 @@
+import { ProtocolNetwork } from '@airgap/module-kit';
+import { EthereumBaseProtocol } from '../protocol/EthereumBaseProtocol';
+import { EthereumBaseModule } from './EthereumBaseModule';
+export declare class EthereumClassicModule extends EthereumBaseModule {
+    constructor();
+    createEthereumProtocol(network?: ProtocolNetwork | undefined): EthereumBaseProtocol;
+}

package/v1/module/EthereumClassicModule.js

@@ -0,0 +1,32 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EthereumClassicModule = void 0;
+var EthereumClassicProtocol_1 = require("../protocol/EthereumClassicProtocol");
+var EthereumBaseModule_1 = require("./EthereumBaseModule");
+var EthereumClassicModule = /** @class */ (function (_super) {
+    __extends(EthereumClassicModule, _super);
+    function EthereumClassicModule() {
+        return _super.call(this, [EthereumClassicProtocol_1.ETHEREUM_CLASSIC_MAINNET_PROTOCOL_NETWORK]) || this;
+    }
+    EthereumClassicModule.prototype.createEthereumProtocol = function (network) {
+        return (0, EthereumClassicProtocol_1.createEthereumClassicProtocol)({ network: network });
+    };
+    return EthereumClassicModule;
+}(EthereumBaseModule_1.EthereumBaseModule));
+exports.EthereumClassicModule = EthereumClassicModule;
+//# sourceMappingURL=EthereumClassicModule.js.map

package/v1/module/EthereumClassicModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EthereumClassicModule.js","sourceRoot":"","sources":["../../../src/v1/module/EthereumClassicModule.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAGA,+EAA8H;AAE9H,2DAAyD;AAEzD;IAA2C,yCAAkB;IAC3D;eACE,kBAAM,CAAC,mEAAyC,CAAC,CAAC;IACpD,CAAC;IAEM,sDAAsB,GAA7B,UAA8B,OAAqC;QACjE,OAAO,IAAA,uDAA6B,EAAC,EAAE,OAAO,SAAA,EAAE,CAAC,CAAA;IACnD,CAAC;IACH,4BAAC;AAAD,CAAC,AARD,CAA2C,uCAAkB,GAQ5D;AARY,sDAAqB"}

package/v1/module/EthereumModule.d.ts

@@ -0,0 +1,7 @@
+import { ProtocolNetwork } from '@airgap/module-kit';
+import { EthereumBaseProtocol } from '../protocol/EthereumBaseProtocol';
+import { EthereumBaseModule } from './EthereumBaseModule';
+export declare class EthereumModule extends EthereumBaseModule {
+    constructor();
+    createEthereumProtocol(network?: ProtocolNetwork | undefined): EthereumBaseProtocol;
+}

package/v1/module/EthereumModule.js

@@ -0,0 +1,32 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EthereumModule = void 0;
+var EthereumProtocol_1 = require("../protocol/EthereumProtocol");
+var EthereumBaseModule_1 = require("./EthereumBaseModule");
+var EthereumModule = /** @class */ (function (_super) {
+    __extends(EthereumModule, _super);
+    function EthereumModule() {
+        return _super.call(this, [EthereumProtocol_1.ETHEREUM_MAINNET_PROTOCOL_NETWORK]) || this;
+    }
+    EthereumModule.prototype.createEthereumProtocol = function (network) {
+        return (0, EthereumProtocol_1.createEthereumProtocol)({ network: network });
+    };
+    return EthereumModule;
+}(EthereumBaseModule_1.EthereumBaseModule));
+exports.EthereumModule = EthereumModule;
+//# sourceMappingURL=EthereumModule.js.map

package/v1/module/EthereumModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EthereumModule.js","sourceRoot":"","sources":["../../../src/v1/module/EthereumModule.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAGA,iEAAwG;AAExG,2DAAyD;AAEzD;IAAoC,kCAAkB;IACpD;eACE,kBAAM,CAAC,oDAAiC,CAAC,CAAC;IAC5C,CAAC;IAEM,+CAAsB,GAA7B,UAA8B,OAAqC;QACjE,OAAO,IAAA,yCAAsB,EAAC,EAAE,OAAO,SAAA,EAAE,CAAC,CAAA;IAC5C,CAAC;IACH,qBAAC;AAAD,CAAC,AARD,CAAoC,uCAAkB,GAQrD;AARY,wCAAc"}

package/v1/module/EthereumRopstenModule.d.ts

@@ -0,0 +1,7 @@
+import { ProtocolNetwork } from '@airgap/module-kit';
+import { EthereumBaseProtocol } from '../protocol/EthereumBaseProtocol';
+import { EthereumBaseModule } from './EthereumBaseModule';
+export declare class EthereumRopstenModule extends EthereumBaseModule {
+    constructor();
+    createEthereumProtocol(network?: ProtocolNetwork | undefined): EthereumBaseProtocol;
+}

package/v1/module/EthereumRopstenModule.js

@@ -0,0 +1,32 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EthereumRopstenModule = void 0;
+var EthereumRopstenProtocol_1 = require("../protocol/EthereumRopstenProtocol");
+var EthereumBaseModule_1 = require("./EthereumBaseModule");
+var EthereumRopstenModule = /** @class */ (function (_super) {
+    __extends(EthereumRopstenModule, _super);
+    function EthereumRopstenModule() {
+        return _super.call(this, [EthereumRopstenProtocol_1.ETHEREUM_ROPSTEN_MAINNET_PROTOCOL_NETWORK]) || this;
+    }
+    EthereumRopstenModule.prototype.createEthereumProtocol = function (network) {
+        return (0, EthereumRopstenProtocol_1.createEthereumRopstenProtocol)({ network: network });
+    };
+    return EthereumRopstenModule;
+}(EthereumBaseModule_1.EthereumBaseModule));
+exports.EthereumRopstenModule = EthereumRopstenModule;
+//# sourceMappingURL=EthereumRopstenModule.js.map

package/v1/module/EthereumRopstenModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EthereumRopstenModule.js","sourceRoot":"","sources":["../../../src/v1/module/EthereumRopstenModule.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAGA,+EAA8H;AAE9H,2DAAyD;AAEzD;IAA2C,yCAAkB;IAC3D;eACE,kBAAM,CAAC,mEAAyC,CAAC,CAAC;IACpD,CAAC;IAEM,sDAAsB,GAA7B,UAA8B,OAAqC;QACjE,OAAO,IAAA,uDAA6B,EAAC,EAAE,OAAO,SAAA,EAAE,CAAC,CAAA;IACnD,CAAC;IACH,4BAAC;AAAD,CAAC,AARD,CAA2C,uCAAkB,GAQ5D;AARY,sDAAqB"}

package/v1/protocol/EthereumBaseProtocol.d.ts

@@ -0,0 +1,71 @@
+import { BigNumber } from '@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber';
+import { Address, AirGapProtocol, AirGapTransaction, AirGapTransactionStatus, AirGapTransactionsWithCursor, Amount, Balance, FeeDefaults, KeyPair, ProtocolMetadata, ProtocolUnitsMetadata, PublicKey, Secret, SecretKey, Signature, TransactionConfiguration, TransactionDetails } from '@airgap/module-kit';
+import { EthereumCryptoClient } from '../clients/crypto/EthereumCryptoClient';
+import { EthereumInfoClient } from '../clients/info/EthereumInfoClient';
+import { EthereumNodeClient } from '../clients/node/EthereumNodeClient';
+import { EthereumBaseProtocolOptions, EthereumProtocolNetwork, EthereumProtocolOptions, EthereumUnits } from '../types/protocol';
+import { EthereumRawUnsignedTransaction, EthereumSignedTransaction, EthereumTransactionCursor, EthereumTypedUnsignedTransaction, EthereumUnsignedTransaction } from '../types/transaction';
+export interface EthereumBaseProtocol<_Units extends string = EthereumUnits> extends AirGapProtocol<{
+    AddressResult: Address;
+    ProtocolNetwork: EthereumProtocolNetwork;
+    Units: _Units;
+    FeeUnits: EthereumUnits;
+    FeeEstimation: FeeDefaults<EthereumUnits>;
+    SignedTransaction: EthereumSignedTransaction;
+    UnsignedTransaction: EthereumUnsignedTransaction;
+    TransactionCursor: EthereumTransactionCursor;
+}, 'Crypto', 'FetchDataForAddress', 'FetchDataForMultipleAddresses', 'TransactionStatusChecker'> {
+}
+export declare const DEFAULT_ETHEREUM_UNITS_METADATA: ProtocolUnitsMetadata<EthereumUnits>;
+export declare abstract class EthereumBaseProtocolImpl<_Units extends string = EthereumUnits> implements EthereumBaseProtocol<_Units> {
+    protected readonly options: EthereumProtocolOptions;
+    protected readonly nodeClient: EthereumNodeClient;
+    protected readonly infoClient: EthereumInfoClient;
+    protected readonly cryptoClient: EthereumCryptoClient;
+    protected readonly bitcoinJS: {
+        lib: any;
+        config: {
+            network: any;
+        };
+    };
+    protected constructor(nodeClient: EthereumNodeClient, infoClient: EthereumInfoClient, options: EthereumBaseProtocolOptions<_Units>);
+    protected readonly units: ProtocolUnitsMetadata<_Units>;
+    protected readonly feeUnits: ProtocolUnitsMetadata<EthereumUnits>;
+    protected readonly feeDefaults: FeeDefaults<EthereumUnits>;
+    protected readonly metadata: ProtocolMetadata<_Units, EthereumUnits>;
+    getMetadata(): Promise<ProtocolMetadata<_Units, EthereumUnits>>;
+    getAddressFromPublicKey(publicKey: PublicKey): Promise<string>;
+    getDetailsFromTransaction(transaction: EthereumSignedTransaction | EthereumUnsignedTransaction, publicKey: PublicKey): Promise<AirGapTransaction<_Units, EthereumUnits>[]>;
+    protected getDetailsFromSignedTransaction(transaction: EthereumSignedTransaction): Promise<AirGapTransaction<_Units, EthereumUnits>[]>;
+    protected getDetailsFromTypedUnsignedTransaction(transaction: EthereumTypedUnsignedTransaction, ownAddress: string): Promise<AirGapTransaction<_Units, EthereumUnits>[]>;
+    protected getDetailsFromRawUnsignedTransaction(transaction: EthereumRawUnsignedTransaction, ownAddress: string): Promise<AirGapTransaction<_Units, EthereumUnits>[]>;
+    verifyMessageWithPublicKey(message: string, signature: Signature, publicKey: PublicKey): Promise<boolean>;
+    encryptAsymmetricWithPublicKey(payload: string, publicKey: PublicKey): Promise<string>;
+    getKeyPairFromSecret(secret: Secret, derivationPath?: string): Promise<KeyPair>;
+    private getKeyPairFromHexSecret;
+    private getKeyPairFromMnemonic;
+    signTransactionWithSecretKey(transaction: EthereumUnsignedTransaction, secretKey: SecretKey): Promise<EthereumSignedTransaction>;
+    private signTypedUnsignedTransactionWithSecretKey;
+    private signRawUnsignedTransactionWithSecretKey;
+    private signTypedTransactionWithSecretKey;
+    signMessageWithKeyPair(message: string, keyPair: KeyPair): Promise<Signature>;
+    decryptAsymmetricWithKeyPair(payload: string, keyPair: KeyPair): Promise<string>;
+    encryptAESWithSecretKey(payload: string, secretKey: SecretKey): Promise<string>;
+    decryptAESWithSecretKey(payload: string, secretKey: SecretKey): Promise<string>;
+    getNetwork(): Promise<EthereumProtocolNetwork>;
+    getTransactionsForPublicKey(publicKey: PublicKey, limit: number, cursor?: EthereumTransactionCursor): Promise<AirGapTransactionsWithCursor<EthereumTransactionCursor, _Units, EthereumUnits>>;
+    getTransactionsForAddress(address: string, limit: number, cursor?: EthereumTransactionCursor): Promise<AirGapTransactionsWithCursor<EthereumTransactionCursor, _Units, EthereumUnits>>;
+    getTransactionsForAddresses(addresses: string[], limit: number, cursor?: EthereumTransactionCursor): Promise<AirGapTransactionsWithCursor<EthereumTransactionCursor, _Units, EthereumUnits>>;
+    getTransactionStatus(transactionIds: string[]): Promise<Record<string, AirGapTransactionStatus>>;
+    getBalanceOfPublicKey(publicKey: PublicKey): Promise<Balance<_Units>>;
+    getBalanceOfAddress(address: string): Promise<Balance<_Units>>;
+    getBalanceOfAddresses(addresses: string[]): Promise<Balance<_Units>>;
+    getTransactionMaxAmountWithPublicKey(publicKey: PublicKey, to: string[], configuration?: TransactionConfiguration<EthereumUnits>): Promise<Amount<_Units>>;
+    getTransactionFeeWithPublicKey(publicKey: PublicKey, details: TransactionDetails<_Units>[]): Promise<FeeDefaults<EthereumUnits>>;
+    prepareTransactionWithPublicKey(publicKey: PublicKey, details: TransactionDetails<_Units>[], configuration?: TransactionConfiguration<EthereumUnits>): Promise<EthereumUnsignedTransaction>;
+    broadcastTransaction(transaction: EthereumSignedTransaction): Promise<string>;
+    protected estimateGas(fromAddress: string, toAddress: string, amount: string | number | BigNumber | Amount<_Units>, data?: string): Promise<BigNumber>;
+}
+export declare abstract class DefaultEthereumBaseProtocolImpl extends EthereumBaseProtocolImpl {
+    protected constructor(nodeClient: EthereumNodeClient, infoClient: EthereumInfoClient, options: EthereumProtocolOptions & Partial<EthereumBaseProtocolOptions>);
+}