@taquito/taquito 24.2.0 → 24.3.0-beta.0

package/dist/lib/parser/michel-codec-parser.js

@@ -1,13 +1,4 @@
 "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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MichelCodecParser = void 0;
 const michel_codec_1 = require("@taquito/michel-codec");
@@ -17,119 +8,103 @@ class MichelCodecParser {
     constructor(context) {
         this.context = context;
     }
-    getNextProto() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.context.proto) {
-                const nextProto = yield this.context.readProvider.getNextProtocol('head');
-                this.context.proto = nextProto;
-            }
-            return this.context.proto;
-        });
+    async getNextProto() {
+        if (!this.context.proto) {
+            const nextProto = await this.context.readProvider.getNextProtocol('head');
+            this.context.proto = nextProto;
+        }
+        return this.context.proto;
     }
-    parseScript(src) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const parser = new michel_codec_1.Parser({ protocol: yield this.getNextProto() });
-            return parser.parseScript(src);
-        });
+    async parseScript(src) {
+        const parser = new michel_codec_1.Parser({ protocol: await this.getNextProto() });
+        return parser.parseScript(src);
     }
-    parseMichelineExpression(src) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const parser = new michel_codec_1.Parser({ protocol: yield this.getNextProto() });
-            return parser.parseMichelineExpression(src);
-        });
+    async parseMichelineExpression(src) {
+        const parser = new michel_codec_1.Parser({ protocol: await this.getNextProto() });
+        return parser.parseMichelineExpression(src);
     }
-    parseJSON(src) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const parser = new michel_codec_1.Parser({ protocol: yield this.getNextProto() });
-            return parser.parseJSON(src);
-        });
+    async parseJSON(src) {
+        const parser = new michel_codec_1.Parser({ protocol: await this.getNextProto() });
+        return parser.parseJSON(src);
     }
-    prepareCodeOrigination(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const parsedParams = params;
-            parsedParams.code = yield this.formatCodeParam(params.code);
-            if (params.init) {
-                parsedParams.init = yield this.formatInitParam(params.init);
-            }
-            else if (params.storage) {
-                const storageType = parsedParams.code.find((p) => 'prim' in p && p.prim === 'storage');
-                if (!(storageType === null || storageType === void 0 ? void 0 : storageType.args)) {
-                    throw new errors_1.InvalidCodeParameter('The storage section is missing from the script', params.code);
-                }
-                const schema = new michelson_encoder_1.Schema(storageType.args[0]);
-                const globalconstantsHashAndValue = yield this.findGlobalConstantsHashAndValue(schema);
-                if (Object.keys(globalconstantsHashAndValue).length !== 0) {
-                    // If there are global constants in the storage part of the contract code,
-                    // they need to be locally expanded in order to encode the storage arguments
-                    const p = new michel_codec_1.Parser({ expandGlobalConstant: globalconstantsHashAndValue });
-                    const storageTypeNoGlobalConst = p.parseJSON(storageType.args[0]);
-                    const schemaNoGlobalConst = new michelson_encoder_1.Schema(storageTypeNoGlobalConst);
-                    parsedParams.init = schemaNoGlobalConst.Encode(params.storage);
-                }
-                else {
-                    parsedParams.init = schema.Encode(params.storage);
-                }
-                delete parsedParams.storage;
+    async prepareCodeOrigination(params) {
+        const parsedParams = params;
+        parsedParams.code = await this.formatCodeParam(params.code);
+        if (params.init) {
+            parsedParams.init = await this.formatInitParam(params.init);
+        }
+        else if (params.storage) {
+            const storageType = parsedParams.code.find((p) => 'prim' in p && p.prim === 'storage');
+            if (!storageType?.args) {
+                throw new errors_1.InvalidCodeParameter('The storage section is missing from the script', params.code);
             }
-            return parsedParams;
-        });
-    }
-    formatCodeParam(code) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let parsedCode;
-            if (typeof code === 'string') {
-                const c = yield this.parseScript(code);
-                if (c === null) {
-                    throw new errors_1.InvalidCodeParameter('Unable to parse', code);
-                }
-                parsedCode = c;
+            const schema = new michelson_encoder_1.Schema(storageType.args[0]);
+            const globalconstantsHashAndValue = await this.findGlobalConstantsHashAndValue(schema);
+            if (Object.keys(globalconstantsHashAndValue).length !== 0) {
+                // If there are global constants in the storage part of the contract code,
+                // they need to be locally expanded in order to encode the storage arguments
+                const p = new michel_codec_1.Parser({ expandGlobalConstant: globalconstantsHashAndValue });
+                const storageTypeNoGlobalConst = p.parseJSON(storageType.args[0]);
+                const schemaNoGlobalConst = new michelson_encoder_1.Schema(storageTypeNoGlobalConst);
+                parsedParams.init = schemaNoGlobalConst.Encode(params.storage);
             }
             else {
-                const c = yield this.parseJSON(code);
-                const order = ['parameter', 'storage', 'code'];
-                // Ensure correct ordering for RPC
-                parsedCode = c.sort((a, b) => order.indexOf(a.prim) - order.indexOf(b.prim));
+                parsedParams.init = schema.Encode(params.storage);
             }
-            return parsedCode;
-        });
+            delete parsedParams.storage;
+        }
+        return parsedParams;
     }
