@airgap/tezos 0.13.45-beta.3 → 0.13.45-beta.4

package/v1/contract/TezosContract.js

@@ -1,279 +1,508 @@
 "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 };
+    }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TezosContract = void 0;
-const index_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0/index"));
-const errors_1 = require("@airgap/coinlib-core/errors");
-const coinlib_error_1 = require("@airgap/coinlib-core/errors/coinlib-error");
-const object_1 = require("@airgap/coinlib-core/utils/object");
-const string_1 = require("@airgap/coinlib-core/utils/string");
-const factory_1 = require("../indexer/factory");
-const MichelineNodeUtils_1 = require("../types/micheline/MichelineNodeUtils");
-const MichelsonOr_1 = require("../types/michelson/generics/MichelsonOr");
-const MichelsonType_1 = require("../types/michelson/MichelsonType");
-const MichelsonTypeMeta_1 = require("../types/michelson/MichelsonTypeMeta");
-const micheline_1 = require("../utils/micheline");
-const pack_1 = require("../utils/pack");
-const TezosContractRemoteDataFactory_1 = require("./remote-data/TezosContractRemoteDataFactory");
-const TezosContractCall_1 = require("./TezosContractCall");
-const TezosContractEntrypoint_1 = require("./TezosContractEntrypoint");
-const TezosContractStorage_1 = require("./TezosContractStorage");
-const DEFAULT_ENTRYPOINT = 'default';
-class TezosContract {
-    constructor(address, network) {
+var index_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0/index"));
+var errors_1 = require("@airgap/coinlib-core/errors");
+var coinlib_error_1 = require("@airgap/coinlib-core/errors/coinlib-error");
+var object_1 = require("@airgap/coinlib-core/utils/object");
+var string_1 = require("@airgap/coinlib-core/utils/string");
+var factory_1 = require("../indexer/factory");
+var MichelineNodeUtils_1 = require("../types/micheline/MichelineNodeUtils");
+var MichelsonOr_1 = require("../types/michelson/generics/MichelsonOr");
+var MichelsonType_1 = require("../types/michelson/MichelsonType");
+var MichelsonTypeMeta_1 = require("../types/michelson/MichelsonTypeMeta");
+var micheline_1 = require("../utils/micheline");
+var pack_1 = require("../utils/pack");
+var TezosContractRemoteDataFactory_1 = require("./remote-data/TezosContractRemoteDataFactory");
+var TezosContractCall_1 = require("./TezosContractCall");
+var TezosContractEntrypoint_1 = require("./TezosContractEntrypoint");
+var TezosContractStorage_1 = require("./TezosContractStorage");
+var DEFAULT_ENTRYPOINT = 'default';
+var TezosContract = /** @class */ (function () {
+    function TezosContract(address, network) {
         this.address = address;
         this.network = network;
         this.remoteDataFactory = new TezosContractRemoteDataFactory_1.TezosContractRemoteDataFactory();
         this.indexerClient = (0, factory_1.createTezosIndexerClient)(this.network.indexerType, this.network.indexerApi);
     }
-    copy(values = {}) {
-        return new TezosContract(values.address ?? this.address, values.network ?? this.network);
-    }
-    async findBigMap(name) {
-        const storage = await this.readStorage();
-        return (0, object_1.recursivelyFind)(storage?.asRawValue(), name)?.toNumber();
-    }
-    async bigMapValue(bigMapID, keyOrValueSchema, keySchemaOrUndefined, valueSchemaOrUndefined) {
-        let expr;
-        let valueSchema;
-        if (keySchemaOrUndefined && valueSchemaOrUndefined) {
-            const michelsonKey = MichelsonTypeMeta_1.MichelsonTypeMeta.fromMichelineNode(keySchemaOrUndefined)?.createValue(keyOrValueSchema);
-            if (!michelsonKey) {
-                return undefined;
-            }
-            expr = await (0, pack_1.encodeExpr)(michelsonKey);
-            valueSchema = valueSchemaOrUndefined;
-        }
-        else if (!keySchemaOrUndefined && !valueSchemaOrUndefined) {
-            valueSchema = keyOrValueSchema;
-        }
-        if (!valueSchema) {
-            return undefined;
-        }
-        const value = await this.bigMapRequest(bigMapID, expr);
-        return value ? MichelsonTypeMeta_1.MichelsonTypeMeta.fromMichelineNode(valueSchema)?.createValue(value) : undefined;
-    }
-    async bigMapValues(bigMapID, valueSchema) {
-        const values = await this.bigMapRequest(bigMapID, '');
-        if (!Array.isArray(values)) {
-            return [];
-        }
-        return values
-            ?.map((value) => MichelsonTypeMeta_1.MichelsonTypeMeta.fromMichelineNode(valueSchema)?.createValue(value))
-            ?.filter((value) => value !== undefined);
-    }
-    async getBigMaps() {
-        await this.waitForBigMaps();
-        return this.bigMaps ?? [];
-    }
-    async getBigMapValues(request) {
-        const bigMap = request?.bigMap ?? (await this.getBigMap(request.bigMap?.path));
-        return this.indexerClient.getContractBigMapValues(this.address, bigMap, request.resultType, request.filters, request.limit ?? 10000);
-    }
-    async getBigMapValue(request) {
-        const bigMap = request?.bigMap ?? (await this.getBigMap(request.bigMap?.path));
-        if (request.key === undefined) {
-            return undefined;
-        }
-        return this.indexerClient.getContractBigMapValue(this.address, bigMap, request.key, request.resultType, request.limit ?? 10000);
-    }
-    async readStorage() {
-        await this.waitForContractCode();
-        if (this.storage === undefined) {
-            return undefined;
-        }
-        const storageContent = await this.contractRequest('/storage/normalized', { unparsing_mode: 'Optimized_legacy' });
-        return this.storage.type.createValue(storageContent);
-    }
-    async metadata(networkResolver) {
-        const bigMapID = await this.findBigMap('metadata');
-        if (bigMapID === undefined) {
-            return undefined;
-        }
-        const remoteData = await this.getMetadataRemoteData(bigMapID, networkResolver);
-        return remoteData?.get();
-    }
-    async balance() {
-        return this.contractRequest('/balance');
-    }
-    async createContractCall(entrypointName, value, amount) {
-        await this.waitForContractCode();
-        const entrypoint = this.entrypoints?.get(entrypointName);
-        if (!entrypoint) {
-            return this.createDefaultContractCall(value, amount);
-        }
-        return this.createEntrypointContractCall(entrypoint, value, undefined, amount);
-    }
-    async parseContractCall(json) {
-        await this.waitForContractCode();
-        const entrypoint = this.entrypoints?.get(json.entrypoint);
-        if (!entrypoint) {
-            return Promise.reject(`Couldn't parse the contract call, unknown entrypoint: ${json.entrypoint}`);
-        }
-        return this.createEntrypointContractCall(entrypoint, json.value, { lazyEval: false });
-    }
-    areValidParameters(data) {
+    TezosContract.prototype.copy = function (values) {
+        var _a, _b;
+        if (values === void 0) { values = {}; }
+        return new TezosContract((_a = values.address) !== null && _a !== void 0 ? _a : this.address, (_b = values.network) !== null && _b !== void 0 ? _b : this.network);
+    };
+    TezosContract.prototype.findBigMap = function (name) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var storage;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.readStorage()];
+                    case 1:
+                        storage = _b.sent();
+                        return [2 /*return*/, (_a = (0, object_1.recursivelyFind)(storage === null || storage === void 0 ? void 0 : storage.asRawValue(), name)) === null || _a === void 0 ? void 0 : _a.toNumber()];
+                }
+            });
+        });
+    };
+    TezosContract.prototype.bigMapValue = function (bigMapID, keyOrValueSchema, keySchemaOrUndefined, valueSchemaOrUndefined) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var expr, valueSchema, michelsonKey, value;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!(keySchemaOrUndefined && valueSchemaOrUndefined)) return [3 /*break*/, 2];
+                        michelsonKey = (_a = MichelsonTypeMeta_1.MichelsonTypeMeta.fromMichelineNode(keySchemaOrUndefined)) === null || _a === void 0 ? void 0 : _a.createValue(keyOrValueSchema);
+                        if (!michelsonKey) {
+                            return [2 /*return*/, undefined];
+                        }
+                        return [4 /*yield*/, (0, pack_1.encodeExpr)(michelsonKey)];
+                    case 1:
+                        expr = _c.sent();
+                        valueSchema = valueSchemaOrUndefined;
+                        return [3 /*break*/, 3];
+                    case 2:
+                        if (!keySchemaOrUndefined && !valueSchemaOrUndefined) {
+                            valueSchema = keyOrValueSchema;
+                        }
+                        _c.label = 3;
+                    case 3:
+                        if (!valueSchema) {
+                            return [2 /*return*/, undefined];
+                        }
+                        return [4 /*yield*/, this.bigMapRequest(bigMapID, expr)];
+                    case 4:
+                        value = _c.sent();
+                        return [2 /*return*/, value ? (_b = MichelsonTypeMeta_1.MichelsonTypeMeta.fromMichelineNode(valueSchema)) === null || _b === void 0 ? void 0 : _b.createValue(value) : undefined];
+                }
+            });
+        });
+    };
+    TezosContract.prototype.bigMapValues = function (bigMapID, valueSchema) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var values;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.bigMapRequest(bigMapID, '')];
+                    case 1:
+                        values = _b.sent();
+                        if (!Array.isArray(values)) {
+                            return [2 /*return*/, []];
+                        }
+                        return [2 /*return*/, (_a = values === null || values === void 0 ? void 0 : values.map(function (value) { var _a; return (_a = MichelsonTypeMeta_1.MichelsonTypeMeta.fromMichelineNode(valueSchema)) === null || _a === void 0 ? void 0 : _a.createValue(value); })) === null || _a === void 0 ? void 0 : _a.filter(function (value) { return value !== undefined; })];
+                }
+            });
+        });
+    };
+    TezosContract.prototype.getBigMaps = function () {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.waitForBigMaps()];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/, (_a = this.bigMaps) !== null && _a !== void 0 ? _a : []];
+                }
+            });
+        });
+    };
+    TezosContract.prototype.getBigMapValues = function (request) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function () {
+            var bigMap, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        if (!((_a = request === null || request === void 0 ? void 0 : request.bigMap) !== null && _a !== void 0)) return [3 /*break*/, 1];
+                        _d = _a;
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.getBigMap((_b = request.bigMap) === null || _b === void 0 ? void 0 : _b.path)];
+                    case 2:
+                        _d = (_e.sent());
+                        _e.label = 3;
+                    case 3:
+                        bigMap = _d;
+                        return [2 /*return*/, this.indexerClient.getContractBigMapValues(this.address, bigMap, request.resultType, request.filters, (_c = request.limit) !== null && _c !== void 0 ? _c : 10000)];
+                }
+            });
+        });
+    };
+    TezosContract.prototype.getBigMapValue = function (request) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function () {
+            var bigMap, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        if (!((_a = request === null || request === void 0 ? void 0 : request.bigMap) !== null && _a !== void 0)) return [3 /*break*/, 1];
+                        _d = _a;
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.getBigMap((_b = request.bigMap) === null || _b === void 0 ? void 0 : _b.path)];
+                    case 2:
+                        _d = (_e.sent());
+                        _e.label = 3;
+                    case 3:
+                        bigMap = _d;
+                        if (request.key === undefined) {
+                            return [2 /*return*/, undefined];
+                        }
+                        return [2 /*return*/, this.indexerClient.getContractBigMapValue(this.address, bigMap, request.key, request.resultType, (_c = request.limit) !== null && _c !== void 0 ? _c : 10000)];
+                }
+            });
+        });
+    };
+    TezosContract.prototype.readStorage = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var storageContent;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.waitForContractCode()];
+                    case 1:
+                        _a.sent();
+                        if (this.storage === undefined) {
+                            return [2 /*return*/, undefined];
+                        }
+                        return [4 /*yield*/, this.contractRequest('/storage/normalized', { unparsing_mode: 'Optimized_legacy' })];
+                    case 2:
+                        storageContent = _a.sent();
+                        return [2 /*return*/, this.storage.type.createValue(storageContent)];
+                }
+            });
+        });
+    };
+    TezosContract.prototype.metadata = function (networkResolver) {
+        return __awaiter(this, void 0, void 0, function () {
+            var bigMapID, remoteData;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.findBigMap('metadata')];
+                    case 1:
+                        bigMapID = _a.sent();
+                        if (bigMapID === undefined) {
+                            return [2 /*return*/, undefined];
+                        }
+                        return [4 /*yield*/, this.getMetadataRemoteData(bigMapID, networkResolver)];
+                    case 2:
+                        remoteData = _a.sent();
+                        return [2 /*return*/, remoteData === null || remoteData === void 0 ? void 0 : remoteData.get()];
+                }
+            });
+        });
+    };
+    TezosContract.prototype.balance = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.contractRequest('/balance')];
+            });
+        });
+    };
+    TezosContract.prototype.createContractCall = function (entrypointName, value, amount) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var entrypoint;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.waitForContractCode()];
+                    case 1:
+                        _b.sent();
+                        entrypoint = (_a = this.entrypoints) === null || _a === void 0 ? void 0 : _a.get(entrypointName);
+                        if (!entrypoint) {
+                            return [2 /*return*/, this.createDefaultContractCall(value, amount)];
+                        }
+                        return [2 /*return*/, this.createEntrypointContractCall(entrypoint, value, undefined, amount)];
+                }
+            });
+        });
+    };
+    TezosContract.prototype.parseContractCall = function (json) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var entrypoint;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.waitForContractCode()];
+                    case 1:
+                        _b.sent();
+                        entrypoint = (_a = this.entrypoints) === null || _a === void 0 ? void 0 : _a.get(json.entrypoint);
+                        if (!entrypoint) {
+                            return [2 /*return*/, Promise.reject("Couldn't parse the contract call, unknown entrypoint: ".concat(json.entrypoint))];
+                        }
+                        return [2 /*return*/, this.createEntrypointContractCall(entrypoint, json.value, { lazyEval: false })];
+                }
+            });
+        });
+    };
+    TezosContract.prototype.areValidParameters = function (data) {
         try {
-            const parameters = typeof data === 'string' ? JSON.parse(data) : data;
+            var parameters = typeof data === 'string' ? JSON.parse(data) : data;
             return parameters instanceof Object && 'entrypoint' in parameters && 'value' in parameters;
         }
-        catch {
+        catch (_a) {
             return false;
         }
-    }
-    parseParameters(parameters) {
+    };
+    TezosContract.prototype.parseParameters = function (parameters) {
         if (!this.areValidParameters(parameters)) {
             throw new Error('Invalid parameters');
         }
         return JSON.parse(parameters);
-    }
-    async normalizeContractCallParameters(json, fallbackEntrypoint) {
-        const entrypoint = 'entrypoint' in json ? json.entrypoint : undefined;
-        const value = 'value' in json ? json.value : json;
-        if (entrypoint !== undefined && entrypoint !== DEFAULT_ENTRYPOINT) {
-            return {
-                entrypoint,
-                value
-            };
-        }
-        if (!MichelsonOr_1.MichelsonOr.isOr(value)) {
-            return {
-                entrypoint: fallbackEntrypoint ?? DEFAULT_ENTRYPOINT,
-                value
-            };
-        }
-        await this.waitForContractCode();
-        const defaultEntrypoint = this.entrypoints?.get(DEFAULT_ENTRYPOINT);
-        if (!defaultEntrypoint) {
-            throw new errors_1.InvalidValueError(coinlib_error_1.Domain.TEZOS, 'Could not fetch default entrypoint.');
-        }
-        let normalizedEntrypoint;
-        defaultEntrypoint.type.createValue(value, {
-            readAnnots: false,
-            beforeNext: (meta, raw) => {
-                const entrypointName = meta.getAnnotation(MichelsonTypeMeta_1.MichelsonAnnotationPrefix.FIELD);
-                if (entrypointName && (0, micheline_1.isMichelineNode)(raw)) {
-                    normalizedEntrypoint = [entrypointName, raw];
-                }
-            },
-            onNext: (_meta, _raw, michelsonValue) => {
-                if (michelsonValue instanceof MichelsonOr_1.MichelsonOr) {
-                    michelsonValue.eval();
+    };
+    TezosContract.prototype.normalizeContractCallParameters = function (json, fallbackEntrypoint) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var entrypoint, value, defaultEntrypoint, normalizedEntrypoint;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        entrypoint = 'entrypoint' in json ? json.entrypoint : undefined;
+                        value = 'value' in json ? json.value : json;
+                        if (entrypoint !== undefined && entrypoint !== DEFAULT_ENTRYPOINT) {
+                            return [2 /*return*/, {
+                                    entrypoint: entrypoint,
+                                    value: value
+                                }];
+                        }
+                        if (!MichelsonOr_1.MichelsonOr.isOr(value)) {
+                            return [2 /*return*/, {
+                                    entrypoint: fallbackEntrypoint !== null && fallbackEntrypoint !== void 0 ? fallbackEntrypoint : DEFAULT_ENTRYPOINT,
+                                    value: value
+                                }];
+                        }
+                        return [4 /*yield*/, this.waitForContractCode()];
+                    case 1:
+                        _b.sent();
+                        defaultEntrypoint = (_a = this.entrypoints) === null || _a === void 0 ? void 0 : _a.get(DEFAULT_ENTRYPOINT);
+                        if (!defaultEntrypoint) {
+                            throw new errors_1.InvalidValueError(coinlib_error_1.Domain.TEZOS, 'Could not fetch default entrypoint.');
+                        }
+                        defaultEntrypoint.type.createValue(value, {
+                            readAnnots: false,
+                            beforeNext: function (meta, raw) {
+                                var entrypointName = meta.getAnnotation(MichelsonTypeMeta_1.MichelsonAnnotationPrefix.FIELD);
+                                if (entrypointName && (0, micheline_1.isMichelineNode)(raw)) {
+                                    normalizedEntrypoint = [entrypointName, raw];
+                                }
+                            },
+                            onNext: function (_meta, _raw, michelsonValue) {
+                                if (michelsonValue instanceof MichelsonOr_1.MichelsonOr) {
+                                    michelsonValue.eval();
+                                }
+                            }
+                        });
+                        return [2 /*return*/, {
+                                entrypoint: normalizedEntrypoint ? normalizedEntrypoint[0] : fallbackEntrypoint !== null && fallbackEntrypoint !== void 0 ? fallbackEntrypoint : defaultEntrypoint.name,
+                                value: normalizedEntrypoint ? normalizedEntrypoint[1] : value
+                            }];
                 }
-            }
+            });
         });
