@partisiablockchain/abi-client 6.37.0 → 6.49.0

package/target/main/deploymentclient/DeploymentBuilder.js

@@ -27,14 +27,24 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeploymentBuilder = void 0;
-exports.getSupportedBinderVersions = getSupportedBinderVersions;
+exports.parsePubState = parsePubState;
 exports.findBinderId = findBinderId;
 exports.findFailureCause = findFailureCause;
+exports.parseAbi = parseAbi;
+exports.unsupportedBinderError = unsupportedBinderError;
+exports.unsupportedBinderDetails = unsupportedBinderDetails;
+exports.isSupported = isSupported;
+exports.validateInputFiles = validateInputFiles;
+exports.validatePubVersions = validatePubVersions;
+exports.validateRealVersions = validateRealVersions;
+exports.isSpecificNodes = isSpecificNodes;
+const DeploymentTypes_1 = require("./DeploymentTypes");
 const sections_1 = require("@partisiablockchain/sections");
 const AbiParser_1 = require("../parser/AbiParser");
 const StateReader_1 = require("../state/StateReader");
-const AbiVersion_1 = require("../model/AbiVersion");
 const RpcContractBuilder_1 = require("../rpc/RpcContractBuilder");
+const bitmanipulation_ts_1 = require("@secata-public/bitmanipulation-ts");
+const Configuration_1 = require("../parser/Configuration");
 class DeploymentBuilder {
     constructor(blockchainClient) {
         this.blockchainClient = blockchainClient;
@@ -49,63 +59,7 @@ class DeploymentBuilder {
      * @returns this builder
      */
     pbcFile(pbcFile) {
-        let pbc;
-        if (Buffer.isBuffer(pbcFile)) {
-            pbc = sections_1.PbcFile.fromBytes(pbcFile);
-        }
-        else {
-            pbc = pbcFile;
-        }
-        this.isZk = pbc.isZk;
-        this.abiBytes = pbc.getAbiBytes();
-        if (pbc.isZk) {
-            this.contractBytes = pbc.getZkwaBytes();
-        }
-        else {
-            this.contractBytes = pbc.getWasmBytes();
-        }
-        return this;
-    }
-    /**
-     * Set the abi of the contract to deploy.
-     *
-     * <p>It is required to provide the abi either through this method or through {@link #pbcFile}.
-     *
-     * @param abi abi bytes to deploy
-     * @returns this builder
-     */
-    abi(abi) {
-        this.abiBytes = abi;
-        return this;
-    }
-    /**
-     * Set the contract bytes of the contract to deploy. Using this function denotes that it is a zk
-     * contract you are trying to deploy.
-     *
-     * <p>It is required to provide the contract bytes either though this method, {@link wasm}, or
-     * {@link pbcFile}.
-     *
-     * @param zkwa contract bytes to deploy
-     * @returns this builder
-     */
-    zkwa(zkwa) {
-        this.isZk = true;
-        this.contractBytes = zkwa;
-        return this;
-    }
-    /**
-     * Set the contract bytes of the contract to deploy. Using this function denotes that it is a
-     * public contract you are trying to deploy.
-     *
-     * <p>It is required to provide the contract bytes either though this method, {@link #zkwa}, or
-     * {@link #pbcFile}.
-     *
-     * @param wasm contract bytes to deploy
-     * @returns this builder
-     */
-    wasm(wasm) {
-        this.isZk = false;
-        this.contractBytes = wasm;
+        this.pbcFileField = pbcFile;
         return this;
     }
     /**
@@ -164,6 +118,19 @@ class DeploymentBuilder {
         this.allowedJurisdictionsField = allowedJurisdictions;
         return this;
     }
+    /**
+     * Set the specific nodes that will be allocated to this zk contract.
+     *
+     * <p>This argument is not allowed if trying to deploy a public contract. It is not required if
+     * deploying a zk contract and nodes will by default be allocated according to the {@link #allowedJurisdictions}.
+     *
+     * @param nodes nodes to be allocated to this contract
+     * @returns this builder
+     */
+    specificNodes(nodes) {
+        this.specificNodesField = nodes;
+        return this;
+    }
     /**
      * Set the required stakes from the nodes selected for the deployed zk contract.
      *
@@ -179,19 +146,6 @@ class DeploymentBuilder {
         this.requiredStakesField = requiredStakes;
         return this;
     }
-    /**
-     * Set the binder id used to determine which binder to deploy the contract with.
-     *
-     * <p>This argument is not required. By default it will read the state of the deploy contract to
-     * find a binder which supports the given contract.
-     *
-     * @param binderId binder id
-     * @returns this builder
-     */
-    binderId(binderId) {
-        this.binderIdField = binderId;
-        return this;
-    }
     /**
      * Set the gas cost used to deploy the contract.
      *
@@ -216,24 +170,16 @@ class DeploymentBuilder {
      */
     buildRpc() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.validateRequiredParameters();
+            const validationResult = yield this.validateRequiredParameters();
             this.validateOptionalParameters();
-            const deployContract = yield this.blockchainClient
-                .getContract(this.deployContractAddressField)
-                .catch(() => {
-                throw new Error("Unable to get deploy contract state");
-            });
-            const deployAbiBytes = Buffer.from(deployContract.abi, "base64");
-            const deployState = Buffer.from(deployContract.serializedContract, "base64");
-            const deployAbi = new AbiParser_1.AbiParser(deployAbiBytes).parseAbi().contract();
-            const abiToBeDeployed = new AbiParser_1.AbiParser(this.abiBytes).parseAbi();
-            const binderId = this.determineBinderId(abiToBeDeployed, deployAbi, deployState);
-            const initializationBytes = this.getInitializationBytes(abiToBeDeployed);
-            if (this.isZk) {
-                return this.realDeployRpc(deployAbi, initializationBytes, binderId);
+            const initializationBytes = this.getInitializationBytes(validationResult.abi);
+            if (validationResult.abi.contract().isZk()) {
+                const realState = yield this.getRealState();
+                return this.realDeployRpc(realState.abi, validationResult, initializationBytes);
             }
             else {
-                return this.pubDeployRpc(deployAbi, initializationBytes, binderId);
+                const pubState = yield this.getPubState();
+                return DeploymentBuilder.createPubDeployRpc(pubState.abi, validationResult, initializationBytes);
             }
         });
     }
@@ -280,15 +226,22 @@ class DeploymentBuilder {
         });
     }
     validateRequiredParameters() {
-        if (this.contractBytes === undefined) {
-            throw new Error("Missing contract bytes");
-        }
-        if (this.abiBytes === undefined) {
-            throw new Error("Missing abi bytes");
-        }
-        if (this.initRpcBytes === undefined) {
-            throw new Error("Missing initialization bytes");
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            const validationResult = yield this.validateContract();
+            if (validationResult.type === DeploymentTypes_1.ResultType.INSUFFICIENT_INPUT) {
+                throw new Error("Missing contract files");
+            }
+            if (validationResult.type !== DeploymentTypes_1.ResultType.VALID) {
+                const details = validationResult.message.details === undefined
+                    ? ""
+                    : `\nDetails: [${validationResult.message.details.join(", ")}]`;
+                throw new Error(`${validationResult.message.title}: ${validationResult.message.summary}${details}`);
+            }
+            if (this.initRpcBytes === undefined) {
+                throw new Error("Missing initialization bytes");
+            }
+            return validationResult;
+        });
     }
     validateOptionalParameters() {
         if (this.deployContractAddressField === undefined) {
@@ -299,50 +252,49 @@ class DeploymentBuilder {
                 this.deployContractAddressField = DeploymentBuilder.DEFAULT_PUB_ADDRESS;
             }
         }
-        if (this.isZk && this.allowedJurisdictionsField === undefined) {
-            this.allowedJurisdictionsField = DeploymentBuilder.DEFAULT_ALLOWED_JURISDICTION;
-        }
         if (!this.isZk && this.allowedJurisdictionsField !== undefined) {
             throw new Error("Allowed jurisdictions is not allowed as argument to pub deploy");
         }
-        if (this.isZk && this.requiredStakesField === undefined) {
-            this.requiredStakesField = DeploymentBuilder.DEFAULT_REQUIRED_STAKES;
+        if (!this.isZk && this.specificNodesField !== undefined) {
+            throw new Error("Specific nodes is not allowed as argument to pub deploy");
         }
         if (!this.isZk && this.requiredStakesField !== undefined) {
             throw new Error("Required stakes is not allowed as argument to pub deploy");
         }
     }
-    determineBinderId(abiToBeDeployed, deployAbi, deployState) {
-        if (this.binderIdField !== undefined) {
-            return this.binderIdField;
-        }
-        const binderVersions = getSupportedBinderVersions(deployState, deployAbi);
-        const binderVersion = abiToBeDeployed.versionBinder;
-        return findBinderId(binderVersions, binderVersion);
-    }
-    realDeployRpc(deployAbi, initializationBytes, binderId) {
-        const fnBuilder = new RpcContractBuilder_1.RpcContractBuilder(deployAbi, "deployContractV3");
-        fnBuilder.addVecU8(this.contractBytes);
-        fnBuilder.addVecU8(initializationBytes);
-        fnBuilder.addVecU8(this.abiBytes);
-        fnBuilder.addI64(this.requiredStakesField);
-        const vecBuilder = fnBuilder.addVec();
-        for (const allowedJurisdiction of this.allowedJurisdictionsField) {
-            const vecVecBuilder = vecBuilder.addVec();
-            for (const allowed of allowedJurisdiction) {
-                vecVecBuilder.addI32(allowed);
+    /**
+     * Validate that the supplied contracts can be deployed.
+     */
+    validateContract() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const inputFilesResult = validateInputFiles(this.pbcFileField);
+                if (!inputFilesResult.ok) {
+                    return inputFilesResult.error;
+                }
+                this.isZk = inputFilesResult.value.abi.contract().isZk();
+                if (this.isZk) {
+                    const realState = yield this.getRealState();
+                    return validateRealVersions(realState, inputFilesResult.value.abi, inputFilesResult.value.pbcFile);
+                }
+                else {
+                    const pubState = yield this.getPubState();
+                    return validatePubVersions(pubState, inputFilesResult.value.abi, inputFilesResult.value.pbcFile);
+                }
             }
-        }
-        fnBuilder.addI32(binderId);
-        return fnBuilder.getBytes();
+            catch (e) {
+                const error = e;
+                return { type: DeploymentTypes_1.ResultType.ERROR, message: { title: error.name, summary: error.message } };
+            }
+        });
     }
