@tezos-x/octez.js 0.9.0

package/dist/lib/forger/composite-forger.js

@@ -0,0 +1,43 @@
+"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.CompositeForger = void 0;
+const errors_1 = require("./errors");
+class CompositeForger {
+    constructor(forgers) {
+        this.forgers = forgers;
+        if (forgers.length === 0) {
+            throw new errors_1.UnspecifiedForgerError();
+        }
+    }
+    forge(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ branch, contents }) {
+            const results = yield Promise.all(this.forgers.map((forger) => {
+                return forger.forge({ branch, contents });
+            }));
+            if (results.length === 0) {
+                throw new errors_1.UnspecifiedForgerError();
+            }
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            let lastResult = results.pop(); // Assumed to be more than one since we
+            while (results.length) {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const currentResult = results.pop();
+                if (currentResult !== lastResult) {
+                    throw new errors_1.ForgingMismatchError([lastResult, currentResult]);
+                }
+                lastResult = currentResult;
+            }
+            return lastResult;
+        });
+    }
+}
+exports.CompositeForger = CompositeForger;

package/dist/lib/forger/errors.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnspecifiedForgerError = exports.ForgingMismatchError = void 0;
+const octez_js_core_1 = require("@tezos-x/octez.js-core");
+/**
+ *  @category Error
+ *  @description Error that indicates CompositeForger.forge() results doesn't match each other
+ */
+class ForgingMismatchError extends octez_js_core_1.TaquitoError {
+    constructor(results) {
+        super();
+        this.results = results;
+        this.name = 'ForgingMismatchError';
+        this.message = `Forging mismatch error`;
+    }
+}
+exports.ForgingMismatchError = ForgingMismatchError;
+/**
+ *  @category Error
+ *  @description Error that indicates no forger has been configured for CompositeForger
+ */
+class UnspecifiedForgerError extends octez_js_core_1.TezosToolkitConfigError {
+    constructor() {
+        super();
+        this.name = 'UnspecifiedForgerError';
+        this.message =
+            'No forger has been configured. Please configure new CompositeForger([rpcForger, localForger]) with your TezosToolkit instance.';
+    }
+}
+exports.UnspecifiedForgerError = UnspecifiedForgerError;

package/dist/lib/forger/octez.js-local-forger.js

@@ -0,0 +1,34 @@
+"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.TaquitoLocalForger = void 0;
+const octez_js_local_forging_1 = require("@tezos-x/octez.js-local-forging");
+class TaquitoLocalForger {
+    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;
+        });
+    }
+    forge(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ branch, contents }) {
+            const forger = new octez_js_local_forging_1.LocalForger(yield this.getNextProto());
+            return forger.forge({ branch, contents });
+        });
+    }
+}
+exports.TaquitoLocalForger = TaquitoLocalForger;

package/dist/lib/forger/rpc-forger.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcForger = void 0;
+class RpcForger {
+    constructor(context) {
+        this.context = context;
+    }
+    forge({ branch, contents }) {
+        return this.context.rpc.forgeOperations({ branch, contents });
+    }
+}
+exports.RpcForger = RpcForger;

package/dist/lib/global-constants/default-global-constants-provider.js

@@ -0,0 +1,46 @@
+"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.DefaultGlobalConstantsProvider = void 0;
+const errors_1 = require("./errors");
+class DefaultGlobalConstantsProvider {
+    constructor() {
+        this._globalConstantsLibrary = {};
+    }
+    /**
+     *
+     * @description Allows to load global constant hashes and their corresponding Michelson JSON values
+     */
+    loadGlobalConstant(globalConstant) {
+        for (const hash in globalConstant) {
+            Object.assign(this._globalConstantsLibrary, {
+                [hash]: globalConstant[hash],
+            });
+        }
+    }
+    /**
+     *
+     * @description Retrieve the Michelson value of a global constant based on its hash
+     *
+     * @param hash a string representing the global constant hash
+     * @returns Expr, the JSON Michelson value
+     */
+    getGlobalConstantByHash(hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const value = this._globalConstantsLibrary[hash];
+            if (!value) {
+                throw new errors_1.GlobalConstantNotFound(hash);
+            }
+            return value;
+        });
+    }
+}
+exports.DefaultGlobalConstantsProvider = DefaultGlobalConstantsProvider;

