adding workerregistry and workorderregistry for the proxy model

examples/common/python/connectors/ethereum/contracts/proxy-model/WorkOrderRegistry.sol

@@ -0,0 +1,171 @@
+/* Copyright 2019 iExec Blockchain Tech
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at 
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+pragma solidity ^0.5.0;
+
+import "./libs/SignatureVerifier.sol";
+
+contract WorkOrderRegistry is SignatureVerifier
+{
+	uint256 constant public TIMEOUT = 1 days;
+
+	enum WorkOrderStatus
+	{
+		NULL,
+		ACTIVE,
+		COMPLETED,
+		FAILED
+	}
+
+	struct WorkOrder
+	{
+		uint256 status;
+		uint256 timestamp;
+		bytes32 workerID;
+		bytes32 requesterID;
+		bytes   request;
+		address verifier;
+		uint256 returnCode;
+		bytes   response;
+	}
+
+	// workOrderID → workOrder
+	mapping(bytes32 => WorkOrder) m_workorders;
+
+	event workOrderSubmitted(
+		bytes32 indexed workOrderID,
+		bytes32 indexed workerID,
+		bytes32 indexed requesterID);
+
+	event workOrderCompleted(
+		bytes32 indexed workOrderID,
+		uint256 indexed workOrderReturnCode);
+
+	event workOrderTimedout(
+		bytes32 indexed workOrderID);
+
+	constructor()
+	public
+	{}
+
+	function workOrderSubmit(
+		bytes32       _workerID,
+		bytes32       _requesterID,
+		bytes memory _workOrderRequest,
+		address       _verifier,
+		bytes32       _salt)
+	public returns (
+		uint256       errorCode
+	) {
+		bytes32 workOrderID = keccak256(abi.encode(
+			_workerID,
+			_requesterID,
+			_workOrderRequest,
+			_verifier,
+			_salt
+		));
+
+		WorkOrder storage wo = m_workorders[workOrderID];
+		require(wo.status == uint256(WorkOrderStatus.NULL), "wo-already-submitted");
+		wo.status      = uint256(WorkOrderStatus.ACTIVE);
+		wo.timestamp   = now;
+		wo.workerID    = _workerID;
+		wo.requesterID = _requesterID;
+		wo.request     = _workOrderRequest;
+		wo.verifier    = _verifier;
+
+		emit workOrderSubmitted(
+			workOrderID,
+			_workerID,
+			_requesterID);
+
+		return 0;
+	}
+
+	function workOrderComplete(
+		bytes32      _workOrderID,
+		uint256      _workOrderReturnCode,
+		bytes memory _workOrderResponse,
+		bytes memory _workOrderSignature
+	) public returns (
+		uint256      errorCode
+	) {
+		WorkOrder storage wo = m_workorders[_workOrderID];
+		require(wo.status == uint256(WorkOrderStatus.ACTIVE), "wo-already-submitted");
+
+		require(checkSignature(
+			wo.verifier,
+			toEthSignedMessageHash(
+				keccak256(abi.encodePacked(
+					_workOrderID,
+					_workOrderReturnCode,
+					_workOrderResponse
+				))
+			),
+			_workOrderSignature
+		));
+
+		wo.status      = uint256(WorkOrderStatus.COMPLETED);
+		wo.returnCode  = _workOrderReturnCode;
+		wo.response    = _workOrderResponse;
+
+		emit workOrderCompleted(
+			_workOrderID,
+			_workOrderReturnCode);
+
+		return 0;
+	}
+
+	function workOrderTimeout(
+		bytes32 _workOrderID
+	) public returns (
+		uint256 errorCode
+	) {
+		WorkOrder storage wo = m_workorders[_workOrderID];
+		require(wo.status == uint256(WorkOrderStatus.ACTIVE));
+		require(wo.timestamp + TIMEOUT < now);
+
+		wo.status = uint256(WorkOrderStatus.FAILED);
+
+		emit workOrderTimedout(_workOrderID);
+
+		return 0;
+	}
+
+	function workOrderGet(
+		bytes32      _workOrderID
+	) public view returns (
+		uint256      status,
+		uint256      timestamp,
+		bytes32      workerID,
+		bytes32      requesterID,
+		bytes memory request,
+		address      verifier,
+		uint256      returnCode,
+		bytes memory response
+	) {
+		WorkOrder storage wo = m_workorders[_workOrderID];
+		return (
+			wo.status,
+			wo.timestamp,
+			wo.workerID,
+			wo.requesterID,
+			wo.request,
+			wo.verifier,
+			wo.returnCode,
+			wo.response);
+	}
+
+}

examples/common/python/connectors/ethereum/contracts/proxy-model/WorkerRegistry.sol

@@ -0,0 +1,142 @@
+/* Copyright 2019 iExec Blockchain Tech
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+pragma solidity ^0.5.0;
+
+contract WorkerRegistry
+{
+	enum WorkerStatus
+	{
+		NULL,
+		ACTIVE,
+		OFFLINE,
+		DECOMMISSIONED,
+		COMPROMISED
+	}
+
+	struct Worker
+	{
+		uint256   status;
+		uint256   workerType;
+		bytes32   organizationId;
+		bytes32[] appTypeIds;
+		string    details;
+	}
+
+	// WorkerID → Worker
+	mapping(bytes32 => Worker) private m_workers;
+
+	// workerType → organizationId → appTypeId → WorkerID[]
+	mapping(uint256 => mapping(bytes32 => mapping(bytes32 => bytes32[]))) m_workersDB;
+
+	constructor()
+	public
+	{}
+
+	function workerRegister(
+		bytes32          workerID,
+		uint256          workerType,
+		bytes32          organizationId,
+		bytes32[] memory appTypeIds,
+		string    memory details
+	) public {
+		Worker storage worker = m_workers[workerID];
+
+		require(worker.status == uint256(WorkerStatus.NULL));
+		worker.status         = uint256(WorkerStatus.ACTIVE);
+		worker.workerType     = workerType;
+		worker.organizationId = organizationId;
+		worker.appTypeIds     = appTypeIds;
+		worker.details        = details;
+
+		require(workerType     != uint256(0));
+		require(organizationId != bytes32(0));
+		m_workersDB[uint256(0)][bytes32(0)    ][bytes32(0)].push(workerID);
+		m_workersDB[workerType][bytes32(0)    ][bytes32(0)].push(workerID);
+		m_workersDB[uint256(0)][organizationId][bytes32(0)].push(workerID);
+		m_workersDB[workerType][organizationId][bytes32(0)].push(workerID);
+
+		for (uint256 p = 0; p < appTypeIds.length; ++p)
+		{
+			require(appTypeIds[p] != bytes32(0));
+			m_workersDB[uint256(0)][bytes32(0)    ][appTypeIds[p]].push(workerID);
+			m_workersDB[workerType][bytes32(0)    ][appTypeIds[p]].push(workerID);
+			m_workersDB[uint256(0)][organizationId][appTypeIds[p]].push(workerID);
+			m_workersDB[workerType][organizationId][appTypeIds[p]].push(workerID);
+		}
+	}
+
+	function workerUpdate(
+		bytes32       workerID,
+		string memory details
+	) public {
+		require(m_workers[workerID].status != uint256(WorkerStatus.NULL));
+		m_workers[workerID].details = details;
+	}
+
+	function workerSetStatus(
+		bytes32 workerID,
+		uint256 status
+	) public {
+		require(m_workers[workerID].status != uint256(WorkerStatus.NULL));
+		require(status                     != uint256(WorkerStatus.NULL));
+		m_workers[workerID].status = status;
+	}
+
+	function workerLookUp(
+		uint256          workerType,
+		bytes32          organizationId,
+		bytes32          appTypeId
+	) public view returns(
+		uint256          totalCount,
+		uint256          lookupTag,
+		bytes32[] memory ids
+	) {
+		return workerLookUpNext(workerType, organizationId, appTypeId, 0);
+	}
+
+	function workerLookUpNext(
+		uint256          workerType,
+		bytes32          organizationId,
+		bytes32          appTypeId,
+		uint256          /*lookUpTag*/
+	) public view returns(
+		uint256          totalCount,
+		uint256          newLookupTag,
+		bytes32[] memory ids
+	) {
+		bytes32[] storage matchs = m_workersDB[workerType][organizationId][appTypeId];
+		return (matchs.length, 0, matchs);
+	}
+
+	function workerRetrieve(
+		bytes32          workerID
+	) public view returns (
+		uint256          status,
+		uint256          workerType,
+		bytes32          organizationId,
+		bytes32[] memory appTypeIds,
+		string    memory details
+	) {
+		Worker storage worker = m_workers[workerID];
+		return (
+			worker.status,
+			worker.workerType,
+			worker.organizationId,
+			worker.appTypeIds,
+			worker.details
+		);
+	}
+}

examples/common/python/connectors/ethereum/contracts/proxy-model/interfaces/IERC1271.sol

@@ -0,0 +1,47 @@
+/* Copyright 2019 iExec Blockchain Tech
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at 
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+pragma solidity ^0.5.0;
+
+contract IERC1271
+{
+	// bytes4(keccak256("isValidSignature(bytes,bytes)")
+	bytes4 constant internal MAGICVALUE = 0x20c13b0b;
+
+	/**
+	 * @dev Should return whether the signature provided is valid for the provided data
+	 * @param _data Arbitrary length data signed on the behalf of address(this)
+	 * @param _signature Signature byte array associated with _data
+	 *
+	 * MUST return the bytes4 magic value 0x20c13b0b when function passes.
+	 * MUST NOT modify state (using STATICCALL for solc < 0.5, view modifier for solc > 0.5)
+	 * MUST allow external calls
+	 */
+	// function isValidSignature(
+	// 	bytes memory _data,
+	// 	bytes memory _signature)
+	// 	public
+	// 	view
+	// 	returns (bytes4 magicValue);
+
+	// Newer version ? From 0x V2
+	function isValidSignature(
+		bytes32 _data,
+		bytes memory _signature
+	)
+	public
+	view
+	returns (bool isValid);
+}