-    pubDeployRpc(deployAbi, initializationBytes, binderId) {
-        const fnBuilder = new RpcContractBuilder_1.RpcContractBuilder(deployAbi, "deployContractWithBinderId");
-        fnBuilder.addVecU8(this.contractBytes);
-        fnBuilder.addVecU8(this.abiBytes);
-        fnBuilder.addVecU8(initializationBytes);
-        fnBuilder.addI32(binderId);
-        return fnBuilder.getBytes();
+    realDeployRpc(deployAbi, validationResult, initializationBytes) {
+        if (this.specificNodesField === undefined) {
+            return DeploymentBuilder.createRealDeployRpc(deployAbi, validationResult, initializationBytes, this.requiredStakesField, this.allowedJurisdictionsField);
+        }
+        else {
+            return DeploymentBuilder.createRealDeployRpc(deployAbi, validationResult, initializationBytes, this.requiredStakesField, this.specificNodesField);
+        }
     }
     getInitializationBytes(abiToBeDeployed) {
         if (Buffer.isBuffer(this.initRpcBytes)) {
@@ -353,6 +305,117 @@ class DeploymentBuilder {
         this.initRpcBytes(fnBuilder);
         return fnBuilder.getBytes();
     }
+    getPubState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.pubState === undefined) {
+                const deployContract = yield this.getContractState(DeploymentBuilder.DEFAULT_PUB_ADDRESS);
+                this.pubState = parsePubState(Buffer.from(deployContract.abi, "base64"), Buffer.from(deployContract.serializedContract, "base64"));
+            }
+            return this.pubState;
+        });
+    }
+    getRealState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.realState === undefined) {
+                const deployContract = yield this.getContractState(DeploymentBuilder.DEFAULT_REAL_ADDRESS);
+                this.realState = parseRealState(Buffer.from(deployContract.abi, "base64"), Buffer.from(deployContract.serializedContract, "base64"));
+            }
+            return this.realState;
+        });
+    }
+    getContractState(defaultDeployAddress) {
+        var _a;
+        return this.blockchainClient
+            .getContract((_a = this.deployContractAddressField) !== null && _a !== void 0 ? _a : defaultDeployAddress)
+            .catch(() => {
+            throw new Error("Unable to get deploy contract state");
+        });
+    }
+    /**
+     * Validate that the supplied pbc file can be deployed using a deploy contract with the given
+     * state.
+     *
+     * @param pubState state of the public deploy contract
+     * @param realState state of the REAL deploy contract
+     * @param pbcFile the contract files as a pbc file
+     * @return a validation result containing either the successful validation or the error message
+     */
+    static validateContract(pubState, realState, pbcFile) {
+        try {
+            const inputFilesResult = validateInputFiles(pbcFile);
+            if (!inputFilesResult.ok) {
+                return inputFilesResult.error;
+            }
+            if (inputFilesResult.value.abi.contract().isZk()) {
+                return validateRealVersions(realState, inputFilesResult.value.abi, inputFilesResult.value.pbcFile);
+            }
+            else {
+                return validatePubVersions(pubState, inputFilesResult.value.abi, inputFilesResult.value.pbcFile);
+            }
+        }
+        catch (e) {
+            const error = e;
+            return { type: DeploymentTypes_1.ResultType.ERROR, message: { title: error.name, summary: error.message } };
+        }
+    }
+    /**
+     * Create rpc needed for a deployment of public contract from a successful validation result and
+     * the contract initialization rpc.
+     *
+     * @param pubDeployAbi abi for the public deployment contract
+     * @param validationResult the successful deployment result
+     * @param initRpc the contract's initialization rpc
+     * @return the deployment rpc
+     */
+    static createPubDeployRpc(pubDeployAbi, validationResult, initRpc) {
+        const fnBuilder = new RpcContractBuilder_1.RpcContractBuilder(pubDeployAbi, "deployContractWithBinderId");
+        fnBuilder.addVecU8(validationResult.pbcFile.getWasmBytes());
+        fnBuilder.addVecU8(validationResult.pbcFile.getAbiBytes());
+        fnBuilder.addVecU8(initRpc);
+        fnBuilder.addI32(validationResult.binderId);
+        return fnBuilder.getBytes();
+    }
+    static createRealDeployRpc(realDeployAbi, validationResult, initRpc, requiredStakes, nodeSelection) {
+        const actualRequiredStakes = requiredStakes !== null && requiredStakes !== void 0 ? requiredStakes : DeploymentBuilder.DEFAULT_REQUIRED_STAKES;
+        if (validationResult.isRealV2) {
+            const fnBuilder = new RpcContractBuilder_1.RpcContractBuilder(realDeployAbi, "deployContractWithEe");
+            fnBuilder.addVecU8(validationResult.pbcFile.getZkwaBytes());
+            fnBuilder.addVecU8(validationResult.pbcFile.getAbiBytes());
+            fnBuilder.addVecU8(initRpc);
+            fnBuilder.addI32(validationResult.binderId);
+            return fnBuilder.getBytes();
+        }
+        else if (isSpecificNodes(nodeSelection)) {
+            const fnBuilder = new RpcContractBuilder_1.RpcContractBuilder(realDeployAbi, "deployContractWithSpecificNodes");
+            fnBuilder.addVecU8(validationResult.pbcFile.getZkwaBytes());
+            fnBuilder.addVecU8(initRpc);
+            fnBuilder.addVecU8(validationResult.pbcFile.getAbiBytes());
+            fnBuilder.addI64(actualRequiredStakes);
+            fnBuilder.addI32(validationResult.binderId);
+            fnBuilder.addAddress(nodeSelection[0]);
+            fnBuilder.addAddress(nodeSelection[1]);
+            fnBuilder.addAddress(nodeSelection[2]);
+            fnBuilder.addAddress(nodeSelection[3]);
+            return fnBuilder.getBytes();
+        }
+        else {
+            const allowedJurisdictions = nodeSelection !== null && nodeSelection !== void 0 ? nodeSelection : DeploymentBuilder.DEFAULT_ALLOWED_JURISDICTION;
+            const fnBuilder = new RpcContractBuilder_1.RpcContractBuilder(realDeployAbi, "deployContractV3");
+            fnBuilder.addVecU8(validationResult.pbcFile.getZkwaBytes());
+            fnBuilder.addVecU8(initRpc);
+            fnBuilder.addVecU8(validationResult.pbcFile.getAbiBytes());
+            fnBuilder.addI64(actualRequiredStakes);
+            const vecBuilder = fnBuilder.addVec();
+            for (const allowedJurisdiction of allowedJurisdictions) {
+                const vecVecBuilder = vecBuilder.addVec();
+                for (const allowed of allowedJurisdiction) {
+                    vecVecBuilder.addI32(allowed);
+                }
+            }
+            fnBuilder.addI32(validationResult.binderId);
+            return fnBuilder.getBytes();
+        }
+    }
 }
 exports.DeploymentBuilder = DeploymentBuilder;
 DeploymentBuilder.DEFAULT_PUB_ADDRESS = "0197a0e238e924025bad144aa0c4913e46308f9a4d";
