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.12-external.0",
   "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 { AoInteractionResult, InteractionResult, LoggerFactory, QuickJsPluginMessage, Tag } from 'warp-contracts';
 import { errorEvalAndDispose } from './utils';
 
 export class QuickJsHandlerApi<State> {
@@ -8,14 +8,18 @@ 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);
     }
-    return this.runContractFunction(message, env);
+    return await this.runContractFunction(message, env);
   }
 
   initState(state: State): void {
@@ -27,13 +31,21 @@ 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 {
         const result: AoInteractionResult<Result> = this.disposeResult(evalInteractionResult);
+        if (this.isSourceAsync) {
+          this.vm.runtime.executePendingJobs();
+        }
         const state = this.currentState() as State;
         return {
           Memory: null,
@@ -69,6 +81,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 +125,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,8 @@
-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';
 
 export class QuickJsEvaluator {
   private readonly logger = LoggerFactory.INST.create('QuickJsEvaluator');
@@ -39,7 +39,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 +50,42 @@ 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(JSON.stringify(result) || ''));
+      });
+      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');
+    const readRes = await dryrun({
+      process: processId,
+      tags: [{ name: 'Action', value: action }],
+      data: '1234'
+    });
+    return JSON.parse(readRes.Messages[0].Data);
+  }
+
   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';
@@ -37,23 +37,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));
+    ({ QuickJS: this.QuickJS, runtime: this.runtime, vm: this.vm } = await this.configureWasmModule(input.binaryType));
     this.setRuntimeOptions();
 
     const quickJsEvaluator = new QuickJsEvaluator(this.vm);
-
+    const isSourceAsync = input.contractSource.search('async') > -1;
+    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();
+    quickJsEvaluator.evalExternal();
+    quickJsEvaluator.dummyPromiseEval();
 
-    return new QuickJsHandlerApi(this.vm, this.runtime, this.QuickJS);
+    return new QuickJsHandlerApi(this.vm, this.runtime, isSourceAsync);
   }
 
   setRuntimeOptions() {

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

@@ -23,7 +23,7 @@ export const vmIntrinsics = {
   ...DefaultIntrinsics,
   Date: false,
   Proxy: false,
-  Promise: false,
+  Promise: true,
   MapSet: false,
   BigFloat: false,
   BigInt: true,