-    formatInitParam(init) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let parsedInit;
-            if (typeof init === 'string') {
-                const c = yield this.parseMichelineExpression(init);
-                if (c === null) {
-                    throw new errors_1.InvalidInitParameter('Invalid init parameter', init);
-                }
-                parsedInit = c;
+    async formatCodeParam(code) {
+        let parsedCode;
+        if (typeof code === 'string') {
+            const c = await this.parseScript(code);
+            if (c === null) {
+                throw new errors_1.InvalidCodeParameter('Unable to parse', code);
             }
-            else {
-                parsedInit = yield this.parseJSON(init);
+            parsedCode = c;
+        }
+        else {
+            const c = await this.parseJSON(code);
+            const order = ['parameter', 'storage', 'code'];
+            // Ensure correct ordering for RPC
+            parsedCode = c.sort((a, b) => order.indexOf(a.prim) - order.indexOf(b.prim));
+        }
+        return parsedCode;
+    }
+    async formatInitParam(init) {
+        let parsedInit;
+        if (typeof init === 'string') {
+            const c = await this.parseMichelineExpression(init);
+            if (c === null) {
+                throw new errors_1.InvalidInitParameter('Invalid init parameter', init);
             }
-            return parsedInit;
-        });
+            parsedInit = c;
+        }
+        else {
+            parsedInit = await this.parseJSON(init);
+        }
+        return parsedInit;
     }
-    findGlobalConstantsHashAndValue(schema) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const globalConstantTokens = schema.findToken('constant');
-            const globalConstantsHashAndValue = {};
-            if (globalConstantTokens.length !== 0) {
-                for (const token of globalConstantTokens) {
-                    const tokenArgs = token.tokenVal.args;
-                    if (tokenArgs) {
-                        const expression = tokenArgs[0];
-                        if (expression.string) {
-                            const hash = expression.string;
-                            const michelineValue = yield this.context.globalConstantsProvider.getGlobalConstantByHash(hash);
-                            Object.assign(globalConstantsHashAndValue, {
-                                [hash]: michelineValue,
-                            });
-                        }
+    async findGlobalConstantsHashAndValue(schema) {
+        const globalConstantTokens = schema.findToken('constant');
+        const globalConstantsHashAndValue = {};
+        if (globalConstantTokens.length !== 0) {
+            for (const token of globalConstantTokens) {
+                const tokenArgs = token.tokenVal.args;
+                if (tokenArgs) {
+                    const expression = tokenArgs[0];
+                    if (expression.string) {
+                        const hash = expression.string;
+                        const michelineValue = await this.context.globalConstantsProvider.getGlobalConstantByHash(hash);
+                        Object.assign(globalConstantsHashAndValue, {
+                            [hash]: michelineValue,
+                        });
                     }
                 }
             }
-            return globalConstantsHashAndValue;
-        });
+        }
+        return globalConstantsHashAndValue;
     }
 }
 exports.MichelCodecParser = MichelCodecParser;

package/dist/lib/parser/noop-parser.js

@@ -1,20 +1,9 @@
 "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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NoopParser = void 0;
 class NoopParser {
-    prepareCodeOrigination(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return params;
-        });
+    async prepareCodeOrigination(params) {
+        return params;
     }
 }
 exports.NoopParser = NoopParser;