make copy customizable with optional capacity

Author: querolita

src/lib/provable/dynamic-array.ts

@@ -417,6 +417,10 @@ class DynamicArrayBase<ProvableValue = any, Value = any> {
    * Shifts all elements of the array to the right by n positions, increasing
    * the length by n, which must result in less than or equal to the capacity.
    * The new elements on the left are set to NULL values.
+   * 
+   * **Warning**: This does not extend the capacity of the array, so if the
+   * array cannot be extended with `n` elements, it will fail. Consider copying
+   * the array into a new one that has larger capacity first.
    *
    * @param n
    */
@@ -436,13 +440,25 @@ 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. Optionally, one can specify a different `capacity` to 
+   * set the new array's capacity. If it is larger than the current capacity, 
+   * the copy can be done without failing. If it is smaller, the current length 
+   * must be less than or equal to the new capacity.
+   * 
+   * @returns a new DynamicArray instance with the same values as the current.
+   * 
    */
-  copy(): this {
-    let newArr = new (<any>this.constructor)();
-    newArr.array = this.array.slice();
-    newArr.length = this.length;
-    return newArr;
+  copy(capacity?: number): DynamicArray<ProvableValue, Value> {
+    const newCapacity = capacity ?? this.capacity;
+
+    if (newCapacity < this.capacity) {
+      this.length.assertLessThanOrEqual(new Field(newCapacity));
+    }
+
+    const CopiedArray = DynamicArray(this.innerType, { capacity: newCapacity });
+
+    return new CopiedArray(this.array, this.length);
   }
 
   /**

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

@@ -38,6 +38,35 @@ 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 of different capacities
+  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();
+  }
+
+  let copyLonger = fromArray.copy(16);
+  assert(copyLonger.length.equals(fromArray.length));
+  assert(copyLonger.capacity === 16);
+  assert(copyLonger.get(new Field(0)).value.equals(fromArray.get(new Field(1)).value));
+  assert(copyLonger.get(new Field(1)).value.equals(fromArray.get(new Field(2)).value));
+  assert(copyLonger.get(new Field(2)).value.equals(fromArray.get(new Field(3)).value));
+  for (let i = 3; i < 16; i++) {
+    copyLonger.getOption(new Field(i)).assertNone();
+  }
+
+  let copyShorter = fromArray.copy(4);
+  assert(copyShorter.length.equals(fromArray.length));
+  assert(copyShorter.capacity === 4);
+  assert(copyShorter.get(new Field(0)).value.equals(fromArray.get(new Field(1)).value));
+  assert(copyShorter.get(new Field(1)).value.equals(fromArray.get(new Field(2)).value));
+  assert(copyShorter.get(new Field(2)).value.equals(fromArray.get(new Field(3)).value));
+  copyShorter.getOption(new Field(3)).assertNone();
 
   // Initialize an empty dynamic array
   let bytes = new Bytestring();