unit test with copy

Author: querolita

src/lib/provable/dynamic-array.ts

@@ -57,7 +57,9 @@ function DynamicArray<
    * Note: Both the actual length and the values beyond the original ones will
    * be constant.
    */
-  from(v: (ProvableValue | Value)[] | DynamicArrayBase<ProvableValue, Value>): DynamicArrayBase<ProvableValue, Value>;
+  from(
+    v: (ProvableValue | Value)[] | DynamicArrayBase<ProvableValue, Value>
+  ): DynamicArrayBase<ProvableValue, Value>;
 } {
   let innerType: Provable<ProvableValue, Value> = ProvableType.get(type);
 
@@ -308,32 +310,56 @@ class DynamicArrayBase<ProvableValue = any, Value = any> {
   /**
    * Increments the length of the current array by n elements, checking that the
    * new length is within the capacity.
+   *
+   * An optional error message can be provided to be used in case the inner
+   * assertion fails.
+   *
+   * @param n
+   * @param message
    */
-  increaseLengthBy(n: Field): void {
+  increaseLengthBy(n: Field, message?: string): void {
+    let errorMessage =
+      message ??
+      `increaseLengthBy: cannot increase length because provided n would exceed capacity ${this.capacity}.`;
+
     let newLength = this.length.add(n).seal();
-    newLength.lessThanOrEqual(new Field(this.capacity)).assertTrue();
+    newLength.assertLessThanOrEqual(new Field(this.capacity), errorMessage);
     this.length = newLength;
   }
 
   /**
-   * Decrements the length of the current array by n elements, checking that the
-   * n is less or equal than the current length.
+   * Decrements the length of the current array by `n` elements, checking that
+   * the `n` is less or equal than the current length.
+   *
+   * An optional error message can be provided to be used in case the inner
+   * assertion fails.
+   *
+   * @param n
+   * @param message
    */
-  decreaseLengthBy(n: Field): void {
+  decreaseLengthBy(n: Field, message?: string): void {
+    let errorMessage =
+      message ??
+      `decreaseLengthBy: cannot decrease length because provided n is larger than current array length ${this.length}`;
+
     let oldLength = this.length;
-    n.assertLessThanOrEqual(this.length);
+    n.assertLessThanOrEqual(this.length, errorMessage);
     this.length = oldLength.sub(n).seal();
   }
 
   /**
    * Sets the length of the current array to a new value, checking that the
    * new length is less or equal than the capacity.
-   * 
-   * @param newLength 
-   * 
+   *
+   * An optional error message can be provided to be used in case the inner
+   * assertion fails.
+   *
+   * @param newLength
+   * @param message
+   *
    * **Warning**: This does not change (add nor remove) the values of the array.
    */
-  setLengthTo(n: Field): void {
+  setLengthTo(n: Field, message?: string): void {
     n.assertLessThanOrEqual(new Field(this.capacity));
     this.length = n;
   }
@@ -436,7 +462,11 @@ class DynamicArrayBase<ProvableValue = any, Value = any> {
   }
 
   /**
-   * @returns a new DynamicArray instance with the same values as the current
+   * Copies the current dynamic array, returning a new instance with the same
+   * values and length.
+   *
+   * @returns a new DynamicArray instance with the same values as the current.
+   *
    */
   copy(): this {
     let newArr = new (<any>this.constructor)();

src/lib/provable/test/dynamic-array.unit-test.ts

@@ -27,7 +27,7 @@ import { Provable } from '../provable.js';
   assert(fromArray.capacity === 8);
 
   let fromLength = new Bytestring(undefined, new Field(0));
-  assert(fromLength.length.equals(new Field(0)))
+  assert(fromLength.length.equals(new Field(0)));
   assert(fromLength.capacity === 8);
 
   let fromArrayLength = new Bytestring(
@@ -38,7 +38,18 @@ import { Provable } from '../provable.js';
   assert(fromArrayLength.get(new Field(1)).value.equals(new Field(2)));
   assert(fromArrayLength.get(new Field(2)).value.equals(new Field(3)));
   fromArrayLength.getOption(new Field(3)).assertNone();
-  
+
+  // Copy into new dynamic arrays
+  let copySame = fromArray.copy();
+  assert(copySame.length.equals(fromArray.length));
+  assert(copySame.capacity === fromArray.capacity);
+  assert(copySame.get(new Field(0)).value.equals(fromArray.get(new Field(1)).value));
+  assert(copySame.get(new Field(1)).value.equals(fromArray.get(new Field(2)).value));
+  assert(copySame.get(new Field(2)).value.equals(fromArray.get(new Field(3)).value));
+  for (let i = 3; i < 8; i++) {
+    copySame.getOption(new Field(i)).assertNone();
+  }
+
   // Initialize an empty dynamic array
   let bytes = new Bytestring();
 
@@ -349,17 +360,16 @@ import { Provable } from '../provable.js';
 
 // Provable behaviour
 {
-class Bytestring extends DynamicArray(UInt8, { capacity: 8 }) {}
+  class Bytestring extends DynamicArray(UInt8, { capacity: 8 }) {}
 
-await Provable.runAndCheck(() => {
-  let b = Provable.witness(Bytestring, () => new Bytestring());
-  b.push(UInt8.from(1));
-});
+  await Provable.runAndCheck(() => {
+    let b = Provable.witness(Bytestring, () => new Bytestring());
+    b.push(UInt8.from(1));
+  });
 }
 
 // In-circuit test for dynamic arrays
 {
-
   let List = ZkProgram({
     name: 'dynamicarrays-circuit',
     methods: {
@@ -416,7 +426,6 @@ await Provable.runAndCheck(() => {
           assert(longerArray.get(new Field(0)).value.equals(sameArray.get(new Field(0)).value));
           assert(otherArray.get(new Field(0)).value.equals(bytes.get(new Field(0)).value));
 
-
           // Mapping over elements should work correctly
           bytes.push(v0.add(new UInt8(1)));
           bytes.push(v0.mul(new UInt8(0)));