@@ -361,14 +424,39 @@ DeploymentBuilder.DEFAULT_ALLOWED_JURISDICTION = [];
 DeploymentBuilder.DEFAULT_REQUIRED_STAKES = 20000000;
 DeploymentBuilder.DEFAULT_PUB_GAS_COST = 800000;
 DeploymentBuilder.DEFAULT_REAL_GAS_COST = 2000000;
-function getSupportedBinderVersions(deployState, deployAbi) {
-    const state = StateReader_1.StateReader.create(deployState, deployAbi).readState();
+function parsePubState(abi, serializedContract) {
+    const deployAbi = new AbiParser_1.AbiParser(abi).parseAbi().contract();
+    const state = StateReader_1.StateReader.create(serializedContract, deployAbi).readState();
     const binders = state.getFieldValue("binders").optionValue().innerValue.mapValue();
     const entries = [...binders.map.entries()].map(([k, v]) => [
         k.optionValue().innerValue.asNumber(),
-        versionIntervalFromScBinderInfo(v.optionValue().innerValue.structValue()),
+        { versionInterval: versionIntervalFromScBinderInfo(v.optionValue().innerValue.structValue()) },
     ]);
-    return new Map(entries);
+    return { binders: Object.fromEntries(entries), abi: deployAbi };
+}
+function parseRealState(abi, serializedContract) {
+    const deployAbi = new AbiParser_1.AbiParser(abi).parseAbi().contract();
+    const state = StateReader_1.StateReader.create(serializedContract, deployAbi).readState();
+    const binders = state.getFieldValue("binders").optionValue().innerValue.mapValue();
+    const entries = [...binders.map.entries()].map(([k, v]) => {
+        var _a;
+        const binderInfoStruct = v.optionValue().innerValue.structValue();
+        return [
+            k.optionValue().innerValue.asNumber(),
+            {
+                versionInterval: versionIntervalFromScBinderInfo(binderInfoStruct),
+                supportedZkbcVersionMax: versionFromScVersion(binderInfoStruct
+                    .getFieldValue("supportedZkbcVersionMax")
+                    .optionValue()
+                    .innerValue.structValue()),
+                usedEeVersion: (_a = binderInfoStruct
+                    .getFieldValue("usedEeVersion")
+                    .optionValue()
+                    .innerValue) === null || _a === void 0 ? void 0 : _a.asNumber(),
+            },
+        ];
+    });
+    return { binders: Object.fromEntries(entries), abi: deployAbi };
 }
 function versionIntervalFromScBinderInfo(binderInfo) {
     const versionInterval = binderInfo
@@ -383,19 +471,26 @@ function versionIntervalFromScBinderInfo(binderInfo) {
         .getFieldValue("supportedBinderVersionMax")
         .optionValue()
         .innerValue.structValue();
-    const min = new AbiVersion_1.AbiVersion(scMin.getFieldValue("major").asNumber(), scMin.getFieldValue("minor").asNumber(), scMin.getFieldValue("patch").asNumber());
-    const max = new AbiVersion_1.AbiVersion(scMax.getFieldValue("major").asNumber(), scMax.getFieldValue("minor").asNumber(), scMax.getFieldValue("patch").asNumber());
-    return { min, max };
+    const supportedBinderVersionMin = versionFromScVersion(scMin);
+    const supportedBinderVersionMax = versionFromScVersion(scMax);
+    return { supportedBinderVersionMin, supportedBinderVersionMax };
+}
+function versionFromScVersion(scVersion) {
+    return {
+        major: scVersion.getFieldValue("major").asNumber(),
+        minor: scVersion.getFieldValue("minor").asNumber(),
+        patch: scVersion.getFieldValue("patch").asNumber(),
+    };
 }
 function findBinderId(binders, binderVersion) {
-    const entry = [...binders.entries()].find(([_, v]) => checkDeployVersion(binderVersion, v));
+    const entry = [...Object.entries(binders)].find(([_, v]) => checkDeployVersion(binderVersion, v.versionInterval));
     if (entry === undefined) {
-        throw new Error("No binders exists supporting version " + binderVersion.toString());
+        return undefined;
     }
-    return entry[0];
+    return parseInt(entry[0]);
 }
 function checkDeployVersion(binderVersion, versionInterval) {
-    return checkVersion(binderVersion, versionInterval.max.major, versionInterval.max.minor, versionInterval.min.major, versionInterval.min.minor);
+    return checkVersion(binderVersion, versionInterval.supportedBinderVersionMax.major, versionInterval.supportedBinderVersionMax.minor, versionInterval.supportedBinderVersionMin.major, versionInterval.supportedBinderVersionMin.minor);
 }
 function checkVersion(binderVersion, maxMajor, maxMinor, minMajor, minMinor) {
     return (maxMajor >= binderVersion.major &&
@@ -416,4 +511,177 @@ function executedToErrorMsg(executedTransaction) {
     }
     return executedTransaction.executionStatus.failure.errorMessage;
 }
+function parseAbi(abiBytes) {
+    const abiParser = new AbiParser_1.AbiParser(abiBytes);
+    const header = abiParser.parseHeader();
+    if (Configuration_1.Configuration.isSupportedVersion(header.versionClient)) {
+        return { ok: true, value: abiParser.parseChainComponent(header) };
+    }
+    else {
+        const supportedVersions = Configuration_1.Configuration.getSupportedVersions();
+        return {
+            ok: false,
+            error: {
+                type: DeploymentTypes_1.ResultType.ERROR,
+                message: {
+                    title: "Invalid abi",
+                    summary: `Unsupported client ABI version ${header.versionClient.toString()}.`,
+                    details: [
+                        `Latest supported version is ${supportedVersions[supportedVersions.length - 1].toString()}`,
+                    ],
+                },
+            },
+        };
+    }
+}
+function unsupportedBinderError(abi, binders) {
+    return {
+        type: DeploymentTypes_1.ResultType.ERROR,
+        message: {
+            title: "Version Error",
+            summary: "The contract requires a binder version that is not supported by the blockchain.",
+            details: unsupportedBinderDetails(abi.versionBinder, Object.values(binders).map((binder) => binder.versionInterval.supportedBinderVersionMax)),
+        },
+    };
+}
+function unsupportedBinderDetails(contractVersion, supportedVersions) {
+    var _a;
+    const max = (_a = maxVersion(supportedVersions.filter((version) => version.major === contractVersion.major))) !== null && _a !== void 0 ? _a : maxVersion(supportedVersions);
+    if (max === undefined) {
+        return ["No binders are available"];
+    }
+    else if (isGreater(contractVersion, max)) {
+        return [
+            "Contract requires a too new binder version " + versionToString(contractVersion),
+            "Blockchain supports latest version " + versionToString(max),
+            "Please downgrade your contract-sdk",
+        ];
+    }
+    else {
+        return [
+            "Contract requires a too old binder version " + versionToString(contractVersion),
+            "Blockchain supports latest version " + versionToString(max),
+            "Please update your contract-sdk",
+        ];
+    }
+}
+function maxVersion(versions) {
+    // Stryker disable next-line BlockStatement
+    if (versions.length === 0) {
+        return undefined;
+    }
+    else {
+        return versions.reduce((acc, val) => (isGreater(acc, val) ? acc : val));
+    }
+}
+function isGreater(version1, version2) {
+    return (version1.major > version2.major ||
+        (version1.major === version2.major && version1.minor > version2.minor));
+}
+function versionToString(version) {
+    return `${version.major}.${version.minor}.0`;
+}
+function invalidContractTypeError(contractType) {
+    return {
+        type: DeploymentTypes_1.ResultType.ERROR,
+        message: {
+            title: "Invalid Contract Type",
+            summary: `Deployment of ${contractType} contracts is currently disabled.`,
+        },
+    };
+}
+function unsupportedZkbcError(zkbcVersion, supportedZkbcVersionMax) {
+    return {
+        type: DeploymentTypes_1.ResultType.ERROR,
+        message: {
+            title: "Version Error",
+            summary: "The contract requires a ZKBC version that the binder doesn't support",
+            details: [
+                `Contract requires version ${zkbcVersion.major}.${zkbcVersion.minor}.0`,
+                `Binder supports up to version ${supportedZkbcVersionMax.major}.${supportedZkbcVersionMax.minor}.0`,
+            ],
+        },
+    };
+}
+function extractZkbcVersion(pbcFile) {
+    const zkbcBytes = pbcFile.getZkbcBytes();
+    const stream = new bitmanipulation_ts_1.BigEndianByteInput(zkbcBytes);
+    stream.readBytes(4); // Magic bytes
+    const major = stream.readI16();
+    const minor = stream.readI16();
+    return { major, minor, patch: 0 };
+}
+function isSupported(zkbcVersion, supportedZkbcVersionMax) {
+    return (zkbcVersion.major === supportedZkbcVersionMax.major &&
+        zkbcVersion.minor <= supportedZkbcVersionMax.minor);
+}
+/**
+ * Parse and validate that the ABI is well-formed.
+ *
+ * @param pbcFile pbc file to validate
+ * @return result of the parsed abi of the error if it couldn't be parsed
+ */
+function validateInputFiles(pbcFile) {
+    if (pbcFile === undefined) {
+        return { ok: false, error: { type: DeploymentTypes_1.ResultType.INSUFFICIENT_INPUT } };
+    }
+    let pbc;
+    if (Buffer.isBuffer(pbcFile)) {
+        pbc = sections_1.PbcFile.fromBytes(pbcFile);
+    }
+    else {
+        pbc = pbcFile;
+    }
+    const abiResult = parseAbi(pbc.getAbiBytes());
+    if (!abiResult.ok) {
+        return abiResult;
+    }
+    return { ok: true, value: { pbcFile: pbc, abi: abiResult.value } };
+}
+/**
+ * Validate that the there exists a public binder that the supports the contract being deployed.
+ *
+ * @param pubState state of public deploy contract
+ * @param abi parsed abi of the contract to be deployed
+ * @param pbcFile pbc file containing the contract files
+ * @return a validation result containing either the successful validation or the error message
+ */
+function validatePubVersions(pubState, abi, pbcFile) {
+    if (pubState === undefined) {
+        return invalidContractTypeError("PUBLIC");
+    }
+    const binderId = findBinderId(pubState.binders, abi.versionBinder);
+    if (binderId === undefined) {
+        return unsupportedBinderError(abi, pubState.binders);
+    }
+    return { type: DeploymentTypes_1.ResultType.VALID, abi, pbcFile, binderId, isRealV2: false };
+}
+/**
+ * Validate that the there exists a REAL binder that the supports the contract being deployed.
+ *
+ * @param realState state of REAL deploy contract
+ * @param abi parsed abi of the contract to be deployed
+ * @param pbcFile pbc file containing the contract files
+ * @return a validation result containing either the successful validation or the error message
+ */
+function validateRealVersions(realState, abi, pbcFile) {
+    if (realState === undefined) {
+        return invalidContractTypeError("MPC");
+    }
+    const binderId = findBinderId(realState.binders, abi.versionBinder);
+    if (binderId === undefined) {
+        return unsupportedBinderError(abi, realState.binders);
+    }
+    const zkbcVersion = extractZkbcVersion(pbcFile);
+    const binder = realState.binders[binderId];
+    const supportedZkbcVersionMax = binder.supportedZkbcVersionMax;
+    if (!isSupported(zkbcVersion, supportedZkbcVersionMax)) {
+        return unsupportedZkbcError(zkbcVersion, supportedZkbcVersionMax);
+    }
+    const isRealV2 = binder.usedEeVersion !== undefined;
+    return { type: DeploymentTypes_1.ResultType.VALID, abi, pbcFile, binderId, isRealV2 };
+}
+function isSpecificNodes(nodeSelection) {
+    return nodeSelection !== undefined && typeof nodeSelection[0] === "string";
+}
 //# sourceMappingURL=DeploymentBuilder.js.map