opportunity-service 0.0.536 → 0.0.542

package/src/api/dispute/launch-new-vote.ts

@@ -0,0 +1,116 @@
+import { Wallet } from "@ethersproject/wallet"
+import { CensusErc20Api } from "@vocdoni/census"
+import { ProcessState, VotingApi, VotingOracleApi } from "@vocdoni/voting"
+import { DVoteGateway, Erc20TokensApi, GatewayPool } from "@vocdoni/client"
+import { ProcessMetadataTemplate } from "@vocdoni/data-models"
+import { ProcessMode, ProcessContractParameters, ProcessEnvelopeType } from '@vocdoni/contract-wrappers'
+import * as assert from 'assert'
+import { waitUntilPresent } from "./util/wait-until-present"
+
+export async function launchNewVote(
+    creatorWallet: Wallet, 
+    tokenAddress: string, 
+    gwPool: GatewayPool, 
+    oracleClient: DVoteGateway,
+    disputeId: string,
+    employer: string,
+    worker: string
+    ) {
+    console.log('Launching new vote...')
+
+    if (!await Erc20TokensApi.isRegistered(tokenAddress, gwPool)) {
+        await CensusErc20Api.registerTokenAuto(
+            tokenAddress,
+            creatorWallet,
+            gwPool
+        )
+
+        assert(await Erc20TokensApi.isRegistered(tokenAddress, gwPool))
+    }
+
+    const sourceBlockHeight = (await gwPool.provider.getBlockNumber()) - 1
+    const tokenInfo = await CensusErc20Api.getTokenInfo(tokenAddress, gwPool)
+    const proof = await CensusErc20Api.generateProof(tokenAddress, creatorWallet.address, tokenInfo.balanceMappingPosition, sourceBlockHeight, gwPool.provider)
+    
+    if (!proof?.storageProof?.length) throw new Error("Invalid storage proof")
+
+    console.log("Preparing the new vote metadata")
+    const processMetadataPre = JSON.parse(JSON.stringify(ProcessMetadataTemplate)) // make a copy of the template
+    processMetadataPre.title.default = disputeId,
+    processMetadataPre.description.default = `Dispute: ${disputeId}`,
+    processMetadataPre.questions = [
+        {
+            title: { default: "Contract Dispute" },
+            description: { default: "Please choose one of the two participants" },
+            choices: [
+                { title: { default: employer }, value: 0 },
+                { title: { default: worker }, value: 1 },
+            ]
+        }
+    ]
+    processMetadataPre.meta.disputeId = disputeId;
+
+    const maxValue = processMetadataPre.questions.reduce((prev, cur) => {
+        const localMax = cur.choices.reduce((prev, cur) => prev > cur.value ? prev : cur.value, 0)
+        return localMax > prev ? localMax : prev
+    }, 0)
+
+    console.log("Getting the block height")
+    const currentBlock = await VotingApi.getBlockHeight(gwPool)
+    const startBlock = currentBlock + 15 //start after 15 blocks
+    const blockCount = 6 * 4 // 4m
+
+    const processParamsPre = {
+        mode: ProcessMode.make({ autoStart: true }),
+        envelopeType: ProcessEnvelopeType.make({}), // bit mask
+        metadata: processMetadataPre,
+        startBlock,
+        blockCount,
+        maxCount: 1,
+        maxValue,
+        maxTotalCost: 0,
+        costExponent: 10000,  // 1.0000
+        maxVoteOverwrites: 1,
+        sourceBlockHeight,
+        tokenAddress,
+        paramsSignature: "0x0000000000000000000000000000000000000000000000000000000000000000"
+    }
+
+    const tokenDetails = {
+        balanceMappingPosition: tokenInfo.balanceMappingPosition,
+        storageHash: proof.storageHash,
+        storageProof: {
+            key: proof.storageProof[0].key,
+            value: proof.storageProof[0].value,
+            proof: proof.storageProof[0].proof
+        }
+    }
+
+    console.log("Creating the process")
+    const processId = await VotingOracleApi.newProcessErc20(
+        processParamsPre, 
+        tokenDetails, 
+        creatorWallet, 
+        gwPool, 
+        oracleClient
+    )
+
+    assert(processId)
+    console.log("Created process with process id: ", processId)
+
+    await waitUntilPresent(processId, gwPool)
+
+    console.log('Checking process params to ensure process was created...')
+    const processParams: ProcessState = await VotingApi.getProcessState(processId, gwPool)
+
+    assert.strictEqual(processParams?.entityAddress.toLowerCase(), creatorWallet.address.toLowerCase())
+    assert.strictEqual(processParams?.startBlock, processParamsPre?.startBlock, "SENT " + JSON.stringify(processParamsPre) + " GOT " + JSON.stringify(processParams))
+    assert.strictEqual(processParams?.blockCount, processParamsPre?.blockCount)
+    assert.strictEqual(processParams?.censusUri, processParamsPre?.censusUri)
+
+    const processMetadata = await VotingApi.getProcessMetadata(processId, gwPool)
+    console.log('Process created with metadata: ')
+    console.log(processMetadata)
+
+    return { processId, processParams, processMetadata }
+}

