work with both JSON and BCS payloads

Author: Manahip

src/ast_to_ts.rs

@@ -259,6 +259,7 @@ pub fn write_app(
         if func.signature.type_parameters.len() > 0 {
             w.writeln(format!("  $p: TypeTag[], /* <{}>*/", tpnames));
         }
+        w.writeln("  isJSON = false,");
         let tags = if func.signature.type_parameters.is_empty() {
             ""
         } else {
@@ -269,10 +270,15 @@ pub fn write_app(
         } else {
             ", "
         };
+        let possibly_comma = if args.is_empty() && tags.is_empty() {
+            ""
+        } else {
+            ", "
+        };
         w.writeln(") {");
         w.writeln(format!(
-            "  return buildPayload_{}({}{}{});",
-            fname, args, separator, tags
+            "  return buildPayload_{}({}{}{}{}isJSON);",
+            fname, args, separator, tags, possibly_comma,
         ));
         w.writeln("}");
 
@@ -284,10 +290,11 @@ pub fn write_app(
             w.writeln(format!("  $p: TypeTag[], /* <{}>*/", tpnames));
         }
         w.writeln("  _maxGas = 1000,");
+        w.writeln("  _isJSON = false,");
         w.writeln(") {");
         w.writeln(format!(
-            "  const payload = buildPayload_{}({}{}{});",
-            fname, args, separator, tags
+            "  const payload = buildPayload_{}({}{}{}{}_isJSON);",
+            fname, args, separator, tags, possibly_comma
         ));
         w.writeln("  return $.sendPayloadTx(this.client, _account, payload, _maxGas);");
         w.writeln("}");
@@ -1007,7 +1014,7 @@ pub fn write_query_function(
 
     // params
     w.writeln("client: AptosClient,");
-    w.writeln("account: AptosAccount,");
+    w.writeln("fetcher: $.SimulationKeys,");
     w.writeln("repo: AptosParserRepo,");
     write_parameters(&f.signature, w, c, true, false)?;
     w.writeln("$p: TypeTag[],");
@@ -1053,7 +1060,7 @@ pub fn write_query_function(
     ));
     let output_tag = base_type_to_typetag(return_type, c)?;
     w.writeln(format!("const outputTypeTag = {};", output_tag));
-    w.writeln("const output = await $.simulatePayloadTx(client, account, payload);");
+    w.writeln("const output = await $.simulatePayloadTx(client, fetcher, payload);");
     w.writeln(format!(
         "return $.takeSimulationValue<{}>(output, outputTypeTag, repo)",
         output_struct_name
@@ -1069,7 +1076,7 @@ pub fn write_query_function(
     w.writeln("function maker(");
     w.increase_indent();
 
-    w.writeln("account: AptosAccount,");
+    w.writeln("fetcher: $.SimulationKeys,");
     write_parameters(&f.signature, w, c, true, false)?;
     w.writeln("$p: TypeTag[],");
 
@@ -1080,7 +1087,7 @@ pub fn write_query_function(
         param_list.push("$p".to_string());
     }
     w.writeln(format!(
-        "  return {}(app.client, account, app.repo, {})",
+        "  return {}(app.client, fetcher, app.repo, {})",
         query_fname,
         param_list.join(", ")
     ));
@@ -1309,6 +1316,7 @@ impl AstTsPrinter for (FunctionName, &Function) {
             if num_tparams > 0 {
                 w.writeln(format!("  $p: TypeTag[], /* <{}>*/", tpnames));
             }
+            w.writeln("  isJSON = false,");
             // marks returnType or void
             w.write(") ");
             // body:
@@ -1338,14 +1346,15 @@ impl AstTsPrinter for (FunctionName, &Function) {
                 w.writeln("  typeParamStrings,");
                 // arguments
                 if params_no_signers.is_empty() {
-                    w.writeln("  []");
+                    w.writeln("  [],");
                 } else {
                     w.writeln("  [");
                     for (pname, _) in params_no_signers.iter() {
                         w.writeln(format!("    {},", pname,));
                     }
-                    w.writeln("  ]");
+                    w.writeln("  ],");
                 }
+                w.writeln("  isJSON,");
                 w.writeln(");");
                 Ok(())
             })?;

src/gen_cli.rs

@@ -381,7 +381,7 @@ pub fn generate_query_printer(query: &CmdParams) -> Result<(String, String), Dia
 const {} = async ({}) => {{
   const {{client, account}} = readConfig(program);
   const repo = getProjectRepo();
-  const value = await {}(client, account, repo, {}{}[{}])
+  const value = await {}(client, getSimulationKeys(account), repo, {}{}[{}])
   print(value);
 }}
 
@@ -532,7 +532,7 @@ pub fn generate_cli(ctx: &Context) -> Result<(String, String), Diagnostics> {
     let filename = "cli.ts".to_string();
     let content = format!(
         r###"
-import {{ AptosParserRepo, getTypeTagFullname, StructTag, parseTypeTagOrThrow, u8, u64, u128, print, strToU8, u8str, DummyCache, ActualStringClass, sendPayloadTx }} from "@manahippo/move-to-ts";
+import {{ AptosParserRepo, getTypeTagFullname, StructTag, parseTypeTagOrThrow, u8, u64, u128, print, strToU8, u8str, DummyCache, ActualStringClass, sendPayloadTx, getSimulationKeys }} from "@manahippo/move-to-ts";
 import {{ AptosAccount, AptosClient, HexString, Types }} from "aptos";
 import {{ Command }} from "commander";
 import {{ getProjectRepo }} from "./";

src/main.rs

@@ -24,7 +24,6 @@ use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};
 use std::process;
 use std::rc::Rc;
-use move_compiler::expansion::ast::Value_::Address;
 
 fn write_file(root_path: &PathBuf, pair: (String, String)) {
     let (filename, content) = pair;

src/utils.rs

@@ -67,7 +67,7 @@ pub fn generate_package_json(package_name: String, cli: bool, ui: bool) -> (Stri
   "dependencies": {{
     "aptos": "^1.3.7",
     "big-integer": "^1.6.51",{}
-    "@manahippo/move-to-ts": "^0.1.28"
+    "@manahippo/move-to-ts": "^0.2.8"
   }}
 }}
 "###,

typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manahippo/move-to-ts",
-  "version": "0.1.28",
+  "version": "0.2.8",
   "license": "MIT",
   "scripts": {
     "build": "rm -rf dist; tsc -p tsconfig.json",

typescript/src/txSender.ts

@@ -1,11 +1,11 @@
-import { AptosClient, AptosAccount, Types, TxnBuilderTypes, HexString, BCS } from "aptos";
+import { AptosClient, AptosAccount, Types, TxnBuilderTypes, HexString, BCS, TransactionBuilderEd25519 } from "aptos";
 import { TypeTagParser } from "aptos/dist/transaction_builder/builder_utils";
-import { UserTransaction, WriteSetChange_WriteResource } from "aptos/dist/generated";
+import { $TransactionPayload_EntryFunctionPayload, TransactionPayload_EntryFunctionPayload, TransactionSignature, UserTransaction, WriteSetChange_WriteResource } from "aptos/dist/generated";
 import { AccountAddress, Identifier, ModuleId, EntryFunction } from "aptos/dist/transaction_builder/aptos_types";
 import { AptosParserRepo } from "./parserRepo";
-import { AtomicTypeTag, StructTag, TypeTag } from "./typeTag";
+import { StructTag } from "./typeTag";
 import { U128, U64, U8 } from "./builtinTypes";
-import { ActualStringClass, serializeMoveValue, serializeMoveValueWithoutTag, serializeVector } from ".";
+import { ActualStringClass, payloadArg, serializeMoveValueWithoutTag } from ".";
 
 type AcceptedScriptFuncArgType = any[] | U8 | U64 | U128 | HexString | boolean | ActualStringClass;
 
@@ -15,59 +15,133 @@ export function buildPayload(
   funcName: string,
   typeArguments: string[],
   args: AcceptedScriptFuncArgType[],
-): TxnBuilderTypes.TransactionPayloadEntryFunction {
+  isJSON = false,
+): TxnBuilderTypes.TransactionPayloadEntryFunction | TransactionPayload_EntryFunctionPayload {
 
-  const bytes = args.map(arg => {
-    const serializer = new BCS.Serializer();
-    serializeMoveValueWithoutTag(serializer, arg);
-    return serializer.getBytes();
-  });
+  if (isJSON) {
+    // JSON
+    return {
+      type: "entry_function_payload",
+      function: `${moduleAddress.toShortString()}::${moduleName}::${funcName}`,
+      type_arguments: typeArguments,
+      arguments: args.map(v => payloadArg(v)),
+    };
+  }
+  else {
+    // BCS
+    const bytes = args.map(arg => {
+      const serializer = new BCS.Serializer();
+      serializeMoveValueWithoutTag(serializer, arg);
+      return serializer.getBytes();
+    });
 
-  
-  const scriptFunction = new EntryFunction(
-    new ModuleId(new AccountAddress(moduleAddress.toUint8Array()), new Identifier(moduleName)),
-    new Identifier(funcName),
-    typeArguments.map(str => new TypeTagParser(str).parseTypeTag()),
-    bytes,
-  );
-  return new TxnBuilderTypes.TransactionPayloadEntryFunction(scriptFunction);
+    
+    const scriptFunction = new EntryFunction(
+      new ModuleId(new AccountAddress(moduleAddress.toUint8Array()), new Identifier(moduleName)),
+      new Identifier(funcName),
+      typeArguments.map(str => new TypeTagParser(str).parseTypeTag()),
+      bytes,
+    );
+    return new TxnBuilderTypes.TransactionPayloadEntryFunction(scriptFunction);
+    }
 }
 
 export async function sendPayloadTx(
   client: AptosClient, 
   account: AptosAccount, 
-  payload: TxnBuilderTypes.TransactionPayload, 
+  payload: TxnBuilderTypes.TransactionPayload | TransactionPayload_EntryFunctionPayload, 
   max_gas=1000
 ){
-  console.log("Building tx...");
-  // RawTransaction
-  const rawTxn = await client.generateRawTransaction(account.address(), payload, {maxGasAmount: BigInt(max_gas)});
-  // Signed BCS representation
-  const bcsTxn = AptosClient.generateBCSTransaction(account, rawTxn);
-  console.log("Submitting...");
-  const txnResult = await client.submitSignedBCSTransaction(bcsTxn);
-  console.log("Submitted");
-  await client.waitForTransaction(txnResult.hash);
-  console.log("Confirmed");
-  const txDetails = (await client.getTransactionByHash(txnResult.hash)) as Types.UserTransaction;
-  console.log(txDetails);
-  return txDetails;
+  // send BCS transaction
+  if (payload instanceof TxnBuilderTypes.TransactionPayloadEntryFunction) {
+    console.log("Building tx...");
+    // RawTransaction
+    const rawTxn = await client.generateRawTransaction(account.address(), payload, {maxGasAmount: BigInt(max_gas)});
+    // Signed BCS representation
+    const bcsTxn = AptosClient.generateBCSTransaction(account, rawTxn);
+    console.log("Submitting...");
+    const txnResult = await client.submitSignedBCSTransaction(bcsTxn);
+    console.log("Submitted");
+    await client.waitForTransaction(txnResult.hash);
+    console.log("Confirmed");
+    const txDetails = (await client.getTransactionByHash(txnResult.hash)) as Types.UserTransaction;
+    console.log(txDetails);
+    return txDetails;
+  }
+  // send JSON transaction
+  else {
+    console.log("Building tx...");
+    const pld = payload as TransactionPayload_EntryFunctionPayload;
+    // RawTransaction
+    const txn = await client.generateTransaction(account.address(), pld, {max_gas_amount: max_gas.toString()});
+    // Signed json representation
+    console.log("Signing tx...");
+    const signedTxn = await client.signTransaction(account, txn);
+    console.log("Submitting...");
+    const txnResult = await client.submitTransaction(signedTxn);
+    console.log("Submitted");
+    await client.waitForTransaction(txnResult.hash);
+    console.log("Confirmed");
+    const txDetails = (await client.getTransactionByHash(txnResult.hash)) as Types.UserTransaction;
+    console.log(txDetails);
+    return txDetails;
+  }
+}
+
+export type SimulationKeys = {
+  pubkey: HexString;
+  address: HexString;
+}
+
+export function getSimulationKeys(account: AptosAccount): SimulationKeys {
+  return {
+    pubkey: account.pubKey(),
+    address: account.address(),
+  }
 }
 
 export async function simulatePayloadTx(
   client: AptosClient, 
-  account: AptosAccount, 
-  payload: TxnBuilderTypes.TransactionPayload, 
+  keys: SimulationKeys,
+  payload: TxnBuilderTypes.TransactionPayload | TransactionPayload_EntryFunctionPayload, 
   max_gas=1000
 ){
-  const rawTxn = await client.generateRawTransaction(account.address(), payload, {maxGasAmount: BigInt(max_gas)});
-  const bcsTxn = AptosClient.generateBCSSimulation(account, rawTxn);
-  const outputs = await client.submitBCSSimulation(bcsTxn);
-  return outputs[0];
+  if (payload instanceof TxnBuilderTypes.TransactionPayload) {
+    const rawTxn = await client.generateRawTransaction(keys.address, payload, {maxGasAmount: BigInt(max_gas)});
+    const bcsTxn = generateBCSSimulation(keys.pubkey, rawTxn);
+    const outputs = await client.submitBCSSimulation(bcsTxn);
+    return outputs[0];
+  }
+  else {
+    const pld = payload as TransactionPayload_EntryFunctionPayload;
+    const txn = await client.generateTransaction(keys.address, pld, {max_gas_amount: max_gas.toString()});
+    const transactionSignature: TransactionSignature = {
+      type: "ed25519_signature",
+      public_key: keys.pubkey.hex(),
+      // use invalid signature for simulation
+      signature: HexString.fromUint8Array(new Uint8Array(64)).hex(),
+    };
+
+    const request = { ...txn, signature: transactionSignature };
+    const outputs = await client.client.transactions.simulateTransaction(request);
+    return outputs[0];
+  }
+}
+
+export function generateBCSSimulation(pubkey: HexString, rawTxn: TxnBuilderTypes.RawTransaction): Uint8Array {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const txnBuilder = new TransactionBuilderEd25519((_signingMessage: TxnBuilderTypes.SigningMessage) => {
+    // @ts-ignore
+    const invalidSigBytes = new Uint8Array(64);
+    return new TxnBuilderTypes.Ed25519Signature(invalidSigBytes);
+  }, pubkey.toUint8Array());
+
+  return txnBuilder.sign(rawTxn);
 }
 
 export function takeSimulationValue<T>(tx: UserTransaction, tag: StructTag, repo: AptosParserRepo): T {
   if (!tx.success) {
+    console.log(tx);
     throw new Error("Simulation failed");
   }
   const valueData = tx.changes.filter(change => {