opportunity-service 0.0.534 → 0.0.539

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

@@ -7,16 +7,22 @@ import abiMap from '../internal/abis'
 import { Result } from 'ethers/lib/utils';
 
 async function registerNewUser() {
+    try {
 const msgSender = await opportunityService.getSignersInterface()._address
 console.log('Registering new user: ' + msgSender)
 
+    
+
 const txResult = new Contract(
-    addressMap['UserRegistration'],
+    addressMap[opportunityService.getEthNetwork()]['UserRegistration'],
     abiMap['UserRegistration']
     ).connect(opportunityService.getSignersInterface())
     .registerNewUser({
         from: msgSender
     })
+    } catch(error) {
+        console.log(error)
+    }
 }
 
 export default registerNewUser;

package/src/api/index.ts

@@ -10,9 +10,25 @@ import { createMarket } from "./market/create-market";
 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,
@@ -22,7 +38,14 @@ function generateAPI() {
             createTask,
             enterWorkRelationship
         },
-        dispute: {},
+        dispute: {
+            connectGateways: connectGateways,
+            getOracleClient: getOracleClient,
+            checkVoteResults: checkVoteResults,
+            ensureEntityMetadata: ensureEntityMetadata,
+            launchNewVote: launchNewVote,
+            submitVote: submitVote
+        },
         identity: {
             registerNewUser
         },
@@ -37,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);
+}