feat: add getVariable function

docs/source/mocks.rst

@@ -133,4 +133,27 @@ Setting the value of multiple variables
  [myKey]: 1234
  }
  })
- 
+ 
+Getting the value of an internal variable
+********************
+
+.. warning::
+ This is an experimental feature and it does not support multidimensional or packed arrays
+
+.. code-block:: typescript
+
+ const myUint256 = await myMock.getVariable('myUint256VariableName');
+
+Getting the value of an internal mapping given the value's key
+#######################################
+
+.. code-block:: typescript
+
+ const myMappingValue = await myMock.getVariable('myMappingVariableName', [mappingKey]);
+
+Getting the value of an internal nested mapping given the value's keys
+#######################################
+
+.. code-block:: typescript
+
+ const myMappingValue = await myMock.getVariable('myMappingVariableName', [mappingKeyA, mappingKeyB]);

src/factories/smock-contract.ts

@@ -7,6 +7,7 @@ import { Observable } from 'rxjs';
 import { distinct, filter, map, share, withLatestFrom } from 'rxjs/operators';
 import { EditableStorageLogic as EditableStorage } from '../logic/editable-storage-logic';
 import { ProgrammableFunctionLogic, SafeProgrammableContract } from '../logic/programmable-function-logic';
+import { ReadableStorageLogic as ReadableStorage } from '../logic/readable-storage-logic';
 import { ObservableVM } from '../observable-vm';
 import { Sandbox } from '../sandbox';
 import { ContractCall, FakeContract, MockContractFactory, ProgrammableContractFunction, ProgrammedReturnValue } from '../types';
@@ -51,8 +52,10 @@ function mockifyContractFactory<T extends ContractFactory>(
 
  // attach to every internal variable, all the editable logic
  const editableStorage = new EditableStorage(await getStorageLayout(contractName), vm.getManager(), mock.address);
+ const readableStorage = new ReadableStorage(await getStorageLayout(contractName), vm.getManager(), mock.address);
  mock.setVariable = editableStorage.setVariable.bind(editableStorage);
  mock.setVariables = editableStorage.setVariables.bind(editableStorage);
+ mock.getVariable = readableStorage.getVariable.bind(readableStorage);
 
  // We attach a wallet to the contract so that users can send transactions *from* a watchablecontract.
  mock.wallet = await impersonate(mock.address);

src/logic/readable-storage-logic.ts

@@ -0,0 +1,40 @@
+import { SmockVMManager } from '../types';
+import { fromHexString, remove0x, toFancyAddress, toHexString } from '../utils';
+import {
+ decodeVariable,
+ getVariableStorageSlots,
+ SolidityStorageLayout,
+ StorageSlotKeyTypePair,
+ StorageSlotKeyValuePair,
+} from '../utils/storage';
+
+export class ReadableStorageLogic {
+ private storageLayout: SolidityStorageLayout;
+ private contractAddress: string;
+ private vmManager: SmockVMManager;
+
+ constructor(storageLayout: SolidityStorageLayout, vmManager: SmockVMManager, contractAddress: string) {
+ this.storageLayout = storageLayout;
+ this.vmManager = vmManager;
+ this.contractAddress = contractAddress;
+ }
+
+ async getVariable(variableName: string, mappingKeys?: string[] | number[]): Promise<unknown> {
+ const slots: StorageSlotKeyTypePair[] = await getVariableStorageSlots(
+ this.storageLayout,
+ variableName,
+ this.vmManager,
+ this.contractAddress,
+ mappingKeys
+ );
+ const slotValueTypePairs: StorageSlotKeyValuePair[] = await Promise.all(
+ slots.map(async (slotKeyPair) => ({
+ ...slotKeyPair,
+ value: remove0x(
+ toHexString(await this.vmManager.getContractStorage(toFancyAddress(this.contractAddress), fromHexString(slotKeyPair.key)))
+ ),
+ }))
+ );
+ return decodeVariable(slotValueTypePairs);
+ }
+}

src/types.ts

@@ -4,6 +4,7 @@ import { Provider } from '@ethersproject/abstract-provider';
 import { Signer } from '@ethersproject/abstract-signer';
 import { BaseContract, ContractFactory, ethers } from 'ethers';
 import { EditableStorageLogic } from './logic/editable-storage-logic';
+import { ReadableStorageLogic } from './logic/readable-storage-logic';
 import { WatchableFunctionLogic } from './logic/watchable-function-logic';
 
 type Abi = ReadonlyArray<
@@ -72,6 +73,7 @@ export type MockContract<T extends BaseContract = BaseContract> = SmockContractB
  connect: (...args: Parameters<T['connect']>) => MockContract<T>;
  setVariable: EditableStorageLogic['setVariable'];
  setVariables: EditableStorageLogic['setVariables'];
+ getVariable: ReadableStorageLogic['getVariable'];
 } & {
  [Property in keyof T['functions']]: ProgrammableContractFunction;
  };

src/utils/hex-utils.ts

@@ -101,3 +101,21 @@ function bitnot(bi: BigInt) {
  .join('');
  return BigInt('0b' + prefix + bin) + BigInt(1);
 }
+
+/**
+ * XOR operation between 2 Buffers
+ * Source: https://github.com/crypto-browserify/buffer-xor/blob/master/index.js
+ * @param a Buffer to XOR
+ * @param b Buffer is the mask
+ * @returns hex representation of the big number
+ */
+export function xor(a: Buffer, b: Buffer) {
+ var length = Math.max(a.length, b.length);
+ var buffer = Buffer.allocUnsafe(length);
+
+ for (var i = 0; i < length; ++i) {
+ buffer[i] = a[i] ^ b[i];
+ }
+
+ return buffer;
+}