package/src/api/dispute/submit-vote.ts

@@ -0,0 +1,59 @@
+import { Wallet } from "@ethersproject/wallet"
+import { CensusErc20Api } from "@vocdoni/census"
+import { ProcessState, VotingApi, VotingOracleApi } from "@vocdoni/voting"
+import { DVoteGateway, Erc20TokensApi, GatewayPool } from "@vocdoni/client"
+import { ProcessMetadata } from "@vocdoni/data-models"
+import { Signer } from "@ethersproject/abstract-signer"
+import { JsonRpcProvider } from "@ethersproject/providers"
+import { assert } from "console"
+
+export async function submitVote(
+    processId: string, 
+    processParams: ProcessState, 
+    processMetadata: ProcessMetadata, 
+    accounts, 
+    tokenAddress: string,
+    voter: Signer,
+    voterChoice: number[],
+    gwPool: GatewayPool) {
+    console.log("Launching votes")
+
+    const processKeys = processParams.envelopeType.hasEncryptedVotes ? await VotingApi.getProcessKeys(processId, gwPool) : null
+    const balanceMappingPosition = (await CensusErc20Api.getTokenInfo(tokenAddress, gwPool)).balanceMappingPosition
+    const voterAddress = await voter.getAddress()
+
+    const result = await CensusErc20Api.generateProof(
+        tokenAddress, 
+        voterAddress, 
+        balanceMappingPosition, 
+        processParams.sourceBlockHeight, 
+        gwPool.provider as JsonRpcProvider
+    )
+
+    const censusProof = result.storageProof[0]
+
+    console.log('Creating voter envelope')
+    const envelope = processParams.envelopeType.encryptedVotes ?
+    await VotingApi.packageSignedEnvelope({ censusOrigin: processParams.censusOrigin, votes: voterChoice, censusProof, processId, walletOrSigner: voter, processKeys }) :
+    await VotingApi.packageSignedEnvelope({ censusOrigin: processParams.censusOrigin, votes: voterChoice, censusProof, processId, walletOrSigner: voter })
+
+    console.log('Attempting to submit voter envelope: ' + voter)
+    await VotingApi.submitEnvelope(envelope, voter, gwPool)
+
+    // wait a bit
+    await new Promise(resolve => setTimeout(resolve, 11000))
+
+    const nullifier = VotingApi.getSignedVoteNullifier(voterAddress, processId)
+    const { block, date, registered } = await VotingApi.getEnvelopeStatus(processId, nullifier, gwPool)
+
+    if (!registered) {
+        console.log('Vote not submitted.. voter not registered...')
+        return false;
+    }
+
+    console.log('Voter envelope successfully submitted')
+    console.log('Block: ' + block)
+    console.log('Date: ' + date)
+    console.log('Registered: ' + registered)
+    return true
+}

