Fix WASM memory bugs

Author: MatthewLM

coinlib/lib/src/common/checks.dart

@@ -1,4 +1,3 @@
-
 void _checkInt(int i, int min, int max, String type, String name) {
   if (i < min || i > max) {
     throw ArgumentError.value(i, name, "must be a $type");

coinlib/lib/src/secp256k1/heap_wasm.dart

@@ -1,5 +1,6 @@
 import 'dart:typed_data';
 import 'heap.dart';
+import 'wasm.dart';
 
 typedef MallocFunction = int Function(int);
 typedef FreeFunction = int Function(int);
@@ -14,52 +15,56 @@ class HeapWasm implements Heap<int> {
     (free) => free(),
   );
 
+  final Wasm _wasm;
+
   @override
   final int ptr;
 
-  HeapWasm._(this.ptr, FreeFunction free) {
-    _finalizer.attach(this, () => free(ptr));
+  HeapWasm._(this._wasm, this.ptr, FreeFunction free) {
+    // Copy avoids reference to object by finalizer ensuring that the object is
+    // indeed freed.
+    final ptrCopy = ptr;
+    _finalizer.attach(this, () => free(ptrCopy));
   }
 
+  Uint8List get memory => _wasm.memory;
+
 }
 
 /// Encapsulates a WASM heap-allocated unsigned char array, accessible as a
 /// Uint8List. Must be created through [HeapFactory].
 class HeapBytesWasm extends HeapWasm implements HeapBytes<int> {
 
   final int size;
-  final Uint8List _view;
 
-  HeapBytesWasm._(this.size, super.ptr, this._view, super.free) : super._();
+  HeapBytesWasm._(super._wasm, this.size, super.ptr, super.free) : super._();
 
   @override
-  Uint8List get copy => _view.sublist(0);
+  Uint8List get copy => memory.sublist(ptr, ptr+size);
 
   @override
-  Uint8List copyNBytes(int n) => _view.sublist(0, n);
+  Uint8List copyNBytes(int n) => memory.sublist(ptr, ptr+n);
 
   @override
-  load(Uint8List data) => _view.setAll(0, data);
+  load(Uint8List data) => memory.setAll(ptr, data);
 
 }
 
 class HeapIntWasm extends HeapWasm implements HeapInt<int> {
 
-  final ByteData _data;
+  HeapIntWasm._(super._wasm, super.ptr, super.free) : super._();
 
-  HeapIntWasm._(this._data, super.ptr, super.free) : super._();
-  HeapIntWasm._withMemory(Uint8List memory, super.ptr, super.free)
-    : _data = ByteData.view(memory.buffer), super._();
+  ByteData get _view => ByteData.view(memory.buffer);
 
   @override
-  set value(int i) => _data.setUint32(ptr, i, Endian.little);
+  set value(int i) => _view.setUint32(ptr, i, Endian.little);
 
   @override
-  int get value => _data.getUint32(ptr, Endian.little);
+  int get value => _view.getUint32(ptr, Endian.little);
 
   /// If this represents an integer array, get the integer at the [i] position.
   HeapIntWasm operator[](int i)
-    => HeapIntWasm._(_data, ptr+_intBytes*i, (_) => 0);
+    => HeapIntWasm._(_wasm, ptr+_intBytes*i, (_) => 0);
 
 }
 
@@ -71,8 +76,8 @@ implements HeapPointerArray<int, int> {
   final List<HeapWasm> _objs;
 
   HeapPointerArrayWasm._(
-    super.memory, super.ptr, super.free, this._objs,
-  ) : super._withMemory() {
+    super._wasm, super.ptr, super.free, this._objs,
+  ) : super._() {
     // Set pointers of array
     for (int i = 0; i < _objs.length; i++) {
       this[i].value = _objs[i].ptr;
@@ -88,38 +93,33 @@ implements HeapPointerArray<int, int> {
 /// functions.
 class HeapFactory {
 
-  final Uint8List _memory;
+  final Wasm _wasm;
   final MallocFunction _malloc;
   final FreeFunction _free;
 
-  HeapFactory(this._memory, this._malloc, this._free);
+  HeapFactory(this._wasm, this._malloc, this._free);
 
   /// Allocate a byte array of [size].
-  HeapBytesWasm bytes(int size) {
-    final ptr = _malloc(size);
-    final list = Uint8List.view(_memory.buffer, ptr, size);
-    return HeapBytesWasm._(size, ptr, list, _free);
-  }
+  HeapBytesWasm bytes(int size)
+    => HeapBytesWasm._(_wasm, size, _malloc(size), _free);
 
   /// Allocate data for a miscellaneous object with [size] bytes.
   /// If [copyFrom] is specified, data shall be copied from this pointer.
   HeapWasm alloc(int size, { int? copyFrom }) {
-    final heap = HeapWasm._(_malloc(size), _free);
+    final heap = HeapWasm._(_wasm, _malloc(size), _free);
     if (copyFrom != null) {
-      _memory.setRange(heap.ptr, heap.ptr + size, _memory, copyFrom);
+      heap.memory.setRange(heap.ptr, heap.ptr + size, heap.memory, copyFrom);
     }
     return heap;
   }
 
   /// Allocates an integer on the heap.
-  HeapIntWasm integer() => HeapIntWasm._withMemory(
-    _memory, _malloc(_intBytes), _free,
-  );
+  HeapIntWasm integer() => HeapIntWasm._(_wasm, _malloc(_intBytes), _free);
 
   /// Creates an array of pointers to the [objs].
   HeapPointerArrayWasm assignPointerArray(List<HeapWasm> objs)
     => HeapPointerArrayWasm._(
-      _memory,
+      _wasm,
       _malloc(objs.length*_intBytes),
       _free,
       objs,
@@ -129,7 +129,7 @@ class HeapFactory {
   /// [objSize].
   HeapPointerArrayWasm allocPointerArray(int length, int objSize)
     => assignPointerArray(
-      List.generate(length, (_) => HeapWasm._(_malloc(objSize), _free)),
+      List.generate(length, (_) => HeapWasm._(_wasm, _malloc(objSize), _free)),
     );
 
 }

coinlib/lib/src/secp256k1/secp256k1_web.dart

@@ -90,9 +90,7 @@ class Secp256k1 extends Secp256k1Base<
     final int Function(int, int) contextRandomize
       = wasm.field("secp256k1_context_randomize");
 
-    final MallocFunction malloc = wasm.field("malloc");
-    final FreeFunction free = wasm.field("free");
-    _heapFactory = HeapFactory(wasm.memory, malloc, free);
+    _heapFactory = HeapFactory(wasm, wasm.field("malloc"), wasm.field("free"));
 
     // Heap arrays
     key32Array = _heapFactory.bytes(Secp256k1Base.privkeySize);

coinlib/lib/src/secp256k1/wasm.dart

@@ -52,7 +52,10 @@ class Wasm {
 
   }
 
+  /// This must be used every single time memory access is required. It must not
+  /// be stored as it can be invalidated at any time.
   Uint8List get memory => _exports.memory.buffer.toDart.asUint8List();
+
   T field<T>(String name) => _exports.getProperty(name.toJS).dartify() as T;
 
 }