chore(assemblyscript): PR comments

.devcontainer/Dockerfile

@@ -2,5 +2,4 @@ ARG VARIANT=18
 FROM mcr.microsoft.com/vscode/devcontainers/typescript-node:${VARIANT}
 RUN apt-get update
 RUN apt-get -y install --no-install-recommends zsh
-RUN apt-get -y install binaryen
-RUN apt-get -y install build-essential cmake
+RUN apt-get -y install binaryen build-essential cmake

libs/as-sdk-integration-tests/README.md

@@ -0,0 +1,3 @@
+# AssemblyScript Integration Tests
+
+This project is for testing the SDK together with the VM project. This is used internally to validate if the functions act like they are supposed to

libs/as-sdk-integration-tests/assembly/index.ts

@@ -1,21 +1,24 @@
-// The entry file of your WebAssembly module.
-
 import { httpFetch, Process } from '../../as-sdk/assembly/index';
+import { testInvalidUint8JsonArray, testValidUint8JsonArray } from './json-utils-test';
 
 const args = Process.args()[0];
 
 if (args === 'testHttpRejection') {
   testHttpRejection();
 } else if (args === 'testHttpSuccess') {
   testHttpSuccess();
+} else if (args === 'testValidUint8JsonArray') {
+  testValidUint8JsonArray();
+} else if (args === 'testInvalidUint8JsonArray') {
+  testInvalidUint8JsonArray();
 }
 
 export function testHttpRejection(): void {
   const response = httpFetch('example.com/');
   const rejected = response.rejected;
 
   if (rejected !== null) {
-    const msg = String.UTF8.encode('ok');
+    const msg = String.UTF8.encode('rejected');
     const buffer = Uint8Array.wrap(msg);
 
     Process.exit_with_result(0, buffer);

libs/as-sdk-integration-tests/assembly/json-utils-test.ts

@@ -0,0 +1,26 @@
+import { jsonArrToUint8Array, JSON, testutils } from '../../as-sdk/assembly/index';
+
+export function testValidUint8JsonArray(): void {
+  const raw: string = "[0, 23, 254, 88]";
+  const json = <JSON.Arr>JSON.parse(raw);
+  const result = jsonArrToUint8Array(json);
+
+  const expected = new Uint8Array(4);
+  expected.set([0, 23, 254, 88]);
+
+  testutils.assert(result.byteLength === expected.byteLength, "bytelength is not equal");
+  testutils.assert(
+    String.UTF8.decode(result.buffer) === String.UTF8.decode(expected.buffer),
+    'buffers are not equal'
+  );
+
+  testutils.ok();
+}
+
+export function testInvalidUint8JsonArray(): void {
+  const raw: string = '[0, 23, 299, 88]';
+  const json = <JSON.Arr>JSON.parse(raw);
+  jsonArrToUint8Array(json);
+
+  testutils.error("Test should fail");
+}

libs/as-sdk-integration-tests/project.json

@@ -18,6 +18,7 @@
         "jestConfig": "libs/as-sdk-integration-tests/jest.config.ts",
         "passWithNoTests": true
       },
+      "dependsOn": [{ "target": "build" }],
       "configurations": {
         "ci": {
           "ci": true,

libs/as-sdk-integration-tests/src/http.test.ts

@@ -21,7 +21,7 @@ describe('Http', () => {
     });
 
     expect(result.exitCode).toBe(0);
-    expect(result.result).toEqual(new TextEncoder().encode("ok"));
+    expect(result.result).toEqual(new TextEncoder().encode("rejected"));
   });
 
   it('Test SDK HTTP Success', async () => {

libs/as-sdk-integration-tests/src/jsonutils.test.ts

@@ -0,0 +1,32 @@
+import { readFile } from "fs/promises";
+import { callVm } from "../../../dist/libs/vm/src";
+
+describe('json-utils', () => {
+  it('should handle valid u8 json arrays', async () => {
+     const wasmBinary = await readFile(
+       'dist/libs/as-sdk-integration-tests/debug.wasm'
+     );
+     const result = await callVm({
+       args: ['testValidUint8JsonArray'],
+       envs: {},
+       binary: new Uint8Array(wasmBinary),
+     });
+
+     expect(result.resultAsString).toEqual('ok');
+     expect(result.exitCode).toBe(0);
+  });
+
+  it('should error on invalid u8 json arrays', async () => {
+    const wasmBinary = await readFile(
+      'dist/libs/as-sdk-integration-tests/debug.wasm'
+    );
+    const result = await callVm({
+      args: ['testInvalidUint8JsonArray'],
+      envs: {},
+      binary: new Uint8Array(wasmBinary),
+    });
+
+    expect(result.stderr).toContain('abort: Invalid u8 299');
+    expect(result.exitCode).toBe(255);
+  });
+});

libs/as-sdk/README.md

@@ -0,0 +1,3 @@
+# AssemblyScript SDK
+
+SDK for creating Data Requests on the SEDA chain

libs/as-sdk/assembly/index.ts

@@ -1,8 +1,9 @@
-// The entry file of your WebAssembly module.
 import Process from './process';
+import * as testutils from './test-utils';
 
-
+export { JSON, JSONDecoder, JSONEncoder, DecoderState, JSONHandler, ThrowingJSONHandler } from '../../../node_modules/assemblyscript-json/assembly/index';
 export { httpFetch, HttpFetchMethod, HttpFetchOptions, HttpResponse } from './http';
 export { PromiseStatus } from './promise';
-export { Process };
+export { Process, testutils };
+export { jsonArrToUint8Array } from './json-utils';
 

libs/as-sdk/assembly/json-utils.ts

@@ -6,6 +6,11 @@ export function jsonArrToUint8Array(array: JSON.Arr): Uint8Array {
 
   for (let i = 0; i < innerArrayValue.length; i++) {
     const element = <JSON.Integer>innerArrayValue[i];
+
+    if (element.valueOf() > i64(U8.MAX_VALUE) || element.valueOf() < i64(U8.MIN_VALUE)) {
+      throw new Error(`Invalid u8 ${element.valueOf()}`);
+    }
+
     bytes.push(u8(element.valueOf()));
   }
 

libs/as-sdk/assembly/process.ts

@@ -6,6 +6,13 @@ export default class Process {
     return CommandLine.all;
   }
 
+  static exit_with_message(code: u8, message: string): void {
+    const msg = String.UTF8.encode(message);
+    const buffer = Uint8Array.wrap(msg);
+
+    Process.exit_with_result(code, buffer);
+  }
+
   static exit_with_result(code: u8, result: Uint8Array): void {
     const buffer = result.buffer;
     const bufferPtr = changetype<usize>(buffer);

libs/as-sdk/assembly/promise.ts

@@ -11,14 +11,6 @@ export class PromiseStatus<F, R> {
     public rejected: R | null
   ) {}
 
-  isFulfilled(): bool {
-    return this.fulfilled !== null;
-  }
-
-  isRejected(): bool {
-    return this.rejected !== null;
-  }
-
   static fromStr<F extends FromBuffer<F>, R extends FromBuffer<R>>(promiseStatus: string, fulfilled: F, rejected: R): PromiseStatus<F, R> {
     const value = <JSON.Obj>JSON.parse(promiseStatus);
     let fulfilledResult: F | null = null;

libs/as-sdk/assembly/test-utils.ts

@@ -0,0 +1,18 @@
+import Process from './process';
+
+@inline
+export function assert(expected: bool, message: string): void {
+  if (!expected) {
+    Process.exit_with_message(1, message);
+  }
+}
+
+@inline
+export function ok(message: string = "ok"): void {
+  Process.exit_with_message(0, message);
+}
+
+@inline
+export function error(message: string = "error"): void {
+  Process.exit_with_message(1, message);
+}

libs/vm/README.md

@@ -0,0 +1,3 @@
+# SEDA VM
+
+Virtual Machine used for testing your Data Request using JavaScript

libs/vm/src/vm.test.ts

@@ -35,7 +35,7 @@ describe("vm", () => {
       binary: new Uint8Array(wasmBinary),
     });
 
-    expect(result).toEqual({ exitCode: 0, stderr: '', stdout: 'hello world\n', result: new Uint8Array() });
+    expect(result).toEqual({ exitCode: 0, stderr: '', stdout: 'hello world\n', result: new Uint8Array(), resultAsString: '' });
   });
 
   it("should exit when an invalid WASM binary is given", async ()  => {
@@ -45,7 +45,7 @@ describe("vm", () => {
       binary: new Uint8Array([0, 97, 115, 109]),
     });
 
-    expect(result).toEqual({ exitCode: 1, stderr: 'CompileError: WebAssembly.compile(): expected 4 bytes, fell off end @+4', stdout: '', result: new Uint8Array() });
+    expect(result).toEqual({ exitCode: 1, stderr: 'CompileError: WebAssembly.compile(): expected 4 bytes, fell off end @+4', stdout: '', result: new Uint8Array(), resultAsString: '' });
   });
 
   it('should be able to call the given adapter', async () => {

libs/vm/src/vm.ts

@@ -12,6 +12,7 @@ export interface VmResult {
   stderr: string;
   exitCode: number;
   result?: Uint8Array;
+  resultAsString?: string;
 }
 
 export async function executeVm(callData: VmCallData, notifierBuffer: SharedArrayBuffer): Promise<VmResult> {
@@ -40,6 +41,7 @@ export async function executeVm(callData: VmCallData, notifierBuffer: SharedArra
       stderr: wasi.getStderrString(),
       stdout: wasi.getStdoutString(),
       result: vmImports.result,
+      resultAsString: new TextDecoder().decode(vmImports.result),
     }
   } catch (err) {
     console.error(`
@@ -56,6 +58,7 @@ export async function executeVm(callData: VmCallData, notifierBuffer: SharedArra
       stderr: stderr !== '' ? stderr : (err + ''),
       stdout: wasi.getStdoutString(),
       result: new Uint8Array(),
+      resultAsString: '',
     };
   }
 }

libs/vm/src/worker-host-communication.ts

@@ -57,6 +57,11 @@ export class HostToWorker {
       this.actionResult = PromiseStatus.rejected(new EmptyBuffer);
     }
 
+    if (typeof this.actionResult === 'undefined') {
+      console.error('Objects that failed:', this, action);
+      throw Error(`Result was undefined while reading. Action was: ${action}`);
+    }
+
     if (this.actionResult.length > MAX_I32_VALUE) {
       throw Error(`Value ${this.actionResult.length} exceeds max i32 (${MAX_I32_VALUE})`);
     }