@taquito/local-forging 11.2.0 → 12.0.1

package/dist/taquito-local-forging.es6.js

@@ -1,4 +1,4 @@
-import { Prefix, prefixLength, b58cencode, prefix, buf2hex, b58cdecode } from '@taquito/utils';
+import { Prefix, prefixLength, b58cencode, prefix, buf2hex, b58cdecode, validateBlock, ValidationResult } from '@taquito/utils';
 import BigNumber$1, { BigNumber } from 'bignumber.js';
 
 const toHexString = (bytes) => bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '');
@@ -27,6 +27,7 @@ var CODEC;
     CODEC["PROPOSAL"] = "proposal";
     CODEC["PROPOSAL_ARR"] = "proposalArr";
     CODEC["INT32"] = "int32";
+    CODEC["INT16"] = "int16";
     CODEC["PARAMETERS"] = "parameters";
     CODEC["ADDRESS"] = "address";
     CODEC["OPERATION"] = "operation";
@@ -212,7 +213,7 @@ const kindMapping = {
     0x00: 'endorsement',
     0x01: 'seed_nonce_revelation',
     0x05: 'proposals',
-    0x6f: 'register_global_constant'
+    0x6f: 'register_global_constant',
 };
 const kindMappingReverse = (() => {
     const result = {};
@@ -236,7 +237,21 @@ const entrypointMappingReverse = (() => {
         result[entrypointMapping[key]] = key;
     });
     return result;
-})();
+})();
+var ProtocolsHash;
+(function (ProtocolsHash) {
+    ProtocolsHash["Pt24m4xi"] = "Pt24m4xiPbLDhVgVfABUjirbmda3yohdN82Sp9FeuAXJ4eV9otd";
+    ProtocolsHash["PsBABY5H"] = "PsBABY5HQTSkA4297zNHfsZNKtxULfL18y95qb3m53QJiXGmrbU";
+    ProtocolsHash["PsBabyM1"] = "PsBabyM1eUXZseaJdmXFApDSBqj8YBfwELoxZHHW77EMcAbbwAS";
+    ProtocolsHash["PsCARTHA"] = "PsCARTHAGazKbHtnKfLzQg3kms52kSRpgnDY982a9oYsSXRLQEb";
+    ProtocolsHash["PsDELPH1"] = "PsDELPH1Kxsxt8f9eWbxQeRxkjfbxoqM52jvs5Y5fBxWWh4ifpo";
+    ProtocolsHash["PtEdo2Zk"] = "PtEdo2ZkT9oKpimTah6x2embF25oss54njMuPzkJTEi5RqfdZFA";
+    ProtocolsHash["PsFLorena"] = "PsFLorenaUUuikDWvMDr6fGBRG8kt3e3D3fHoXK1j1BFRxeSH4i";
+    ProtocolsHash["PtGRANADs"] = "PtGRANADsDU8R9daYKAgWnQYAJ64omN1o3KMGVCykShA97vQbvV";
+    ProtocolsHash["PtHangz2"] = "PtHangz2aRngywmSRGGvrcTyMbbdpWdpFKuS4uMWxg2RaH9i1qx";
+    ProtocolsHash["PsiThaCa"] = "PsiThaCaT47Zboaw71QWScM8sXeMM7bbQFncK9FLqYc6EKdpjVP";
+    ProtocolsHash["Psithaca2"] = "Psithaca2MLRFYargivpo7YvUr7wUDqyxrdhC5CQq78mRvimz6A";
+})(ProtocolsHash || (ProtocolsHash = {}));
 
 class Uint8ArrayConsumer {
     constructor(arr, offset = 0) {
@@ -593,6 +608,23 @@ const int32Decoder = (val) => {
     }
     return finalNum;
 };
+const int16Encoder = (val) => {
+    const num = parseInt(String(val), 10);
+    const byte = [];
+    for (let i = 0; i < 2; i++) {
+        const shiftBy = (2 - (i + 1)) * 8;
+        byte.push((num & (0xff << shiftBy)) >> shiftBy);
+    }
+    return Buffer.from(byte).toString('hex');
+};
+const int16Decoder = (val) => {
+    const num = val.consume(2);
+    let finalNum = 0;
+    for (let i = 0; i < num.length; i++) {
+        finalNum = finalNum | (num[i] << ((num.length - (i + 1)) * 8));
+    }
+    return finalNum;
+};
 const boolDecoder = (val) => {
     const bool = val.consume(1);
     return bool[0] === 0xff;
@@ -893,7 +925,7 @@ const schemaDecoder = (decoders) => (schema) => (value) => {
         else {
             const decoder = decoders[valueToEncode];
             const result = decoder(value);
-            if (result) {
+            if (typeof result !== 'undefined') {
                 return Object.assign(Object.assign({}, prev), { [key]: result });
             }
             else {
@@ -965,30 +997,226 @@ encoders[CODEC.OP_REVEAL] = (val) => schemaEncoder(encoders)(RevealSchema)(val);
 encoders[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaEncoder(encoders)(RegisterGlobalConstantSchema)(val);
 encoders[CODEC.MANAGER] = schemaEncoder(encoders)(ManagerOperationSchema);
 
+const blockPayloadHashEncoder = prefixEncoder(Prefix.VH);
+const blockPayloadHashDecoder = prefixDecoder(Prefix.VH);
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+const kindMappingNoEndorsement = __rest(kindMapping, ["0"]);
+const kindMappingProto12 = Object.assign(Object.assign({}, kindMappingNoEndorsement), { 0x15: 'endorsement' });
+const kindMappingReverseProto12 = (() => {
+    const result = {};
+    Object.keys(kindMappingProto12).forEach((key) => {
+        const keyNum = typeof key === 'string' ? parseInt(key, 10) : key;
+        result[kindMappingProto12[keyNum]] = pad(keyNum, 2);
+    });
+    return result;
+})();
+
+const EndorsementSchemaProto12 = {
+    slot: 'int16',
+    level: 'int32',
+    round: 'int32',
+    block_payload_hash: 'blockPayloadHash',
+};
+const operationEncoderProto12 = (encoders) => (operation) => {
+    if (!(operation.kind in encoders) || !(operation.kind in kindMappingReverseProto12)) {
+        throw new Error(`Unsupported operation kind: ${operation.kind}`);
+    }
+    return kindMappingReverseProto12[operation.kind] + encoders[operation.kind](operation);
+};
+const operationDecoderProto12 = (decoders) => (value) => {
+    const op = value.consume(1);
+    const operationName = kindMappingProto12[op[0]];
+    const decodedObj = decoders[operationName](value);
+    if (typeof decodedObj !== 'object') {
+        throw new Error('Decoded invalid operation');
+    }
+    if (operationName) {
+        return Object.assign({ kind: operationName }, decodedObj);
+    }
+    else {
+        throw new Error(`Unsupported operation ${op[0]}`);
+    }
+};
+
+const decodersProto12 = Object.assign(Object.assign({}, decoders), { [CODEC.INT16]: int16Decoder, ["blockPayloadHash" /* BLOCK_PAYLOAD_HASH */]: blockPayloadHashDecoder });
+decodersProto12[CODEC.OPERATION] = operationDecoderProto12(decodersProto12);
+decodersProto12[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaDecoder(decodersProto12)(ActivationSchema)(val);
+decodersProto12[CODEC.OP_DELEGATION] = (val) => schemaDecoder(decodersProto12)(DelegationSchema)(val);
+decodersProto12[CODEC.OP_TRANSACTION] = (val) => schemaDecoder(decodersProto12)(TransactionSchema)(val);
+decodersProto12[CODEC.OP_ORIGINATION] = (val) => schemaDecoder(decodersProto12)(OriginationSchema)(val);
+decodersProto12[CODEC.OP_BALLOT] = (val) => schemaDecoder(decodersProto12)(BallotSchema)(val);
+decodersProto12[CODEC.OP_ENDORSEMENT] = (val) => schemaDecoder(decodersProto12)(EndorsementSchemaProto12)(val);
+decodersProto12[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaDecoder(decodersProto12)(SeedNonceRevelationSchema)(val);
+decodersProto12[CODEC.OP_PROPOSALS] = (val) => schemaDecoder(decodersProto12)(ProposalsSchema)(val);
+decodersProto12[CODEC.OP_REVEAL] = (val) => schemaDecoder(decodersProto12)(RevealSchema)(val);
+decodersProto12[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaDecoder(decodersProto12)(RegisterGlobalConstantSchema)(val);
+decodersProto12[CODEC.MANAGER] = schemaDecoder(decodersProto12)(ManagerOperationSchema);
+
+const encodersProto12 = Object.assign(Object.assign({}, encoders), { [CODEC.INT16]: int16Encoder, ["blockPayloadHash" /* BLOCK_PAYLOAD_HASH */]: blockPayloadHashEncoder });
+encodersProto12[CODEC.OPERATION] = operationEncoderProto12(encodersProto12);
+encodersProto12[CODEC.OP_ACTIVATE_ACCOUNT] = (val) => schemaEncoder(encodersProto12)(ActivationSchema)(val);
+encodersProto12[CODEC.OP_DELEGATION] = (val) => schemaEncoder(encodersProto12)(DelegationSchema)(val);
+encodersProto12[CODEC.OP_TRANSACTION] = (val) => schemaEncoder(encodersProto12)(TransactionSchema)(val);
+encodersProto12[CODEC.OP_ORIGINATION] = (val) => schemaEncoder(encodersProto12)(OriginationSchema)(val);
+encodersProto12[CODEC.OP_BALLOT] = (val) => schemaEncoder(encodersProto12)(BallotSchema)(val);
+encodersProto12[CODEC.OP_ENDORSEMENT] = (val) => schemaEncoder(encodersProto12)(EndorsementSchemaProto12)(val);
+encodersProto12[CODEC.OP_SEED_NONCE_REVELATION] = (val) => schemaEncoder(encodersProto12)(SeedNonceRevelationSchema)(val);
+encodersProto12[CODEC.OP_PROPOSALS] = (val) => schemaEncoder(encodersProto12)(ProposalsSchema)(val);
+encodersProto12[CODEC.OP_REVEAL] = (val) => schemaEncoder(encodersProto12)(RevealSchema)(val);
+encodersProto12[CODEC.OP_REGISTER_GLOBAL_CONSTANT] = (val) => schemaEncoder(encodersProto12)(RegisterGlobalConstantSchema)(val);
+encodersProto12[CODEC.MANAGER] = schemaEncoder(encodersProto12)(ManagerOperationSchema);
+
+class InvalidBlockHashError extends Error {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.name = 'InvalidBlockHashError';
+    }
+}
+class InvalidOperationSchemaError extends Error {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.name = 'InvalidOperationSchemaError';
+    }
+}
+class InvalidOperationKindError extends Error {
+    constructor(message) {
+        super(message);
+        this.message = message;
+        this.name = 'InvalidOperationKindError';
+    }
+}
+
+const OperationKindMapping = {
+    activate_account: ActivationSchema,
+    reveal: RevealSchema,
+    delegation: DelegationSchema,
+    transaction: TransactionSchema,
+    origination: OriginationSchema,
+    ballot: BallotSchema,
+    endorsement: EndorsementSchema,
+    seed_nonce_revelation: SeedNonceRevelationSchema,
+    proposals: ProposalsSchema,
+    register_global_constant: RegisterGlobalConstantSchema,
+};
+// Asymmetric difference: only account for things in arr2 that are not present in arr1, not vice versa
+const getArrayDifference = (arr1, arr2) => {
+    return arr2.filter((x) => !arr1.includes(x));
+};
+const deleteArrayElementByValue = (array, item) => {
+    return array.filter((e) => e !== item);
+};
+/**
+ * @returns A boolean value to indicate whether the operation kind is valid or not
+ */
+const validateOperationKind = (opKind) => {
+    const opKindList = Object.keys(OperationKindMapping);
+    return opKindList.includes(opKind);
+};
+/**
+ *  returns 0 when the two array of properties are identical or the passed property
+ *  does not have any missing parameters from the corresponding schema
+ *
+ *  @returns array element differences if there are missing required property keys
+ */
+const validateMissingProperty = (operationContent) => {
+    const kind = operationContent.kind;
+    const keys = Object.keys(operationContent);
+    const cleanKeys = deleteArrayElementByValue(keys, 'kind');
+    const schemaKeys = Object.keys(OperationKindMapping[kind]);
+    return getArrayDifference(cleanKeys, schemaKeys);
+};
+
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
 const VERSION = {
-    "commitHash": "81f0a5b103f867f57fbe5d526315c375a3788346",
-    "version": "11.2.0"
+    "commitHash": "8203ea7669c742797022f1b61f2577bcac50ca55",
+    "version": "12.0.1"
 };
 
 /**
  * @packageDocumentation
  * @module @taquito/local-forging
  */
-function getCodec(codec) {
-    return {
-        encoder: encoders[codec],
-        decoder: (hex) => {
-            const consumer = Uint8ArrayConsumer.fromHexString(hex);
-            return decoders[codec](consumer);
-        },
-    };
+function getCodec(codec, proto) {
+    if (proto === ProtocolsHash.Psithaca2) {
+        return {
+            encoder: encodersProto12[codec],
+            decoder: (hex) => {
+                const consumer = Uint8ArrayConsumer.fromHexString(hex);
+                return decodersProto12[codec](consumer);
+            },
+        };
+    }
+    else {
+        return {
+            encoder: encoders[codec],
+            decoder: (hex) => {
+                const consumer = Uint8ArrayConsumer.fromHexString(hex);
+                return decoders[codec](consumer);
+            },
+        };
+    }
 }
 class LocalForger {
-    constructor() {
-        this.codec = getCodec(CODEC.MANAGER);
+    constructor(protocolHash = ProtocolsHash.Psithaca2) {
+        this.protocolHash = protocolHash;
+        this.codec = getCodec(CODEC.MANAGER, this.protocolHash);
     }
     forge(params) {
+        if (validateBlock(params.branch) !== ValidationResult.VALID) {
+            throw new InvalidBlockHashError(`The block hash ${params.branch} is invalid`);
+        }
+        for (const content of params.contents) {
+            if (!validateOperationKind(content.kind)) {
+                throw new InvalidOperationKindError(`The operation kind '${content.kind}' does not exist`);
+            }
+            const diff = validateMissingProperty(content);
+            if (diff.length === 1) {
+                if (content.kind === 'delegation' && diff[0] === 'delegate') {
+                    continue;
+                }
+                else if (content.kind === 'origination' && diff[0] === 'delegate') {
+                    continue;
+                }
+                else if (content.kind === 'transaction' && diff[0] === 'parameters') {
+                    continue;
+                }
+                else {
+                    throw new InvalidOperationSchemaError(`Missing properties: ${diff.join(', ').toString()}`);
+                }
+            }
+            else if (diff.length > 1) {
+                throw new InvalidOperationSchemaError(`Missing properties: ${diff.join(', ').toString()}`);
+            }
+        }
         return Promise.resolve(this.codec.encoder(params));
     }
     parse(hex) {
@@ -997,5 +1225,5 @@ class LocalForger {
 }
 const localForger = new LocalForger();
 
-export { CODEC, LocalForger, Uint8ArrayConsumer, VERSION, decoders, encoders, getCodec, localForger };
+export { CODEC, LocalForger, ProtocolsHash, Uint8ArrayConsumer, VERSION, decoders, encoders, getCodec, localForger };
 //# sourceMappingURL=taquito-local-forging.es6.js.map