-        return {
-            entrypoint: normalizedEntrypoint ? normalizedEntrypoint[0] : fallbackEntrypoint ?? defaultEntrypoint.name,
-            value: normalizedEntrypoint ? normalizedEntrypoint[1] : value
-        };
-    }
-    createDefaultContractCall(value, amount) {
+    };
+    TezosContract.prototype.createDefaultContractCall = function (value, amount) {
         return new TezosContractCall_1.TezosContractCall(DEFAULT_ENTRYPOINT, value instanceof MichelsonType_1.MichelsonType ? value : undefined, amount);
-    }
-    createEntrypointContractCall(entrypoint, value, configuration = {}, amount) {
+    };
+    TezosContract.prototype.createEntrypointContractCall = function (entrypoint, value, configuration, amount) {
+        if (configuration === void 0) { configuration = {}; }
         return new TezosContractCall_1.TezosContractCall(entrypoint.name, entrypoint.type.createValue(value, configuration), amount);
-    }
-    async getBigMap(path) {
-        await this.waitForBigMaps();
-        if (this.bigMaps?.length === 1) {
-            return this.bigMaps[0];
-        }
-        if (!path) {
-            throw new errors_1.InvalidValueError(coinlib_error_1.Domain.TEZOS, 'Contract has more than one BigMap, provide ID or predicates to select one.');
-        }
-        const response = this.bigMaps?.filter((bigMap) => bigMap.path === path) ?? [];
-        if (response.length === 0) {
-            throw new errors_1.InvalidValueError(coinlib_error_1.Domain.TEZOS, 'BigMap ID not found');
-        }
-        if (response.length > 1) {
-            throw new errors_1.InvalidValueError(coinlib_error_1.Domain.TEZOS, 'More than one BigMap ID has been found for the predicates.');
-        }
-        return response[0];
-    }
-    async waitForBigMaps() {
-        if (this.bigMaps !== undefined) {
-            return;
-        }
-        if (this.bigMapsPromise === undefined) {
-            this.bigMapsPromise = this.indexerClient
-                .getContractBigMaps(this.address, 1000)
-                .then((response) => {
-                if (response.length === 0) {
-                    throw new errors_1.NotFoundError(coinlib_error_1.Domain.TEZOS, 'BigMap IDs not found');
+    };
+    TezosContract.prototype.getBigMap = function (path) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.waitForBigMaps()];
+                    case 1:
+                        _d.sent();
+                        if (((_a = this.bigMaps) === null || _a === void 0 ? void 0 : _a.length) === 1) {
+                            return [2 /*return*/, this.bigMaps[0]];
+                        }
+                        if (!path) {
+                            throw new errors_1.InvalidValueError(coinlib_error_1.Domain.TEZOS, 'Contract has more than one BigMap, provide ID or predicates to select one.');
+                        }
+                        response = (_c = (_b = this.bigMaps) === null || _b === void 0 ? void 0 : _b.filter(function (bigMap) { return bigMap.path === path; })) !== null && _c !== void 0 ? _c : [];
+                        if (response.length === 0) {
+                            throw new errors_1.InvalidValueError(coinlib_error_1.Domain.TEZOS, 'BigMap ID not found');
+                        }
+                        if (response.length > 1) {
+                            throw new errors_1.InvalidValueError(coinlib_error_1.Domain.TEZOS, 'More than one BigMap ID has been found for the predicates.');
+                        }
+                        return [2 /*return*/, response[0]];
                 }
-                this.bigMaps = response;
-            })
-                .finally(() => {
-                this.bigMapsPromise = undefined;
             });
