Merge pull request #49 from firstbatchxyz/erhant/regex-check

Null value fix

jest.config.ts

@@ -14,6 +14,7 @@ const config: Config = {
   verbose: true,
   // Warp & Arlocal takes some time to close, so make this 5 secs
   openHandlesTimeout: 5000,
+  forceExit: true,
 };
 
 export default config;

src/contracts/errors/index.ts

@@ -6,5 +6,6 @@ export const UnknownProtocolError = new ContractError('Unknown protocol.');
 export const NotWhitelistedError = new ContractError('Not whitelisted.');
 export const InvalidProofError = new ContractError('Invalid proof.');
 export const ExpectedProofError = new ContractError('Expected a proof.');
+export const NullValueError = new ContractError('Value cant be null, use remove instead.');
 export const NotOwnerError = new ContractError('Not contract owner.');
 export const InvalidFunctionError = new ContractError('Invalid function.');

src/contracts/functions/crud.ts

@@ -1,5 +1,5 @@
 import type {ContractState, GetInput, PutInput, RemoveInput, UpdateInput} from '../types';
-import {KeyExistsError} from '../errors';
+import {KeyExistsError, NullValueError} from '../errors';
 import {assertWhitelist, safeGet, verifyAuthProof} from '../utils';
 
 /** Gets a value at the specified key. */
@@ -22,6 +22,9 @@ export async function put<State extends ContractState<{whitelists: ['put']; circ
 ) {
   assertWhitelist(state, caller, 'put');
 
+  if (value === null) {
+    throw NullValueError;
+  }
   if ((await SmartWeave.kv.get(key)) !== null) {
     throw KeyExistsError;
   }
@@ -67,6 +70,9 @@ export async function update<State extends ContractState<{whitelists: ['update']
 ) {
   assertWhitelist(state, caller, 'update');
 
+  if (value === null) {
+    throw NullValueError;
+  }
   const dbValue = await safeGet(key);
   await verifyAuthProof(state, proof, dbValue, value, key);
   await SmartWeave.kv.put(key, value);

src/contracts/functions/htx.ts

@@ -1,5 +1,5 @@
 import type {ContractState} from '../types';
-import {KeyExistsError} from '../errors';
+import {KeyExistsError, NullValueError} from '../errors';
 import {assertWhitelist, safeGet, verifyAuthProofImmediate} from '../utils';
 import {HTXValueType, PutHTXInput, RemoveHTXInput, UpdateHTXInput} from '../types/htx';
 
@@ -10,9 +10,13 @@ export async function putHTX<State extends ContractState<{whitelists: ['put']; c
 ) {
   assertWhitelist(state, caller, 'put');
 
+  if (value === null) {
+    throw NullValueError;
+  }
   if ((await SmartWeave.kv.get(key)) !== null) {
     throw KeyExistsError;
   }
+
   await SmartWeave.kv.put(key, value);
 
   return {state};
@@ -41,6 +45,9 @@ export async function updateHTX<State extends ContractState<{whitelists: ['updat
 ) {
   assertWhitelist(state, caller, 'update');
 
+  if (value === null) {
+    throw NullValueError;
+  }
   const dbValue = await safeGet<string>(key);
   const [oldHash] = dbValue.split('.');
   const [newHash] = value.split('.');

tests/htx.test.ts

@@ -73,8 +73,7 @@ describe('hash.txid value tests', () => {
   });
 
   describe('disabling proofs', () => {
-    const {VALUE, NEXT_VALUE} = createValues<ValueType>();
-    const KEY = 'some-non-bigint-friendly-key';
+    const {VALUE, NEXT_VALUE, KEY} = createValues<ValueType>();
 
     beforeAll(async () => {
       const {cachedValue} = await owner.readState();

tests/null.test.ts

@@ -0,0 +1,66 @@
+import fs from 'fs';
+import {Prover} from 'hollowdb-prover';
+import constants from './constants';
+import {createValues, deployContract} from './utils';
+import {setupWarp} from './hooks';
+import {Admin} from '../src/hollowdb';
+
+// adding `null` to type for testing purposes
+// it is not allowed normally
+type ValueType = {val: string} | null;
+
+describe('null value tests with proofs', () => {
+  const warpHook = setupWarp();
+  const protocol = 'groth16';
+  let prover: Prover;
+  let owner: Admin<ValueType>;
+
+  const {KEY, KEY_PREIMAGE, VALUE, NEXT_VALUE} = createValues<ValueType>();
+
+  beforeAll(async () => {
+    const hook = warpHook();
+    const [ownerWallet] = hook.wallets;
+    const contractTxId = await deployContract(hook.warp, ownerWallet.jwk);
+
+    prover = new Prover(
+      constants.PROVERS[protocol].HOLLOWDB.WASM_PATH,
+      constants.PROVERS[protocol].HOLLOWDB.PROVERKEY_PATH,
+      protocol
+    );
+
+    owner = new Admin(ownerWallet.jwk, contractTxId, hook.warp);
+  });
+
+  it('should set verification key', async () => {
+    const verificationKey = JSON.parse(
+      fs.readFileSync(constants.PROVERS[protocol].HOLLOWDB.VERIFICATIONKEY_PATH, 'utf8')
+    );
+    await owner.updateVerificationKey('auth', verificationKey);
+    const {cachedValue} = await owner.readState();
+    expect(cachedValue.state.verificationKeys.auth).toEqual(verificationKey);
+  });
+
+  it('should NOT allow putting a null value', async () => {
+    await expect(owner.put(KEY, null)).rejects.toThrow('Contract Error [put]: Value cant be null, use remove instead.');
+  });
+
+  it('should allow putting without a proof', async () => {
+    await owner.put(KEY, VALUE);
+  });
+
+  it('should NOT allow updating to null with a proof', async () => {
+    const {proof} = await prover.prove(KEY_PREIMAGE, VALUE, null);
+    await expect(owner.update(KEY, null, proof)).rejects.toThrow(
+      'Contract Error [update]: Value cant be null, use remove instead.'
+    );
+  });
+
+  it('should allow removing with a proof', async () => {
+    const {proof} = await prover.prove(KEY_PREIMAGE, VALUE, null);
+    await owner.remove(KEY, proof);
+  });
+
+  it('should allow putting again to a removed key without a proof', async () => {
+    await owner.put(KEY, NEXT_VALUE);
+  });
+});