package/src/api/dispute/util/wait-until-present.ts

@@ -0,0 +1,19 @@
+import { VotingApi, VochainWaiter, ProcessState } from '@vocdoni/voting'
+import * as assert from 'assert'
+import { ProcessStatus } from 'dvote-solidity'
+
+export async function waitUntilPresent(processId, gwPool) {
+    let attempts = 10
+    while (attempts >= 0) {
+        console.log("Waiting for process", processId, "to be created")
+        await VochainWaiter.wait(1, gwPool)
+
+        const state: ProcessState | void = await VotingApi.getProcessState(processId, gwPool).catch(error => console.log(error))
+        console.log('Attempted to get process state: ' + state)
+        if (state?.entityId) break
+
+        attempts--
+    }
+
+    if (attempts < 0) throw new Error("The process still does not exist on the Vochain after 10 blocks")
+}

package/src/api/dispute/util/wait-until-started.ts

@@ -0,0 +1,14 @@
+import { VotingApi, VochainWaiter } from '@vocdoni/voting'
+import * as assert from 'assert'
+import { ProcessStatus } from 'dvote-solidity'
+
+export async function waitUntilStarted(processId, startBlock, gwPool) {
+    console.log('Waiting until block: ' + startBlock)
+
+    // start block
+    await VochainWaiter.waitUntil(startBlock, gwPool, { verbose: true })
+
+    console.log("Waiting for the process to be ready")
+    const state = await VotingApi.getProcessState(processId, gwPool)
+    assert.strictEqual(state.status, ProcessStatus.READY, "Should be ready but is not")
+}

package/src/api/exchange/create-dispute.ts

