QuickJSPlugin: read external data

warp-contracts-plugin-quickjs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "warp-contracts-plugin-quickjs",
-  "version": "1.1.12",
+  "version": "1.1.13",
   "license": "MIT",
   "main": "./build/cjs/index.js",
   "module": "./build/esm/index.js",
@@ -38,10 +38,11 @@
     "warp-contracts-plugin-deploy": "^1.0.13"
   },
   "dependencies": {
+    "@permaweb/aoconnect": "^0.0.62",
     "@redstone-finance/protocol": "0.5.4",
     "fast-copy": "^3.0.2",
     "pngjs": "7.0.0",
-    "quickjs-emscripten": "^0.29.2",
+    "quickjs-emscripten": "^0.31.0",
     "seedrandom": "^3.0.5",
     "warp-contracts": "1.4.40"
   },

warp-contracts-plugin-quickjs/src/QuickJsHandlerApi.ts

@@ -1,5 +1,5 @@
-import { QuickJSContext, QuickJSHandle, QuickJSRuntime, QuickJSWASMModule } from 'quickjs-emscripten';
-import {AoInteractionResult, InteractionResult, LoggerFactory, QuickJsPluginMessage, Tag} from 'warp-contracts';
+import { QuickJSContext, QuickJSHandle, QuickJSRuntime } from 'quickjs-emscripten';
+import { AoInteractionResult, InteractionResult, LoggerFactory, QuickJsPluginMessage, Tag } from 'warp-contracts';
 import { errorEvalAndDispose } from './utils';
 
 export class QuickJsHandlerApi<State> {
@@ -8,10 +8,14 @@ export class QuickJsHandlerApi<State> {
   constructor(
     private readonly vm: QuickJSContext,
     private readonly runtime: QuickJSRuntime,
-    private readonly quickJS: QuickJSWASMModule,
+    private readonly isSourceAsync: boolean
   ) {}
 
-  async handle<Result>(message: QuickJsPluginMessage, env: ProcessEnv, state?: State): Promise<InteractionResult<State, Result>> {
+  async handle<Result>(
+    message: QuickJsPluginMessage,
+    env: ProcessEnv,
+    state?: State
+  ): Promise<InteractionResult<State, Result>> {
     if (state) {
       this.initState(state);
     }
@@ -27,9 +31,14 @@ export class QuickJsHandlerApi<State> {
     }
   }
 
-  private async runContractFunction<Result>(message: QuickJsPluginMessage, env: ProcessEnv): InteractionResult<State, Result> {
+  private async runContractFunction<Result>(
+    message: QuickJsPluginMessage,
+    env: ProcessEnv
+  ): InteractionResult<State, Result> {
     try {
-      const evalInteractionResult = this.vm.evalCode(`__handleDecorator(${JSON.stringify(message)}, ${JSON.stringify(env)})`);
+      const evalInteractionResult = this.isSourceAsync
+        ? await this.evalInteractionAsync(message, env)
+        : this.evalInteractionSync(message, env);
       if (evalInteractionResult.error) {
         errorEvalAndDispose('interaction', this.logger, this.vm, evalInteractionResult.error);
       } else {
@@ -69,6 +78,20 @@ export class QuickJsHandlerApi<State> {
     }
   }
 
+  private async evalInteractionAsync(message: QuickJsPluginMessage, env: ProcessEnv) {
+    const result = this.vm.evalCode(`(async () => {
+      return await __handleDecorator(${JSON.stringify(message)}, ${JSON.stringify(env)})
+    })()`);
+    const promiseHandle = this.vm.unwrapResult(result);
+    const evalInteractionResult = await this.vm.resolvePromise(promiseHandle);
+    promiseHandle.dispose();
+    return evalInteractionResult;
+  }
+
+  private evalInteractionSync(message: QuickJsPluginMessage, env: ProcessEnv) {
+    return this.vm.evalCode(`__handleDecorator(${JSON.stringify(message)}, ${JSON.stringify(env)})`);
+  }
+
   currentBinaryState(state: State): Buffer {
     const currentState = state || this.currentState();
     return Buffer.from(JSON.stringify(currentState));
@@ -99,19 +122,18 @@ export class QuickJsHandlerApi<State> {
     resultValue.dispose();
     return result;
   }
-
 }
 
 // https://cookbook_ao.g8way.io/concepts/processes.html
 export type ProcessEnv = {
   Process: {
-    Id: string,
-    Owner: string,
-    Tags: { name: string, value: string }[]
-  },
+    Id: string;
+    Owner: string;
+    Tags: { name: string; value: string }[];
+  };
   Module: {
-    Id: string,
-    Owner: string,
-    Tags: { name: string, value: string }[]
-  }
-}
+    Id: string;
+    Owner: string;
+    Tags: { name: string; value: string }[];
+  };
+};

warp-contracts-plugin-quickjs/src/eval/QuickJsEvaluator.ts

@@ -1,8 +1,11 @@
-import { QuickJSContext } from 'quickjs-emscripten';
-import { LoggerFactory } from 'warp-contracts';
+import { QuickJSContext, QuickJSHandle } from 'quickjs-emscripten';
+import { HandlerBasedContract, LoggerFactory } from 'warp-contracts';
 import { PNG } from 'pngjs';
 import seedrandom from 'seedrandom';
-import { SignedDataPackage } from "@redstone-finance/protocol"
+import { SignedDataPackage } from '@redstone-finance/protocol';
+import { timeout } from '../utils';
+
+const TIMEOUT_ASYNC_OPERATIONS = 10000;
 
 export class QuickJsEvaluator {
   private readonly logger = LoggerFactory.INST.create('QuickJsEvaluator');
@@ -39,7 +42,7 @@ export class QuickJsEvaluator {
     const randomHandle = this.vm.newFunction('random', (...args) => {
       const nativeArgs = args.map(this.vm.dump);
       const message = nativeArgs[0];
-      const uniqueValue = nativeArgs.length > 1 ? "" + nativeArgs[1] : ''
+      const uniqueValue = nativeArgs.length > 1 ? '' + nativeArgs[1] : '';
       const rng = seedrandom(message.Signature + uniqueValue);
       return this.vm.newNumber(rng());
     });
@@ -50,6 +53,60 @@ export class QuickJsEvaluator {
     randomHandle.dispose();
   }
 
+  dummyPromiseEval() {
+    const dummyPromiseEval = this.vm.newFunction('dummyPromise', () => {
+      const promise = this.vm.newPromise();
+      promise.resolve(this.vm.newString(''));
+      promise.settled.then(this.vm.runtime.executePendingJobs);
+      return promise.handle;
+    });
+    this.vm.setProp(this.vm.global, 'dummyPromise', dummyPromiseEval);
+    dummyPromiseEval.dispose();
+  }
+
+  evalExternal() {
+    const readExternalHandle = this.vm.newFunction('readExternal', (processIdHandle, actionHandle) => {
+      const promise = this.vm.newPromise();
+      this.readExternal(processIdHandle, actionHandle)
+        .then((result) => {
+          promise.resolve(this.vm.newString(result) || '');
+        })
+        .catch((error) => {
+          promise.reject(this.vm.newString(error?.message) || `External read threw an error.`);
+        });
+      promise.settled.then(this.vm.runtime.executePendingJobs);
+      return promise.handle;
+    });
+    this.vm.setProp(this.vm.global, 'readExternal', readExternalHandle);
+    readExternalHandle.dispose();
+  }
+
+  async readExternal(processIdHandle: QuickJSHandle, actionHandle: QuickJSHandle) {
+    const processId = this.vm.getString(processIdHandle);
+    const action = this.vm.getString(actionHandle);
+    const { dryrun } = await import('@permaweb/aoconnect');
+    try {
+      const result = await Promise.race<{
+        Output: any;
+        Messages: any[];
+        Spawns: any[];
+        Error?: any;
+      }>([
+        dryrun({
+          process: processId,
+          tags: [{ name: 'Action', value: action }],
+          data: '1234'
+        }),
+        timeout(TIMEOUT_ASYNC_OPERATIONS, 'Dryrun operation timed out after 10 seconds')
+      ]);
+      return result.Messages[0].Data;
+    } catch (error) {
+      const errorMessage = (error as Error).message;
+      this.logger.error(errorMessage);
+      throw new Error(errorMessage);
+    }
+  }
+
   evalRedStone() {
     const recoverSignerAddressHandle = this.vm.newFunction('recoverSignerAddress', (...args) => {
       const nativeArgs = args.map(this.vm.dump);

warp-contracts-plugin-quickjs/src/eval/evalCode/decorator.ts

@@ -1,3 +1,16 @@
+export const asyncDecorateProcessFn = (processCode: string) => {
+  return `
+        ${processCode}
+
+        async function __handleDecorator(message, env) {
+          ao.init(env);
+          currentMessage = message;
+          await handle(currentState, message);
+          return JSON.stringify(ao.outbox);
+        }
+    `;
+};
+
 export const decorateProcessFn = (processCode: string) => {
   return `
         ${processCode}

warp-contracts-plugin-quickjs/src/index.ts

@@ -15,7 +15,7 @@ import {
   newVariant
 } from 'quickjs-emscripten';
 import { QuickJsHandlerApi } from './QuickJsHandlerApi';
-import { decorateProcessFn } from './eval/evalCode/decorator';
+import { asyncDecorateProcessFn, decorateProcessFn } from './eval/evalCode/decorator';
 import { globals } from './eval/evalCode/globals';
 import { WasmModuleConfig } from './types';
 import { vmIntrinsics } from './utils';
@@ -25,8 +25,6 @@ export const DELIMITER = '|||';
 const MEMORY_LIMIT = 1024 * 640;
 const MAX_STACK_SIZE = 1024 * 320;
 const INTERRUPT_CYCLES = 1024;
-const MEMORY_INITIAL_PAGE_SIZE = 64 * 1024;
-const MEMORY_MAXIMUM_PAGE_SIZE = 2048;
 
 export class QuickJsPlugin<State> implements WarpPlugin<QuickJsPluginInput, Promise<QuickJsHandlerApi<State>>> {
   private readonly logger = LoggerFactory.INST.create('QuickJsPlugin');
@@ -37,23 +35,22 @@ export class QuickJsPlugin<State> implements WarpPlugin<QuickJsPluginInput, Prom
   constructor(private readonly quickJsOptions: QuickJsOptions) {}
 
   async process(input: QuickJsPluginInput): Promise<QuickJsHandlerApi<State>> {
-    ({
-      QuickJS: this.QuickJS,
-      runtime: this.runtime,
-      vm: this.vm
-    } = await this.configureWasmModule(input.binaryType));
+    const isSourceAsync = input.contractSource.search('async') > -1;
+    ({ QuickJS: this.QuickJS, runtime: this.runtime, vm: this.vm } = await this.configureWasmModule(isSourceAsync));
     this.setRuntimeOptions();
-
     const quickJsEvaluator = new QuickJsEvaluator(this.vm);
-
+    const processDecorator = isSourceAsync ? asyncDecorateProcessFn : decorateProcessFn;
     quickJsEvaluator.evalSeedRandom();
     quickJsEvaluator.evalGlobalsCode(globals);
-    quickJsEvaluator.evalHandleFnCode(decorateProcessFn, input.contractSource);
+    quickJsEvaluator.evalHandleFnCode(processDecorator, input.contractSource);
     quickJsEvaluator.evalLogging();
     quickJsEvaluator.evalPngJS();
     quickJsEvaluator.evalRedStone();
-
-    return new QuickJsHandlerApi(this.vm, this.runtime, this.QuickJS);
+    if (isSourceAsync) {
+      quickJsEvaluator.evalExternal();
+      quickJsEvaluator.dummyPromiseEval();
+    }
+    return new QuickJsHandlerApi(this.vm, this.runtime, isSourceAsync);
   }
 
   setRuntimeOptions() {
@@ -65,7 +62,7 @@ export class QuickJsPlugin<State> implements WarpPlugin<QuickJsPluginInput, Prom
     );
   }
 
-  async configureWasmModule(binaryType: QuickJsBinaryType): Promise<WasmModuleConfig> {
+  async configureWasmModule(isSourceAsync: boolean): Promise<WasmModuleConfig> {
     try {
       const initialWasmMemory = new WebAssembly.Memory({
         initial: 256, //*65536
@@ -80,7 +77,10 @@ export class QuickJsPlugin<State> implements WarpPlugin<QuickJsPluginInput, Prom
       const runtime = QuickJS.newRuntime();
 
       const vm = runtime.newContext({
-        intrinsics: vmIntrinsics
+        intrinsics: {
+          ...vmIntrinsics,
+          ...(isSourceAsync && { Promise: true })
+        }
       });
 
       return {

warp-contracts-plugin-quickjs/src/utils.ts

@@ -8,7 +8,7 @@ export const errorEvalAndDispose = (
   vm: QuickJSContext,
   evalError: QuickJSHandle
 ) => {
-  const error = vm.dump(evalError);
+  const error = vm.dump(evalError) || vm.getString(evalError);
   evalError.dispose();
   logger.error(`${evalType} eval failed: ${JSON.stringify(error)}`);
 
@@ -50,3 +50,11 @@ export const splitBuffer = (buffer: Buffer, delimiter: string) => {
   splitted.push(buffer.slice(start));
   return splitted;
 };
+
+export const timeout = (ms: number, message: string): Promise<never> => {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      reject(new Error(message));
+    }, ms);
+  });
+};

warp-contracts-plugin-quickjs/tools/quickjs-promise.mjs

@@ -0,0 +1,83 @@
+import { newQuickJSWASMModule, newVariant, RELEASE_SYNC } from 'quickjs-emscripten';
+import { dryrun } from '@permaweb/aoconnect';
+
+const mem = new WebAssembly.Memory({
+  initial: 256, //*65536
+  maximum: 2048 //*65536
+});
+const variant = newVariant(RELEASE_SYNC, {
+  wasmMemory: mem
+});
+const QuickJS = await newQuickJSWASMModule(variant);
+
+const vm = QuickJS.newContext();
+
+const timeout = (ms, message) => {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      reject(new Error(message));
+    }, ms);
+  });
+};
+
+const readExternalHandle = vm.newFunction('readExternal', () => {
+  const promise = vm.newPromise();
+  readExternal()
+    .then((result) => {
+      promise.resolve(vm.newString(result) || '');
+    })
+    .catch((error) => {
+      promise.reject(vm.newString(error.message) || '');
+    });
+  promise.settled.then(vm.runtime.executePendingJobs);
+  return promise.handle;
+});
+readExternalHandle.consume((handle) => vm.setProp(vm.global, 'readExternal', handle));
+
+async function readExternal() {
+  const result = await Promise.race([
+    fakedryrun({
+      process: 'iWM-odlyQHopPECpyz465p7ED8lm5d3hyyWtijKhie4',
+      tags: [{ name: 'Action', value: 'Read-Hollow' }],
+      data: '1234'
+    }),
+    timeout(1000, 'Operation timed out after 10 seconds')
+  ]);
+  return result.Messages[0].Data;
+}
+function fakedryrun(config) {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve({
+        Messages: [{ Data: JSON.stringify({ ap: { Price: '100', Quantity: '49' } }) }]
+      });
+    }, 20000);
+  });
+}
+
+const result = vm.evalCode(`(async () => {
+  const content = await readExternal()
+  return content;
+})()`);
+const promiseHandle = vm.unwrapResult(result);
+const resolvedResult = await vm.resolvePromise(promiseHandle);
+promiseHandle.dispose();
+
+if (resolvedResult.error) {
+  //   const errorMessage = vm.getString(resolvedResult.error);
+  const error = vm.dump(resolvedResult) || vm.getString(resolvedResult.error);
+  resolvedResult.error.dispose();
+  console.log(`eval failed: ${JSON.stringify(error)}`);
+
+  throw new EvalError(`eval failed.`, {
+    name: error.name,
+    evalMessage: error.message,
+    stack: error.stack
+  });
+} else {
+  const resultValue = resolvedResult.value;
+  const stringValue = vm.getString(resultValue);
+  const result = stringValue === 'undefined' ? undefined : JSON.parse(vm.getString(resultValue));
+  resultValue.dispose();
+  console.log('Result:', result);
+}