-        }
-        return this.bigMapsPromise;
-    }
-    async waitForContractCode() {
-        if (this.entrypoints !== undefined && this.storage !== undefined) {
-            return;
-        }
-        if (this.codePromise === undefined) {
-            const scriptPromise = this.contractRequest('/script/normalized', {
-                unparsing_mode: 'Optimized_legacy'
+        });
+    };
+    TezosContract.prototype.waitForBigMaps = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (this.bigMaps !== undefined) {
+                    return [2 /*return*/];
+                }
+                if (this.bigMapsPromise === undefined) {
+                    this.bigMapsPromise = this.indexerClient
+                        .getContractBigMaps(this.address, 1000)
+                        .then(function (response) {
+                        if (response.length === 0) {
+                            throw new errors_1.NotFoundError(coinlib_error_1.Domain.TEZOS, 'BigMap IDs not found');
+                        }
+                        _this.bigMaps = response;
+                    })
+                        .finally(function () {
+                        _this.bigMapsPromise = undefined;
+                    });
+                }
+                return [2 /*return*/, this.bigMapsPromise];
             });
-            const entrypointsPromise = this.contractRequest('/entrypoints');
-            this.codePromise = Promise.all([scriptPromise, entrypointsPromise])
-                .then(([scriptResponse, entrypointsResponse]) => {
-                if (entrypointsResponse.entrypoints[DEFAULT_ENTRYPOINT] === undefined) {
-                    const parameter = scriptResponse.code.find((primitiveApplication) => primitiveApplication.prim === 'parameter');
-                    if (parameter) {
-                        const normalizedParameter = parameter ? this.normalizeContractCode(parameter) : undefined;
-                        entrypointsResponse.entrypoints[DEFAULT_ENTRYPOINT] = normalizedParameter?.args ? normalizedParameter.args[0] : [];
-                    }
+        });
+    };
+    TezosContract.prototype.waitForContractCode = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var scriptPromise, entrypointsPromise;
+            var _this = this;
+            return __generator(this, function (_a) {
+                if (this.entrypoints !== undefined && this.storage !== undefined) {
+                    return [2 /*return*/];
                 }
-                this.entrypoints = new Map(TezosContractEntrypoint_1.TezosContractEntrypoint.fromJSON(entrypointsResponse.entrypoints).map((entrypoint) => [
-                    entrypoint.name,
-                    entrypoint
-                ]));
-                const storage = scriptResponse.code.find((primitiveApplication) => primitiveApplication.prim === 'storage');
-                if (storage) {
-                    const normalizedStorage = this.normalizeContractCode(storage);
-                    this.storage = TezosContractStorage_1.TezosContractStorage.fromJSON(normalizedStorage.args[0]);
+                if (this.codePromise === undefined) {
+                    scriptPromise = this.contractRequest('/script/normalized', {
+                        unparsing_mode: 'Optimized_legacy'
+                    });
+                    entrypointsPromise = this.contractRequest('/entrypoints');
+                    this.codePromise = Promise.all([scriptPromise, entrypointsPromise])
+                        .then(function (_a) {
+                        var scriptResponse = _a[0], entrypointsResponse = _a[1];
+                        if (entrypointsResponse.entrypoints[DEFAULT_ENTRYPOINT] === undefined) {
+                            var parameter = scriptResponse.code.find(function (primitiveApplication) { return primitiveApplication.prim === 'parameter'; });
+                            if (parameter) {
+                                var normalizedParameter = parameter ? _this.normalizeContractCode(parameter) : undefined;
+                                entrypointsResponse.entrypoints[DEFAULT_ENTRYPOINT] = (normalizedParameter === null || normalizedParameter === void 0 ? void 0 : normalizedParameter.args) ? normalizedParameter.args[0] : [];
+                            }
+                        }
+                        _this.entrypoints = new Map(TezosContractEntrypoint_1.TezosContractEntrypoint.fromJSON(entrypointsResponse.entrypoints).map(function (entrypoint) { return [
+                            entrypoint.name,
+                            entrypoint
+                        ]; }));
+                        var storage = scriptResponse.code.find(function (primitiveApplication) { return primitiveApplication.prim === 'storage'; });
+                        if (storage) {
+                            var normalizedStorage = _this.normalizeContractCode(storage);
+                            _this.storage = TezosContractStorage_1.TezosContractStorage.fromJSON(normalizedStorage.args[0]);
+                        }
+                    })
+                        .finally(function () {
+                        _this.codePromise = undefined;
+                    });
                 }
-            })
-                .finally(() => {
-                this.codePromise = undefined;
+                return [2 /*return*/, this.codePromise];
             });
-        }
-        return this.codePromise;
-    }
-    normalizeContractCode(code) {
+        });
+    };
+    TezosContract.prototype.normalizeContractCode = function (code) {
+        var _a;
         return {
             prim: code.prim,
-            args: code.args?.map((arg) => MichelineNodeUtils_1.MichelineNodeUtils.normalize(arg))
+            args: (_a = code.args) === null || _a === void 0 ? void 0 : _a.map(function (arg) { return MichelineNodeUtils_1.MichelineNodeUtils.normalize(arg); })
         };
-    }
-    async getMetadataRemoteData(bigMapID, networkResolver) {
-        const uriEncoded = await this.bigMapValue(bigMapID, '', { prim: 'string' }, { prim: 'bytes' });
-        const uri = uriEncoded ? uriEncoded.value.toString() : undefined;
-        return uri ? this.remoteDataFactory.create(uri.trim(), { contract: this, networkResolver }) : undefined;
-    }
-    async bigMapRequest(bigMapID, expr) {
-        const url = expr
-            ? `${this.network.rpcUrl}/chains/main/blocks/head/context/big_maps/${bigMapID}/${expr}`
-            : `${this.network.rpcUrl}/chains/main/blocks/head/context/big_maps/${bigMapID}`;
-        const response = await index_1.default.get(url);
-        return response.data;
-    }
-    async contractRequest(endpoint, body) {
-        const url = `${this.network.rpcUrl}/chains/main/blocks/head/context/contracts/${this.address}/${(0, string_1.trimStart)(endpoint, '/')}`;
-        const response = body === undefined
-            ? await index_1.default.get(url)
-            : await index_1.default.post(url, body, {
-                headers: {
-                    'Content-Type': 'application/json'
+    };
+    TezosContract.prototype.getMetadataRemoteData = function (bigMapID, networkResolver) {
+        return __awaiter(this, void 0, void 0, function () {
+            var uriEncoded, uri;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.bigMapValue(bigMapID, '', { prim: 'string' }, { prim: 'bytes' })];
+                    case 1:
+                        uriEncoded = _a.sent();
+                        uri = uriEncoded ? uriEncoded.value.toString() : undefined;
+                        return [2 /*return*/, uri ? this.remoteDataFactory.create(uri.trim(), { contract: this, networkResolver: networkResolver }) : undefined];
                 }
             });
-        return response.data;
-    }
-}
+        });
+    };
+    TezosContract.prototype.bigMapRequest = function (bigMapID, expr) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        url = expr
+                            ? "".concat(this.network.rpcUrl, "/chains/main/blocks/head/context/big_maps/").concat(bigMapID, "/").concat(expr)
+                            : "".concat(this.network.rpcUrl, "/chains/main/blocks/head/context/big_maps/").concat(bigMapID);
+                        return [4 /*yield*/, index_1.default.get(url)];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.data];
+                }
+            });
+        });
+    };
+    TezosContract.prototype.contractRequest = function (endpoint, body) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url, response, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        url = "".concat(this.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(this.address, "/").concat((0, string_1.trimStart)(endpoint, '/'));
+                        if (!(body === undefined)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, index_1.default.get(url)];
+                    case 1:
+                        _a = _b.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, index_1.default.post(url, body, {
+                            headers: {
+                                'Content-Type': 'application/json'
+                            }
+                        })];
+                    case 3:
+                        _a = _b.sent();
+                        _b.label = 4;
+                    case 4:
+                        response = _a;
+                        return [2 /*return*/, response.data];
+                }
+            });
+        });
+    };
+    return TezosContract;
+}());
 exports.TezosContract = TezosContract;
 //# sourceMappingURL=TezosContract.js.map