@@ -31,7 +31,7 @@ async function createDispute(data) : Promise<void> {
         const disputeContractfactory = new ContractFactory(abi, bytecodeMap[Contracts.DISPUTE], opportunityService.getSignersInterface())
 
         // Deploy an instance of the contract
-        const disputeContract = await disputeContractfactory.deploy(relationshipAddress, addressMap[Contracts.SCHEDULER], complaintMetadataPointer, complaintResponseMetadataPointer);
+        const disputeContract = await disputeContractfactory.deploy(relationshipAddress, complaintMetadataPointer, complaintResponseMetadataPointer);
         const txReceipt = await disputeContract.deployTransaction.wait()
         console.log(txReceipt)
     } catch(error) {

package/src/api/exchange/create-task.ts

@@ -40,7 +40,7 @@ async function createTask(data) : Promise<void> {
         console.log('d')
     const contract = await new ethers.Contract(taskMarket, abi).connect(opportunityService.getSignersInterface());
     console.log('e')
-    const txResponse = await contract.functions.createJob(taskOwner, ContractType.NORMAL, taskMetadataPointer, addressMap['Dai'])
+    const txResponse = await contract.functions.createJob(taskOwner, ContractType.NORMAL, taskMetadataPointer, addressMap[opportunityService.getEthNetwork()][Contracts.DAI])
     const txReceipt = await txResponse.wait()
     console.log(txReceipt)
     } catch(error) {

package/src/api/identity/register-new-user.ts

@@ -14,7 +14,7 @@ console.log('Registering new user: ' + msgSender)
     
 
 const txResult = new Contract(
-    addressMap['UserRegistration'],
+    addressMap[opportunityService.getEthNetwork()]['UserRegistration'],
     abiMap['UserRegistration']
     ).connect(opportunityService.getSignersInterface())
     .registerNewUser({

package/src/api/index.ts

@@ -6,33 +6,46 @@ import { createTask } from "./exchange/create-task";
 import { enterWorkRelationship } from "./exchange/enter-work-relationship";
 import registerNewUser from "./identity/register-new-user";
 import { createMarket } from "./market/create-market";
-import { registerEntity } from "./voting/entity";
-import { createVotingProcess } from "./voting/process";
 
 import { abis, events, addresses } from './internal/index'; 
 
 import { sendAsync } from './ethereum/sendAsync'
+import { parseCypher } from "./util/parse-cipher";
+import { stringifyCypher } from "./util/stringify-cipher";
+import { decryptByPrivateKey, encryptByPublicKey } from "./util/encrypt-by-public-key";
+import { createEthCryptoCreds } from "./other/create-eth-crypto-creds";
+import { encrypt } from "./provider/encrypt";
+import { decrypt } from "./provider/decrypt";
+import { connectGateways, getOracleClient } from "./dispute/connect";
+import { checkVoteResults } from "./dispute/check-vote-results";
+import { ensureEntityMetadata } from "./dispute/ensure-entity-metadata";
+import { launchNewVote } from "./dispute/launch-new-vote";
+import { submitVote } from "./dispute/submit-vote";
 
 function generateAPI() {
     return {
+        crypto: {
+            encryptByPublicKey,
+            decryptByPrivateKey,
+            createEthCryptoCreds
+        },
         internal: {
             abis: abis,
             addresses,
         },
-        voting: {
-            entity: {
-                registerEntity
-            },
-            process: {
-                createVotingProcess
-            }
-        },
         exchange: {
             completeRelationship,
             createTask,
             enterWorkRelationship
         },
-        dispute: {},
+        dispute: {
+            connectGateways: connectGateways,
+            getOracleClient: getOracleClient,
+            checkVoteResults: checkVoteResults,
+            ensureEntityMetadata: ensureEntityMetadata,
+            launchNewVote: launchNewVote,
+            submitVote: submitVote
+        },
         identity: {
             registerNewUser
         },
@@ -47,7 +60,13 @@ function generateAPI() {
             }
         },
         provider: {
-            sendAsync
+            sendAsync,
+            encrypt,
+            decrypt
+        },
+        util: {
+            parseCypher,
+            stringifyCypher
         }
     }
 }

package/src/api/internal/abis.ts

@@ -6,5 +6,6 @@ export default {
     'WorkRelationship': abiMap['WorkRelationship'],
     'Market': abiMap['Market'],
     'UserRegistration': abiMap['UserRegistration'],
-    'Dispute': abiMap['Dispute']
+    'Dispute': abiMap['Dispute'],
+    'Participation': abiMap['Participation']
 }

package/src/api/internal/addresses.ts

@@ -2,8 +2,25 @@ import opportunityService from '../../OpportunityService';
 import * as addressMap from '../../blockchain/addresses.json';
 
 export default {
-    'MarketFactory': addressMap['MarketFactory'],
-    'UserRegistration': addressMap['UserRegistration'],
-    'Dai': addressMap['Dai'],
-    'Scheduler': addressMap['Scheduler'],
+    "rinkeby": {
+        'MarketFactory': addressMap['rinkeby']['MarketFactory'],
+        'UserRegistration': addressMap['rinkeby']['UserRegistration'],
+        'UserSummaryFactory': addressMap['rinkeby']['UserSummaryFactory'],
+        'Dai': addressMap['rinkeby']['Dai'],
+        'Participation': addressMap['rinkeby']['Participation']
+    },
+    "mainnet": {
+        'MarketFactory': addressMap['mainnet']['MarketFactory'],
+        'UserRegistration': addressMap['mainnet']['UserRegistration'],
+        'UserSummaryFactory': addressMap['mainnet']['UserSummaryFactory'],
+        'Dai': addressMap['mainnet']['Dai'],
+        'Participation': addressMap['mainnet']['Participation']
+    },
+    "xdai": {
+        'MarketFactory': addressMap['xdai']['MarketFactory'],
+        'UserRegistration': addressMap['xdai']['UserRegistration'],
+        'UserSummaryFactory': addressMap['xdai']['UserSummaryFactory'],
+        'Dai': addressMap['xdai']['Dai'],
+        'Participation': addressMap['xdai']['Participation']
+    }
 }

package/src/api/other/create-eth-crypto-creds.ts

@@ -0,0 +1,14 @@
+import EthCrypto from 'eth-crypto';
+import jswallet from 'ethereumjs-wallet'
+import opportunityService from '../..//OpportunityService';
+import Web3 from 'web3'
+
+async function createEthCryptoCreds(passphrase) {
+    const entropy = Buffer.from(passphrase, 'utf-8')
+    const identity = EthCrypto.createIdentity(entropy)
+
+    const { address, publicKey, privateKey } = identity
+    return identity
+}
+
+export { createEthCryptoCreds }

package/src/api/provider/decrypt.ts

@@ -0,0 +1,9 @@
+import Web3 from 'web3'
+import opportunityService from '../../OpportunityService'
+
+export async function decrypt (keystore, passphrase) {
+    const web3 : Web3 = opportunityService.getDefaultProviderInterface()
+
+    const data = await web3.eth.accounts.decrypt(keystore, passphrase)
+    return data
+}

package/src/api/provider/encrypt.ts

@@ -0,0 +1,9 @@
+import Web3 from 'web3'
+import opportunityService from '../../OpportunityService'
+
+export async function encrypt(privKey, password) {
+    const web3 : Web3 = opportunityService.getDefaultProviderInterface()
+
+    const keystore = await web3.eth.accounts.encrypt(privKey, password);
+    return keystore
+}

package/src/api/util/encrypt-by-public-key.ts

@@ -0,0 +1,47 @@
+import EthCrypto from 'eth-crypto';
+
+/**
+ * 
+ * @param pubKey 
+ * @param message 
+ * @returns 
+ */
+async function encryptByPublicKey(pubKey, message) {
+    const encrypted = await EthCrypto.encryptWithPublicKey(
+        pubKey, // publicKey
+        message// message
+    );
+
+    return encrypted
+}
+
+/*
+{
+    iv: '02aeac54cb45283b427bd1a5028552c1',
+    ephemPublicKey: '044acf39ed83c304f19f41ea66615d7a6c0068d5fc48ee181f2fb1091...',
+    ciphertext: '5fbbcc1a44ee19f7499dbc39cfc4ce96',
+    mac: '96490b293763f49a371d3a2040a2d2cb57f246ee88958009fe3c7ef2a38264a1'
+} // encrypted-data
+*/
+
+
+/**
+ * 
+ * @param privKey 
+ * @param encryptedData 
+ */
+async function decryptByPrivateKey(privKey, encryptedData) {
+    const { iv, ephemPublicKey, ciphertext, mac } = encryptedData
+    const message = await EthCrypto.decryptWithPrivateKey(
+        privKey, // privateKey
+        {
+            iv,
+            ephemPublicKey,
+            ciphertext,
+            mac
+        } // encrypted-data
+    );
+}
+
+
+export { encryptByPublicKey, decryptByPrivateKey }

package/src/api/util/parse-cipher.ts

@@ -0,0 +1,11 @@
+import EthCrypto from 'eth-crypto'
+
+/* >  {
+        iv: '02aeac54cb45283b427bd1a5028552c1',
+        ephemPublicKey: '044acf39ed83c304f19f41ea66615d7a6c0068d5fc48ee181f2fb1091...',
+        ciphertext: '5fbbcc1a44ee19f7499dbc39cfc4ce96',
+        mac: '96490b293763f49a371d3a2040a2d2cb57f246ee88958009fe3c7ef2a38264a1'
+    } */
+export function parseCypher(str) {
+    return EthCrypto.cipher.parse(str);
+}

package/src/api/util/stringify-cipher.ts

@@ -0,0 +1,5 @@
+import EthCrypto from 'eth-crypto'
+
+export function stringifyCypher(cipher) {
+    return EthCrypto.cipher.stringify(cipher);
+}