Loom provider with optional private key

src/loom-provider.ts

@@ -147,7 +147,7 @@ export class LoomProvider {
    */
   constructor(
     client: Client,
-    privateKey: Uint8Array,
+    privateKey?: Uint8Array,
     setupMiddlewaresFunction?: SetupMiddlewareFunction
   ) {
     this._client = client
@@ -171,7 +171,10 @@ export class LoomProvider {
 
     this.addDefaultMethods()
     this.addDefaultEvents()
-    this.addAccounts([privateKey])
+
+    if (privateKey) {
+      this.addAccounts([privateKey])
+    }
   }
 
   /**
@@ -892,6 +895,11 @@ export class LoomProvider {
     txTransaction: Transaction
   ): Promise<Uint8Array | void> {
     const middleware = this._accountMiddlewares.get(fromPublicAddr)
+
+    if (!middleware) {
+      throw Error(`Middleware not found for public address ${fromPublicAddr}`)
+    }
+
     return this._client.commitTxAsync<Transaction>(txTransaction, { middleware })
   }
 

src/tests/e2e/loom-provider-web3-tests.ts

@@ -80,11 +80,11 @@ const newContractAndClient = async () => {
     }
   ]
 
-  const result = await deployContract(loomProvider, contractData)
+  const { contractAddress } = await deployContract(loomProvider, contractData)
 
-  const contract = new web3.eth.Contract(ABI, result.contractAddress, { from })
+  const contract = new web3.eth.Contract(ABI, contractAddress, { from })
 
-  return { contract, client, web3, from, privKey }
+  return { contract, client, web3, from, privKey, ABI, contractAddress }
 }
 
 test('LoomProvider + Web3 + Event with not matching topic', async t => {
@@ -118,6 +118,50 @@ test('LoomProvider + Web3 + Event with not matching topic', async t => {
   }
 })
 
+test('LoomProvider transaction without private key should fail', async t => {
+  t.plan(1)
+  const { client, ABI, contractAddress } = await newContractAndClient()
+  const loomProvider = new LoomProvider(client)
+  const web3 = new Web3(loomProvider)
+  const contract = new web3.eth.Contract(ABI, contractAddress)
+
+  try {
+    const newValue = 1
+    await contract.methods.get(newValue).send()
+    await waitForMillisecondsAsync(1000)
+  } catch (err) {
+    t.assert(err, 'Should fail on try to transaction without a private key set')
+  }
+
+  if (client) {
+    client.disconnect()
+  }
+})
+
+test('LoomProvider static call without private key should not fail', async t => {
+  t.plan(1)
+
+  const { client, ABI, contractAddress } = await newContractAndClient()
+  const loomProvider = new LoomProvider(client)
+  const web3 = new Web3(loomProvider)
+  const contract = new web3.eth.Contract(ABI, contractAddress)
+
+  // Some dummy address needed or the call will fail
+  const from = '0x0000000000000000000000000000000000000000'
+
+  try {
+    const resultOfGet = await contract.methods.get().call({ from })
+    t.equal(+resultOfGet, 10, `SimpleStore.get should return correct value`)
+    await waitForMillisecondsAsync(1000)
+  } catch (err) {
+    t.fail(err)
+  }
+
+  if (client) {
+    client.disconnect()
+  }
+})
+
 test('LoomProvider + Web3 + Multiple event topics', async t => {
   t.plan(3)
   const { contract, client } = await newContractAndClient()