use manifest to contract

Author: samuelmanzanera

example/transactionBuilder/app.js

@@ -249,14 +249,11 @@ let namedParams = [];
 
 window.onChangeRecipient = async () => {
   const address = document.querySelector("#recipient").value;
-  const contractCode = await archethic.network.getContractCode(address);
-  if (contractCode == "") {
-    return;
-  }
+  const contractContext = await archethic.network.getContractCode(address);
 
   document.querySelector("#namedActionsContainer").style.display = "block";
 
-  const actions = await Contract.extractActionsFromContract(contractCode);
+  const actions = await Contract.extractActionsFromContract(contractContext);
   actions.forEach((action) => {
     const option = document.createElement("option");
     option.text = action.name;

src/api.ts

@@ -355,9 +355,9 @@ export async function getContractCode(address: string | Uint8Array, endpoint: st
     .then(handleResponse)
     .then((res): string => {
       if (res.errors || res.data == null) {
-        return "";
+        throw new Error("No contract at this address")
       } else {
-        return res.data.lastTransaction.data.code;
+        return res.data.lastTransaction.data.code
       }
     });
 }

src/contract.ts

@@ -2,59 +2,64 @@ import { ContractAction } from "./types.js";
 import { encryptSecret, deriveAddress } from "./crypto.js";
 import { ExtendedTransactionBuilder } from "./transaction.js";
 import Archethic from "./index.js";
-import { hexToUint8Array, isHex } from "./utils.js";
+import { isHex } from "./utils.js";
 
-export async function extractActionsFromContract(code: string): Promise<ContractAction[]> {
-  let actions = [];
+type CodeWithManifest = {
+  bytecode: string;
+  manifest: WasmManifest
+}
 
-  if (isHex(code)) {
-    const wasmModule = await WebAssembly.instantiate(hexToUint8Array(code), {
-      "archethic/env": {
-        log: (offset: bigint, length: bigint) => {},
-        store_u8: (offset: bigint, data: bigint) => {},
-        load_u8: (offset: bigint): number => 0,
-        input_size: (): bigint => 0n,
-        alloc: (length: bigint): bigint => 0n,
-        set_output: (offset: bigint, length: bigint) => {},
-        set_error: (offset: bigint, length: bigint) => {}
-      },
-      // FIXME with JSON RPC like request
-      "archethic/IO": {
-        get_balance: (offset: bigint, length: bigint) => 0
-      }
-    });
+type WasmManifest = {
+  abi: WasmABI
+}
 
-    const reservedFunctions = ["spec", "init", "onUpgrade"];
-    for (let key in wasmModule.instance.exports) {
-      if (wasmModule.instance.exports[key] instanceof Function) {
-        if (!reservedFunctions.includes(key)) {
-          actions.push({ name: key, parameters: ["WASM JSON Input"] });
-        }
-      }
-    }
+type WasmABI = {
+  functions: Record<string, WASMFunctionABI>
+}
 
-    actions.push({ name: "upgrade", parameters: ['WASM JSON Input ( {"code": "wasm code as hex"})'] });
+type WASMFunctionABI = {
+  type: string;
+  name: string;
+  input: Record<string, any>
+}
 
-    return actions;
+export async function extractActionsFromContract(code: string): Promise<ContractAction[]> {
+  try {
+    const codeWithManifest: CodeWithManifest = JSON.parse(code)
+    const manifest = codeWithManifest.manifest
+    let actions: ContractAction[] = []
+    for (let name of Object.keys(manifest.abi.functions)) {
+      const functionABI = manifest.abi.functions[name]
+      if (functionABI.type == "action") {
+        actions.push({
+          name: name,
+          parameters: Object.keys(functionABI.input)
+       })
+      }
+    }
+    return actions
   }
+  catch(e) {
+    let actions = [];
 
-  const regex = /actions\s+triggered_by:\s+transaction,\s+on:\s+([\w\s.,()]+?)\s+do/g;
+    const regex = /actions\s+triggered_by:\s+transaction,\s+on:\s+([\w\s.,()]+?)\s+do/g;
 
-  for (const match of code.matchAll(regex)) {
-    const fullAction = match[1];
+    for (const match of code.matchAll(regex)) {
+      const fullAction = match[1];
 
-    const regexActionName = /(\w+)\((.*?)\)/g;
-    for (const actionMatch of fullAction.matchAll(regexActionName)) {
-      const name = actionMatch[1];
-      const parameters = actionMatch[2] != "" ? actionMatch[2].split(",") : [];
-      actions.push({
-        name: name,
-        parameters: parameters
-      });
+      const regexActionName = /(\w+)\((.*?)\)/g;
+      for (const actionMatch of fullAction.matchAll(regexActionName)) {
+        const name = actionMatch[1];
+        const parameters = actionMatch[2] != "" ? actionMatch[2].split(",") : [];
+        actions.push({
+          name: name,
+          parameters: parameters
+        });
+      }
     }
-  }
 
-  return actions;
+    return actions;
+  }
 }
 
 export function parseTypedArgument(input: any): any {

src/transaction_builder.ts

@@ -433,36 +433,13 @@ export default class TransactionBuilder {
    * JSON RPC API SEND_TRANSACTION
    */
   async toNodeRPC(): Promise<TransactionRPC> {
-    async function asyncConcatUint8Arrays(uint8arrays: Uint8Array[]) {
-      const blob = new Blob(uint8arrays);
-      const buffer = await blob.arrayBuffer();
-      return new Uint8Array(buffer);
-    }
-
-    async function compress(str: Uint8Array): Promise<Uint8Array> {
-      // Convert the string to a byte stream.
-      const stream = new Blob([str]).stream();
-
-      // Create a compressed stream.
-      const compressedStream = stream.pipeThrough(new CompressionStream("deflate-raw"));
-
-      // Read all the bytes from this stream.
-      const chunks: Uint8Array[] = [];
-      //@ts-ignore
-      for await (const chunk of compressedStream) {
-        chunks.push(chunk);
-      }
-
-      return await asyncConcatUint8Arrays(chunks);
-    }
-
     return {
       version: this.version,
       address: uint8ArrayToHex(this.address),
       type: this.type,
       data: {
         content: new TextDecoder().decode(this.data.content),
-        code: uint8ArrayToHex(await compress(this.data.code)),
+        code: new TextDecoder().decode(this.data.code),
         ownerships: this.data.ownerships.map(({ secret, authorizedPublicKeys }) => {
           return {
             secret: uint8ArrayToHex(secret),