package/dist/lib/global-constants/errors.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnconfiguredGlobalConstantsProviderError = exports.GlobalConstantNotFound = void 0;
+const octez_js_core_1 = require("@tezos-x/octez.js-core");
+/**
+ *  @category Error
+ *  @description Error that indicates that a global constant does not exist
+ */
+class GlobalConstantNotFound extends octez_js_core_1.TaquitoError {
+    constructor(hash) {
+        super();
+        this.hash = hash;
+        this.name = 'GlobalConstantNotFound';
+        this.message = `Please load the value associated with the constant ${hash} using the loadGlobalConstant method of the DefaultGlobalConstantsProvider.`;
+    }
+}
+exports.GlobalConstantNotFound = GlobalConstantNotFound;
+/**
+ *  @category Error
+ *  @description Error that indicates the global constant provider not being configured under TezosToolkit
+ */
+class UnconfiguredGlobalConstantsProviderError extends octez_js_core_1.TezosToolkitConfigError {
+    constructor() {
+        super();
+        this.name = 'UnconfiguredGlobalConstantsProviderError';
+        this.message =
+            'No global constants provider has been configured. Please configure one by calling setGlobalConstantsProvider({globalConstantsProvider}) on your TezosToolkit instance.';
+    }
+}
+exports.UnconfiguredGlobalConstantsProviderError = UnconfiguredGlobalConstantsProviderError;

package/dist/lib/global-constants/interface-global-constants-provider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/global-constants/noop-global-constants-provider.js

@@ -0,0 +1,21 @@
+"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.NoopGlobalConstantsProvider = void 0;
+const errors_1 = require("./errors");
+class NoopGlobalConstantsProvider {
+    getGlobalConstantByHash(_hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new errors_1.UnconfiguredGlobalConstantsProviderError();
+        });
+    }
+}
+exports.NoopGlobalConstantsProvider = NoopGlobalConstantsProvider;

package/dist/lib/import-key.js

@@ -0,0 +1,51 @@
+"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.importKey = importKey;
+const octez_js_signer_1 = require("@tezos-x/octez.js-signer");
+/**
+ *
+ * @description Import a key to sign operation with the side-effect of setting the Tezos instance to use the InMemorySigner provider
+ *
+ * @warn The JSON faucets are no longer available on https://teztnets.com/
+ * @param toolkit The toolkit instance to attach a signer
+ * @param privateKeyOrEmail Key to load in memory
+ * @param passphrase If the key is encrypted passphrase to decrypt it
+ * @param mnemonic Faucet mnemonic
+ * @param secret Faucet secret
+ */
+function importKey(toolkit, privateKeyOrEmail, passphrase, mnemonic, secret) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (privateKeyOrEmail && passphrase && mnemonic && secret) {
+            const signer = octez_js_signer_1.InMemorySigner.fromFundraiser(privateKeyOrEmail, passphrase, mnemonic);
+            toolkit.setProvider({ signer });
+            const pkh = yield signer.publicKeyHash();
+            let op;
+            try {
+                op = yield toolkit.tz.activate(pkh, secret);
+            }
+            catch (ex) {
+                const isInvalidActivationError = ex && ex.body && /Invalid activation/.test(ex.body);
+                if (!isInvalidActivationError) {
+                    throw ex;
+                }
+            }
+            if (op) {
+                yield op.confirmation();
+            }
+        }
+        else {
+            // Fallback to regular import
+            const signer = yield octez_js_signer_1.InMemorySigner.fromSecretKey(privateKeyOrEmail, passphrase);
+            toolkit.setProvider({ signer });
+        }
+    });
+}

package/dist/lib/injector/helper.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatErrorMessage = formatErrorMessage;
+const octez_js_http_utils_1 = require("@tezos-x/octez.js-http-utils");
+function formatErrorMessage(error, stringToReplace) {
+    const body = JSON.parse(error.body);
+    if (body[0] && body[0].kind && body[0].msg) {
+        const newBody = JSON.stringify({
+            kind: body[0].kind,
+            id: body[0].id,
+            msg: body[0].msg.replace(stringToReplace, ''),
+        });
+        return new octez_js_http_utils_1.HttpResponseError(`Http error response: (${error.status}) ${newBody}`, error.status, error.statusText, newBody, error.url);
+    }
+    else {
+        return error;
+    }
+}

package/dist/lib/injector/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/injector/rpc-injector.js

@@ -0,0 +1,38 @@
+"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.RpcInjector = void 0;
+const helper_1 = require("./helper");
+const octez_js_http_utils_1 = require("@tezos-x/octez.js-http-utils");
+class RpcInjector {
+    constructor(context) {
+        this.context = context;
+    }
+    inject(signedOperationBytes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let hash;
+            try {
+                hash = yield this.context.rpc.injectOperation(signedOperationBytes);
+            }
+            catch (error) {
+                const stringToStrip = '. You may want to use --replace to provide adequate fee and replace it';
+                if (error instanceof octez_js_http_utils_1.HttpResponseError && error.message.includes(stringToStrip)) {
+                    throw (0, helper_1.formatErrorMessage)(error, stringToStrip);
+                }
+                else {
+                    throw error;
+                }
+            }
+            return hash;
+        });
+    }
+}
+exports.RpcInjector = RpcInjector;