antelopeql 2.0.0-rc.6 → 2.0.0-rc.9

package/blockchain/get_required_keys.mjs

@@ -1,4 +1,9 @@
-import { GraphQLInputObjectType, GraphQLList, GraphQLString } from "graphql";
+import {
+  GraphQLError,
+  GraphQLInputObjectType,
+  GraphQLList,
+  GraphQLString
+} from "graphql";
 
 import bytes_type from "../eosio_types/bytes_type.mjs";
 import name_type from "../eosio_types/name_type.mjs";
@@ -66,7 +71,11 @@ const get_required_keys = {
       })
     });
 
-    const { required_keys } = await data.json();
+    const { required_keys, ...error } = await data.json();
+    if (error.error)
+      throw new GraphQLError(error.message, {
+        extensions: error.error
+      });
 
     return required_keys;
   }

package/eosio_types/public_key_type.mjs

@@ -1,11 +1,9 @@
+import base58_to_binary from "base58-js/base58_to_binary.mjs";
+import binary_to_base58 from "base58-js/binary_to_base58.mjs";
 import { GraphQLScalarType } from "graphql";
+import ripemd160 from "ripemd160-js/ripemd160.mjs";
 
 const public_key_type = new GraphQLScalarType({
-  description: `\`Public key type\`
-  ---
-
-  Public keys should begin with PUB_K1 (or EOS for legacy keys) and include base58 characters only.
-  `,
   name: "public_key",
   async parseValue(public_key) {
     if (public_key == "") return "";
@@ -21,6 +19,22 @@ const public_key_type = new GraphQLScalarType({
       );
 
     return public_key;
+  },
+  async serialize(key) {
+    if (key.startsWith("EOS")) {
+      const public_key = base58_to_binary(key.replace(/^[A-Z]+/gmu, "")).slice(
+        0,
+        -4
+      );
+
+      const hash = await ripemd160(Uint8Array.from([...public_key, 75, 49]));
+      const checksum = hash.slice(0, 4);
+      return (
+        "PUB_K1_" +
+        binary_to_base58(new Uint8Array([...public_key, ...checksum]))
+      );
+    }
+    return key;
   }
 });
 

package/graphql_input_types/configuration.mjs

@@ -17,7 +17,6 @@ const configuration_default_value = {
  * @param {Number} expireSeconds Seconds past before transaction is no longer valid (TaPoS protection)
  * @param {Number} max_net_usage_words Maximum NET bandwidth usage a transaction can consume (0 there is no limit).
  * @param {Number} max_cpu_usage_ms Maximum NET bandwidth usage a transaction can consume (0 there is no limit).
- * @param {Number} delay_sec Number of seconds that the transaciton will be delayed by.
  */
 const configuration_type = new GraphQLInputObjectType({
   name: "configuration_type",
@@ -43,11 +42,6 @@ const configuration_type = new GraphQLInputObjectType({
       description: `Maximum CPU bandwidth usage a transaction can consume, \nwhen set to 0 there is no limit`,
       type: GraphQLInt,
       defaultValue: configuration_default_value.max_cpu_usage_ms
-    },
-    delay_sec: {
-      type: GraphQLInt,
-      description: "Number of seconds that the transaciton will be delayed by",
-      defaultValue: configuration_default_value.delay_sec
     }
   })
 });

package/graphql_object_types/packed_transaction.mjs

@@ -1,7 +1,78 @@
-import { GraphQLList, GraphQLObjectType } from "graphql";
+import { GraphQLError, GraphQLList, GraphQLObjectType } from "graphql";
+import sha256 from "universal-sha256-js/sha256.mjs";
 
 import bytes_type from "../eosio_types/bytes_type.mjs";
 import public_key_type from "../eosio_types/public_key_type.mjs";
+
+export const packed_transaction_fields = {
+  chain_id: {
+    type: bytes_type,
+    description: "A unique ID that specifies which chain we are operating on."
+  },
+  transaction_header: {
+    type: bytes_type,
+    description: "Serialized transaction header."
+  },
+  transaction_body: {
+    type: bytes_type,
+    description: "Serialized transaction body _(bytecode instructions)_."
+  },
+  required_keys: {
+    type: new GraphQLList(public_key_type),
+    description: "List of public keys needed to authorize transaction",
+    async resolve({ available_keys, transaction }, args, { network }) {
+      if (available_keys?.length) {
+        const keys = await Promise.all(available_keys);
+
+        const req = await fetch(
+          network.rpc_url + "/v1/chain/get_required_keys",
+          {
+            method: "post",
+            body: JSON.stringify({
+              transaction: {
+                ...transaction,
+                // Transform the transaction.actions into appropriate form for get_required_keys.
+                actions: transaction.actions.map(({ hex_data, ...action }) => ({
+                  ...action,
+                  data: hex_data
+                }))
+              },
+              available_keys: keys
+            })
+          }
+        ).then((res) => res.json());
+
+        if (req.error)
+          throw new GraphQLError(req.message, { extensions: req.error });
+        return req.required_keys;
+      }
+    }
+  },
+  hash: {
+    type: bytes_type,
+    description: "Transaction hash to sign to authorize transaction",
+    async resolve({ chain_id, transaction_header, transaction_body }) {
+      const transaction_bytes =
+        chain_id +
+        transaction_header +
+        transaction_body +
+        "0000000000000000000000000000000000000000000000000000000000000000";
+
+      const hash_to_sign = await sha256(
+        Uint8Array.from(
+          transaction_bytes
+            .match(/[a-fA-F0-9]{2}/gmu)
+            .map((i) => Number(`0x${i}`))
+        )
+      );
+
+      return [...hash_to_sign]
+        .map((x) => Number(x).toString(16).padStart(2, "0"))
+        .join("");
+    }
+  }
+};
+
 /**
  * The packed transaction type.
  * @kind typedef
@@ -11,29 +82,11 @@ import public_key_type from "../eosio_types/public_key_type.mjs";
  * @prop {String} transaction_header Hex string representing the serialized transaction header.
  * @prop {String} transaction_body Hex string representing the serialized transaction body.
  * @prop {String} transaction_body Hex string representing the serialized transaction body.
-
  */
 const packed_transaction_type = new GraphQLObjectType({
   name: "packed_transaction",
   description: "Packed transaction, chain ID and transaction header",
-  fields: {
-    chain_id: {
-      type: bytes_type,
-      description: "A unique ID that specifies which chain we are operating on."
-    },
-    transaction_header: {
-      type: bytes_type,
-      description: "Serialized transaction header."
-    },
-    transaction_body: {
-      type: bytes_type,
-      description: "Serialized transaction body _(bytecode instructions)_."
-    },
-    required_keys: {
-      type: new GraphQLList(public_key_type),
-      description: "List of public keys needed to authorize transaction"
-    }
-  }
+  fields: packed_transaction_fields
 });
 
 export default packed_transaction_type;

package/mutation_resolver.mjs

@@ -48,8 +48,7 @@ async function get_transaction_body(actions, ast_list) {
   let _actions = [];
   let _context_free_actions = [];
 
-  let transaction_extensions =
-    "000000000000000000000000000000000000000000000000000000000000000000";
+  let transaction_extensions = "00";
 
   for (const action of actions_list_to_serialize) {
     const {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antelopeql",
-  "version": "2.0.0-rc.6",
+  "version": "2.0.0-rc.9",
   "description": "A GraphQL implementation for interacting with Antelope based blockchains.",
   "repository": "github:pur3miish/antelopeql",
   "bugs": "https://github.com/pur3miish/antelopeql/issues",
@@ -38,6 +38,7 @@
     "send_serialized_transaction.mjs",
     "send_transaction_rpc.mjs",
     "send_transaction.mjs",
+    "serialize_abi.mjs",
     "serialize_transaction.mjs",
     "types.mjs"
   ],
@@ -58,6 +59,7 @@
     "./send_serialized_transaction.mjs": "./send_serialized_transaction.mjs",
     "./send_transaction_rpc.mjs": "./send_transaction_rpc.mjs",
     "./send_transaction.mjs": "./send_transaction.mjs",
+    "./serialize_abi.mjs": "./serialize_abi.mjs",
     "./serialize_transaction.mjs": "./serialize_transaction.mjs",
     "./types.mjs": "./types.mjs"
   },
@@ -77,6 +79,7 @@
   ],
   "devDependencies": {
     "@types/node": "^18.13.0",
+    "antelope-ecc": "^2.0.0-rc.7",
     "coverage-node": "^8.0.0",
     "eslint": "^8.34.0",
     "eslint-plugin-simple-import-sort": "^10.0.0",

package/send_transaction.mjs

@@ -22,7 +22,11 @@ const send_transaction = (actions, ast_list) => ({
     const { chain_id, transaction_header, transaction_body, transaction } =
       await mutation_resolver(args, network, ast_list);
 
-    const transaction_bytes = chain_id + transaction_header + transaction_body;
+    const transaction_bytes =
+      chain_id +
+      transaction_header +
+      transaction_body +
+      "0000000000000000000000000000000000000000000000000000000000000000";
 
     const hash_to_sign = await sha256(
       Uint8Array.from(

package/serialize_abi.mjs

@@ -0,0 +1,273 @@
+import serialize from "eosio-wasm-js/serialize.mjs";
+
+import { eosio_abi_to_graphql_ast } from "./eosio_abi_to_graphql_ast.mjs";
+
+const ABI = {
+  version: "eosio::abi/1.1",
+  structs: [
+    {
+      name: "extensions_entry",
+      base: "",
+      fields: [
+        {
+          name: "tag",
+          type: "uint16"
+        },
+        {
+          name: "value",
+          type: "bytes"
+        }
+      ]
+    },
+    {
+      name: "type_def",
+      base: "",
+      fields: [
+        {
+          name: "new_type_name",
+          type: "string"
+        },
+        {
+          name: "type",
+          type: "string"
+        }
+      ]
+    },
+    {
+      name: "field_def",
+      base: "",
+      fields: [
+        {
+          name: "name",
+          type: "string"
+        },
+        {
+          name: "type",
+          type: "string"
+        }
+      ]
+    },
+    {
+      name: "struct_def",
+      base: "",
+      fields: [
+        {
+          name: "name",
+          type: "string"
+        },
+        {
+          name: "base",
+          type: "string"
+        },
+        {
+          name: "fields",
+          type: "field_def[]"
+        }
+      ]
+    },
+    {
+      name: "action_def",
+      base: "",
+      fields: [
+        {
+          name: "name",
+          type: "name"
+        },
+        {
+          name: "type",
+          type: "string"
+        },
+        {
+          name: "ricardian_contract",
+          type: "string"
+        }
+      ]
+    },
+    {
+      name: "table_def",
+      base: "",
+      fields: [
+        {
+          name: "name",
+          type: "name"
+        },
+        {
+          name: "index_type",
+          type: "string"
+        },
+        {
+          name: "key_names",
+          type: "string[]"
+        },
+        {
+          name: "key_types",
+          type: "string[]"
+        },
+        {
+          name: "type",
+          type: "string"
+        }
+      ]
+    },
+    {
+      name: "clause_pair",
+      base: "",
+      fields: [
+        {
+          name: "id",
+          type: "string"
+        },
+        {
+          name: "body",
+          type: "string"
+        }
+      ]
+    },
+    {
+      name: "error_message",
+      base: "",
+      fields: [
+        {
+          name: "error_code",
+          type: "uint64"
+        },
+        {
+          name: "error_msg",
+          type: "string"
+        }
+      ]
+    },
+    {
+      name: "variant_def",
+      base: "",
+      fields: [
+        {
+          name: "name",
+          type: "string"
+        },
+        {
+          name: "types",
+          type: "string[]"
+        }
+      ]
+    },
+    {
+      name: "abi_def",
+      base: "",
+      fields: [
+        {
+          name: "version",
+          type: "string"
+        },
+        {
+          name: "types",
+          type: "type_def[]"
+        },
+        {
+          name: "structs",
+          type: "struct_def[]"
+        },
+        {
+          name: "actions",
+          type: "action_def[]"
+        },
+        {
+          name: "tables",
+          type: "table_def[]"
+        },
+        {
+          name: "ricardian_clauses",
+          type: "clause_pair[]"
+        },
+        {
+          name: "error_messages",
+          type: "error_message[]"
+        },
+        {
+          name: "abi_extensions",
+          type: "extensions_entry[]"
+        },
+        {
+          name: "variants",
+          type: "variant_def[]$"
+        }
+      ]
+    }
+  ]
+};
+
+const AST = eosio_abi_to_graphql_ast(ABI);
+
+/**
+ * Given a Smart contract convert the ABI to serialized byte code representation.
+ * @param {Object} abi JS Object of the Antelope ABI for a given smart contract.
+ * @returns {String} serialized Byte code representation of the ABI.
+ */
+export default async function serialize_abi(abi) {
+  let JSON_ABI = abi;
+
+  ABI.structs[9].fields.forEach(({ name }) => {
+    if (JSON_ABI[name] == undefined) {
+      JSON_ABI[name] = [];
+    }
+  });
+
+  const build_serialize_list = async (data, instructions) => {
+    const serialize_list = [];
+
+    for (const instruction of instructions) {
+      const { $info, name, type } = instruction;
+      const datum = data[name];
+
+      const next_instruction = AST[type];
+
+      if ($info.variant) {
+        if (Object.keys(data).length > 1)
+          throw new Error(`Must only include one type for variant.`);
+        if (!datum) continue;
+        else
+          serialize_list.push({
+            type: "varuint32",
+            value: instructions.findIndex((i) => i.type == type)
+          });
+      }
+
+      if ($info.binary_ex) $info.optional = false; // Binary extentions are optional (GraphQL types) but should not serialize an optional type.
+
+      if ($info.optional)
+        serialize_list.push({ type: "bool", value: datum != undefined }); // Add an optional item to serialize list.
+
+      if ($info.list)
+        if (datum !== undefined)
+          serialize_list.push({ type: "varuint32", value: datum.length }); // Add an length of list to serialize list.
+
+      // Indicates that we need to recursion loop through each data item.
+      if (next_instruction)
+        if ($info.list) {
+          if (datum != undefined && !$info.binary_ex)
+            for await (const d of datum)
+              serialize_list.push(
+                ...(await build_serialize_list(await d, next_instruction))
+              );
+        }
+        // None list recursion
+        else
+          serialize_list.push(
+            ...(await build_serialize_list(datum, next_instruction))
+          );
+      // Indicates that the list of data can be serilaized and so is pushed into serialize_list.
+      else if ($info.list && datum !== undefined)
+        for await (const d of datum) serialize_list.push({ type, value: d });
+      else if (datum !== undefined) serialize_list.push({ type, value: datum }); // Native eoio types than can be serialized.
+    }
+
+    return serialize_list;
+  };
+
+  const ser_list = await build_serialize_list(JSON_ABI, AST.abi_def);
+
+  let hex_string = "";
+  ser_list.forEach(({ type, value }) => (hex_string += serialize[type](value)));
+
+  return hex_string;
+}

package/serialize_transaction.mjs

@@ -26,26 +26,7 @@ const serialize_transaction = (actions, ast_list) => ({
       ast_list
     );
 
-    let required_keys;
-    if (available_keys?.length) {
-      try {
-        const { required_keys: rk } = await fetch(
-          network.rpc_url + "/v1/chain/get_required_keys",
-          {
-            method: "post",
-            body: JSON.stringify({
-              transaction,
-              available_keys: await Promise.all(available_keys)
-            })
-          }
-        ).then((res) => res.json);
-        required_keys = rk;
-      } catch (err) {
-        // gracefully catch the error
-      }
-    }
-
-    return { ...serialized_txn, required_keys };
+    return { ...serialized_txn, available_keys, transaction };
   }
 });