antelopeql 2.0.0-rc.0 → 2.0.0-rc.10

package/antelopeql.mjs

@@ -12,8 +12,8 @@ import blockchain_query_field from "./blockchain_query_field.mjs";
 import build_graphql_fields_from_abis from "./build_graphql_fields_from_abis.mjs";
 import get_abis from "./get_abis.mjs";
 import actions from "./graphql_input_types/actions.mjs";
-import push_serialized_transaction from "./push_serialized_transaction.mjs";
-import push_transaction from "./push_transaction.mjs";
+import send_serialized_transaction from "./send_serialized_transaction.mjs";
+import send_transaction from "./send_transaction.mjs";
 import serialize_transaction from "./serialize_transaction.mjs";
 
 /**
@@ -22,7 +22,6 @@ import serialize_transaction from "./serialize_transaction.mjs";
  * @property {String} rpc_url Chain remote proceedure call (RPC) Uniform Resource Locator (URL).
  * @property {*} [variableValues] GraphQL variables.
  * @property {String} [operationName] GraphQL operation name (query resolution).
- * @property {Function} [fetch] Custom fetch implementation.
  * @property {Array<String>} [contracts] List of Antelope smart contracts.
  * @property {async Function} [signTransaction] A function to sign the Antelope transaction.
  * @property {Headers} [headers] Headers to pass to the network request.
@@ -39,30 +38,12 @@ import serialize_transaction from "./serialize_transaction.mjs";
  * AntelopeQL for interacting with Antelope based blockchains.
  * @param {AntelopeQLArgument} Argument
  * @returns {AntelopeQLResult}
- * @example
- * ```js
- * import AntelopeQL from 'antelopeql/antelopeql.mjs'
- * import fetch from 'node-fetch'
- *
- * const query = `{ eosio_token { accounts(arg: { scope: "relockeblock" }){ balance } } }`
- *
- * AntelopeQL({
- *  query,
- *  contracts: ["eosio.token"],
- *  fetch,
- *  rpc_url: "https://eos.relocke.io",
- *  headers: { "content-type": "application/json" }
- * }).then(console.log);
- * ```
- * > Logged output was "data": {"eosio_token": {"accounts": [{"balance": "100.0211 EOS"}]}}}
  */
-
 export default async function AntelopeQL({
   query,
   variableValues,
   operationName,
   signTransaction,
-  fetch,
   contracts = [],
   ABIs = [],
   rpc_url,
@@ -70,9 +51,7 @@ export default async function AntelopeQL({
   signal
 }) {
   try {
-    if (!fetch && !(typeof window == "undefined")) fetch = window.fetch;
-    if (!fetch && typeof window == "undefined")
-      throw new GraphQLError("No fetch implementation provided");
+    if (!fetch) throw new GraphQLError("No fetch implementation provided");
 
     const fetchOptions = {};
     if (headers) fetchOptions.headers = headers;
@@ -96,19 +75,17 @@ export default async function AntelopeQL({
       const action_fields = actions(mutation_fields);
       mutations = new GraphQLObjectType({
         name: "Mutation",
-        description: "Push transactions to the blockchain.",
         fields: {
-          push_transaction: push_transaction(action_fields, ast_list),
+          send_transaction: send_transaction(action_fields, ast_list),
           serialize_transaction: serialize_transaction(action_fields, ast_list),
-          push_serialized_transaction
+          send_serialized_transaction
         }
       });
     } else
       mutations = new GraphQLObjectType({
         name: "Mutation",
-        description: "Push transactions to the blockchain.",
         fields: {
-          push_serialized_transaction
+          send_serialized_transaction
         }
       });
 

package/blockchain/get_currency_balance.mjs

@@ -23,8 +23,7 @@ const currency_balance = {
     },
     symbol: {
       description: "The crytpo currency token symbol.",
-      type: new GraphQLNonNull(symbol_code_type),
-      defaultValue: "EOS"
+      type: new GraphQLNonNull(symbol_code_type)
     }
   },
   async resolve(_, args, { network: { fetch, rpc_url, ...fetchOptions } }) {

package/blockchain/get_ram_price.mjs

@@ -5,7 +5,7 @@ const RAM_quote_type = new GraphQLObjectType({
   fields: () => ({
     quote: {
       type: GraphQLString,
-      resolve: (EOS) => EOS
+      resolve: (SYS) => SYS
     }
   })
 });

package/blockchain/get_required_keys.mjs

@@ -1,11 +1,84 @@
-// const { required_keys, ...errors } = await fetch(
-//   `${rpc_url}/v1/chain/get_required_keys`,
-//   {
-//     method: "POST",
-//     ...fetchOptions,
-//     body: JSON.stringify({
-//       available_keys,
-//       transaction
-//     })
-//   }
-// ).then((res) => res.json());
+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";
+import public_key_type from "../eosio_types/public_key_type.mjs";
+import authorization_type from "../graphql_input_types/authorization.mjs";
+
+const action_type = new GraphQLInputObjectType({
+  name: "required_keys_action",
+  fields: {
+    account: {
+      type: name_type,
+      description: "The smart contract name"
+    },
+    name: { type: name_type },
+    authorization: { type: new GraphQLList(authorization_type) },
+    data: { type: GraphQLString },
+    hex_data: { type: bytes_type }
+  }
+});
+
+const transaction_type = new GraphQLInputObjectType({
+  name: "required_keys_transaction",
+  fields: {
+    expiration: { type: GraphQLString },
+    ref_block_num: { type: GraphQLString },
+    ref_block_prefix: { type: GraphQLString },
+    max_net_usage_words: { type: GraphQLString },
+    max_cpu_usage_ms: { type: GraphQLString },
+    actions: { type: new GraphQLList(action_type) },
+    context_free_actions: { type: GraphQLString }
+  }
+});
+
+const get_required_keys = {
+  description: "Retrieve a table from the blockchain.",
+  type: new GraphQLList(public_key_type),
+  args: {
+    transaction: {
+      type: transaction_type
+    },
+    available_keys: {
+      type: new GraphQLList(public_key_type)
+    }
+  },
+  async resolve(
+    _,
+    { available_keys, transaction },
+    { network: { fetch, rpc_url } }
+  ) {
+    const uri = `${rpc_url}/v1/chain/get_required_keys`;
+
+    const { actions, ...txn } = transaction;
+
+    const data = await fetch(uri, {
+      method: "POST",
+      body: JSON.stringify({
+        available_keys: await Promise.all(available_keys),
+        transaction: {
+          ...txn,
+          actions: actions.map(({ data, ...object }) => ({
+            ...object,
+            ...(data ? { data: JSON.parse(data) } : {})
+          }))
+        }
+      })
+    });
+
+    const { required_keys, ...error } = await data.json();
+    if (error.error)
+      throw new GraphQLError(error.message, {
+        extensions: error.error
+      });
+
+    return required_keys;
+  }
+};
+
+export default get_required_keys;

package/blockchain/get_smart_contract.mjs

@@ -0,0 +1,53 @@
+import {
+  GraphQLError,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLString
+} from "graphql";
+
+import name_type from "../eosio_types/name_type.mjs";
+
+const smart_contract_type = new GraphQLObjectType({
+  name: "smart_contract_type",
+  fields: () => ({
+    wasm: {
+      type: GraphQLString,
+      description: "base64 encoded contract WASM"
+    },
+    abi: {
+      description: "base64 encoded contract ABI",
+      type: GraphQLString
+    }
+  })
+});
+
+const get_smart_contract = {
+  description: "Retrieve a smart contract from the blockchain.",
+  type: smart_contract_type,
+  args: {
+    account_name: {
+      description: "The account holding the `smart contract`.",
+      type: new GraphQLNonNull(name_type)
+    }
+  },
+  async resolve(
+    _,
+    { account_name },
+    { network: { fetch, rpc_url, ...fetchOptions } }
+  ) {
+    const uri = `${rpc_url}/v1/chain/get_raw_code_and_abi`;
+    const data = await fetch(uri, {
+      method: "POST",
+      ...fetchOptions,
+      body: JSON.stringify({
+        account_name,
+        code_as_wasm: 1
+      })
+    }).then((req) => req.json());
+
+    if (data.error) throw new GraphQLError(data.message, { extensions: data });
+    return data;
+  }
+};
+
+export default get_smart_contract;

package/blockchain_query_field.mjs

@@ -10,6 +10,8 @@ import get_currency_stats from "./blockchain/get_currency_stats.mjs";
 import get_info from "./blockchain/get_info.mjs";
 import get_producers from "./blockchain/get_producers.mjs";
 import get_ram_price from "./blockchain/get_ram_price.mjs";
+import get_required_keys from "./blockchain/get_required_keys.mjs";
+import get_smart_contract from "./blockchain/get_smart_contract.mjs";
 import get_table from "./blockchain/get_table_by_scope.mjs";
 
 const blockchain_query_field = {
@@ -23,20 +25,19 @@ const blockchain_query_field = {
       get_block,
       get_currency_balance,
       get_currency_stats,
+      get_required_keys,
+      get_smart_contract,
       get_info,
       get_producers,
-      deserialize_action_data,
       get_table,
-      get_ram_price
+      get_ram_price,
+      deserialize_action_data
     }
   }),
-  resolve(_, __, { network: { fetch, rpc_url } }) {
-    if (!fetch)
-      throw new GraphQLError(
-        "Fetch was not supplied to the `antelopeql_context`."
-      );
+  resolve(_, __, { network: { rpc_url } }) {
     if (!rpc_url)
       throw new GraphQLError("No RPC url supplied to `antelopeql_context`");
+
     return {};
   }
 };

package/build_graphql_fields_from_abis.mjs

@@ -26,7 +26,7 @@ import {
  * ```js
  * import actions_type from 'antelopeql/graphql_input_types/actions.js'
  * import serialize_transaction from 'antelopeql/graphql_input_types/actions.js'
- * import push_transaction from 'antelopeql/push_transaction.js'
+ * import send_transaction from 'antelopeql/send_transaction.js'
  *
  * const network = { fetch, rpc_url: 'https://eos.relocke.io', headers: {}, signal }
  * const ABI_list = [{ account_name: 'eosio.token', abi: … }]
@@ -45,9 +45,9 @@ import {
  * const mutations = new GraphQLObjectType({
  *   name: 'Mutation',
  *   fields: {
- *     push_transaction: push_transaction(action_fields, ast_list),
+ *     send_transaction: send_transaction(action_fields, ast_list),
  *     serialize_transaction: serialize_transaction(action_fields, ast_list),
- *     push_serialized_transaction
+ *     send_serialized_transaction
  *   }
  * })
  *

package/eosio_abi_to_graphql_ast.mjs

@@ -69,15 +69,17 @@ export function eosio_abi_to_graphql_ast(abi) {
   const { types, variants } = abi;
 
   let structs = [
-    ...variants.map(({ name, types }) => ({
-      name,
-      base: "",
-      fields: types.map((item) => ({ name: item, type: item + "$@" })) // @ indiacted a variant type and binary extention.
-    })),
+    ...(variants?.length
+      ? variants.map(({ name, types }) => ({
+          name,
+          base: "",
+          fields: types.map((item) => ({ name: item, type: item + "$@" })) // @ indiacted a variant type and binary extention.
+        }))
+      : []),
     ...abi.structs
   ];
 
-  if (types.length)
+  if (types?.length)
     for (const { type: real_type, new_type_name } of types)
       structs = structs.map(({ fields, ...struct }) => ({
         ...struct,

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/eosio_types/signature_type.mjs

@@ -3,15 +3,13 @@ import { GraphQLScalarType } from "graphql";
 const signature_type = new GraphQLScalarType({
   description: `\`Signature type\`
 
-  EOS K1 signature supported.`,
+  Antelope based signature, K1, R1 WA.`,
   name: "signature",
   parseValue(signature) {
     if (signature == "") return "";
     if (typeof signature !== "string")
       throw new TypeError("Expected signature to be string");
 
-    if (signature.slice(0, 7) != "SIG_K1_")
-      throw new TypeError("Signature prefix is should be SIG_K1_.");
     return signature;
   }
 });

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,4 +1,77 @@
-import { GraphQLObjectType, GraphQLString } 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.
@@ -8,25 +81,12 @@ import { GraphQLObjectType, GraphQLString } from "graphql";
  * @prop {String} chain_id Hash representing the blockchain.
  * @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: GraphQLString,
-      description: "A unique ID that Specifies which chain we are operating on."
-    },
-    transaction_header: {
-      type: GraphQLString,
-      description: "Serialized transaction header _(TaPoS protection)_."
-    },
-    transaction_body: {
-      type: GraphQLString,
-      description: "Serialized transaction body _(bytecode instructions)_."
-    }
-  }
+  fields: packed_transaction_fields
 });
 
 export default packed_transaction_type;

package/mutation_resolver.mjs

@@ -2,12 +2,11 @@ import serialize from "eosio-wasm-js/serialize.mjs";
 import serialize_transaction_header from "eosio-wasm-js/transaction_header.mjs";
 import { GraphQLError } from "graphql";
 
-const defeaul_config = {
+const default_config = {
   blocksBehind: 3,
   expireSeconds: 30,
   max_net_usage_words: 0,
-  max_cpu_usage_ms: 0,
-  delay_sec: 0
+  max_cpu_usage_ms: 0
 };
 
 const validate_actions = () => {
@@ -48,8 +47,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 {
@@ -164,7 +162,7 @@ async function get_transaction_body(actions, ast_list) {
  * @returns {Object} Transaction object.
  */
 async function mutation_resolver(
-  { actions, configuration = defeaul_config },
+  { actions, configuration = default_config },
   network,
   ast_list
 ) {
@@ -213,10 +211,10 @@ async function mutation_resolver(
     ref_block_prefix,
     max_net_usage_words: configuration.max_net_usage_words,
     max_cpu_usage_ms: configuration.max_cpu_usage_ms,
-    delay_sec: configuration.delay_sec
+    delay_sec: 0
   };
 
-  // Generates a transaction header for a EOS transaction.
+  // Generates a transaction header for a Antelope transaction.
   const transaction_header = serialize_transaction_header(txn_header);
   txn_header.expiration = timestamp;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antelopeql",
-  "version": "2.0.0-rc.0",
+  "version": "2.0.0-rc.10",
   "description": "A GraphQL implementation for interacting with Antelope based blockchains.",
   "repository": "github:pur3miish/antelopeql",
   "bugs": "https://github.com/pur3miish/antelopeql/issues",
@@ -11,6 +11,7 @@
     "eslint": "eslint .",
     "prettier": "prettier -c .",
     "prettier:readme": "prettier --write readme.md",
+    "server": "nodemon test/server.mjs",
     "types": "tsc -p jsconfig.json",
     "snapshot": "SAVE_SNAPSHOTS=1 coverage-node test/index.test.mjs",
     "coverage": "coverage-node test/index.test.mjs",
@@ -19,26 +20,27 @@
     "prepublishOnly": "npm test"
   },
   "engines": {
-    "node": "^16.0.0 || >= 17.0.0 || >= 18.0.0"
+    "node": ">= 18.0.0"
   },
   "files": [
     "blockchain/*.mjs",
     "eosio_types/*.mjs",
     "graphql_input_types/*.mjs",
     "graphql_object_types/*.mjs",
+    "antelopeql.mjs",
     "blockchain_query_field.mjs",
     "build_graphql_fields_from_abis.mjs",
     "eosio_abi_to_graphql_ast.mjs",
     "eosio_types.mjs",
+    "get_abis.mjs",
     "mutation_resolver.mjs",
-    "push_serialized_transaction.mjs",
-    "push_transaction_rpc.mjs",
-    "push_transaction.mjs",
     "query_resolver.mjs",
+    "send_serialized_transaction.mjs",
+    "send_transaction_rpc.mjs",
+    "send_transaction.mjs",
+    "serialize_abi.mjs",
     "serialize_transaction.mjs",
-    "antelopeql.mjs",
-    "types.mjs",
-    "get_abis.mjs"
+    "types.mjs"
   ],
   "sideEffects": false,
   "exports": {
@@ -46,19 +48,20 @@
     "./eosio_types/*.mjs": "./eosio_types/*.mjs",
     "./graphql_input_types/*.mjs": "./graphql_input_types/*.mjs",
     "./graphql_object_types/*.mjs": "./graphql_object_types/*.mjs",
+    "./antelopeql.mjs": "./antelopeql.mjs",
     "./blockchain_query_field.mjs": "./blockchain_query_field.mjs",
     "./build_graphql_fields_from_abis.mjs": "./build_graphql_fields_from_abis.mjs",
     "./eosio_abi_to_graphql_ast.mjs": "./eosio_abi_to_graphql_ast.mjs",
     "./eosio_types.mjs": "./eosio_types.mjs",
+    "./get_abis.mjs": "./get_abis.mjs",
     "./mutation_resolver.mjs": "./mutation_resolver.mjs",
-    "./push_serialized_transaction.mjs": "./push_serialized_transaction.mjs",
-    "./push_transaction_rpc.mjs": "./push_transaction_rpc.mjs",
-    "./push_transaction.mjs": "./push_transaction.mjs",
     "./query_resolver.mjs": "./query_resolver.mjs",
+    "./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",
-    "./antelopeql.mjs": "./antelopeql.mjs",
-    "./types.mjs": "./types.mjs",
-    "./get_abis.mjs": "./get_abis.mjs"
+    "./types.mjs": "./types.mjs"
   },
   "browserslist": [
     "> 0.5%, not OperaMini all, not IE > 0, not dead"
@@ -76,23 +79,20 @@
   ],
   "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",
-    "graphql": "^16.6.0",
-    "node-fetch": "^3.3.0",
-    "nodemon": "^2.0.20",
+    "graphql": "^16.8.0",
+    "nodemon": "^3.0.1",
     "prettier": "^2.8.4",
     "snapshot-assertion": "^5.0.0",
     "test-director": "^10.0.0",
     "typescript": "^4.9.5"
   },
-  "peerDependencies": {
-    "graphql": "^16.6.0"
-  },
   "dependencies": {
     "base58-js": "^2.0.0",
-    "eosio-wasm-js": "^4.1.0",
+    "eosio-wasm-js": "^4.1.1",
     "ripemd160-js": "*",
     "universal-sha256-js": "^2.0.0"
   }

package/readme.md

@@ -31,42 +31,35 @@ See the examples folder on how to run AntelopeQL as a [Node.js](https://nodejs.o
 ### Query a blockchain account
 
 ```js
-import fetch from "node-fetch";
 import AntelopeQL from "antelopeql/antelopeql.mjs";
 
-const { data } = await AntelopeQL(
-  {
-    query: /*GraphQL*/ `{
-    blockchain{
-      get_account(account_name:"relockeblock") {
-        core_liquid_balance
-        ram_quota
-        net_weight
-        cpu_weight
-        ram_usage
-        permissions {
-          linked_actions {
-            account
-            action
-          }
-          required_auth {
-            keys {
-              key
-              weight
+const { data } = await AntelopeQL({
+  query: /*GraphQL*/ `{
+      blockchain{
+        get_account(account_name:"relockeblock") {
+          core_liquid_balance
+          ram_quota
+          net_weight
+          cpu_weight
+          ram_usage
+          permissions {
+            linked_actions {
+              account
+              action
+            }
+            required_auth {
+              keys {
+                key
+                weight
+              }
+              threshold
             }
-            threshold
           }
         }
       }
-    }
-  }`
-  fetch,
-  rpc_url: "https://jungle.relocke.io",
-  headers: {
-    "content-type": "application/json"
-  }
-  },
-);
+  }`,
+  rpc_url: "https://jungle.relocke.io"
+});
 
 console.log(data);
 ```
@@ -76,13 +69,13 @@ console.log(data);
 ### Transfer EOS cryptocurrency
 
 ```js
-import fetch from "node-fetch";
 import AntelopeQL from "antelopeql/antelopeql.mjs";
+import sign_txn from "antelopeql-ecc/sign_txn.mjs";
 
 const { data } = await AntelopeQL({
   query: /*GraphQL*/ `
-  mutation{
-      push_transaction(actions: [{
+    mutation {
+      send_transaction(actions: [{
         eosio_token:{
           transfer: {
             authorization:{
@@ -98,18 +91,14 @@ const { data } = await AntelopeQL({
         transaction_id
         block_num
       }
-    }`,
-  contracts: ["eosio.token"],
-  signTransaction: async () => {
-    const private_keys = [...]  // your private keys
-    const signatures = generate_signature_function(...privatekeys) // your antelope digital signature provider
-    return  signatures // signaures must return array
-  }
-  fetch,
-  rpc_url: "https://eos.relocke.io", // eos blockchain.
-  headers: {
-    "content-type": "application/json"
-  }
+  }`,
+  contracts: ["eosio.token", "eosio"], // List of smart contracts
+  signTransaction: async (hash) => {
+    const wif_private_key = "PVT_K1_…"; // your private key
+    const signature = await sign_txn({ hash, wif_private_key });
+    return [signature]; // signaures must return array
+  },
+  rpc_url: "https://eos.relocke.io" // eos blockchain url.
 });
 
 console.log(data);
@@ -134,24 +123,9 @@ console.log(data);
 
 Supported runtime environments:
 
-- [Node.js](https://nodejs.org) versions `>=16.0.0`.
+- [Node.js](https://nodejs.org) versions `>=18.0.0`.
 - Browsers matching the [Browserslist](https://browsersl.ist) query [`> 0.5%, not OperaMini all, not dead`](https://browsersl.ist/?q=%3E+0.5%25%2C+not+OperaMini+all%2C+not+dead).
-- [Deno](https://deno.land) version `>=1.30.0`.
 
 ## Exports
 
 The [npm](https://npmjs.com) package [`AntelopeQL`](https://npm.im/antelopeql) features [optimal JavaScript module design](https://jaydenseric.com/blog/optimal-javascript-module-design). It doesn’t have a main index module, so use deep imports from the ECMAScript modules that are exported via the [`package.json`](./package.json) field [`exports`](https://nodejs.org/api/packages.html#exports):
-
-- [`antelopeql.mjs`](./antelopeql.mjs)
-- [`blockchain_query_field.mjs`](blockchain_query_field.mjs)
-- [`build_graphql_fields_from_abis.mjs`](build_graphql_fields_from_abis.mjs)
-- [`eosio_abi_to_graphql_ast.mjs`](eosio_abi_to_graphql_ast.mjs)
-- [`eosio_types.mjs`](eosio_types.mjs)
-- [`mutation_resolver.mjs`](mutation_resolver.mjs)
-- [`push_serialized_transaction.mjs`](push_serialized_transaction.mjs)
-- [`push_transaction_rpc.mjs`](push_transaction_rpc.mjs)
-- [`push_transaction.mjs`](push_transaction.mjs)
-- [`query_resolver.mjs`](query_resolver.mjs)
-- [`serialize_transaction.mjs`](serialize_transaction.mjs)
-- [`antelopeql.mjs`](antelopeql.mjs)
-- [`types.mjs`](types.mjs)

package/{push_serialized_transaction.mjs → send_serialized_transaction.mjs}

@@ -3,13 +3,13 @@ import { GraphQLList, GraphQLNonNull } from "graphql";
 import bytes_type from "./eosio_types/bytes_type.mjs";
 import signature_type from "./eosio_types/signature_type.mjs";
 import transaction_receipt from "./graphql_object_types/transaction_receipt.mjs";
-import push_transaction_rpc from "./push_transaction_rpc.mjs";
+import send_transaction_rpc from "./send_transaction_rpc.mjs";
 
 /**
  * Push transaction type.
  */
-const push_serialized_transaction = {
-  description: "Pushes a serialized transaction to the blockchain.",
+const send_serialized_transaction = {
+  description: "Sends a serialized transaction to the blockchain.",
   type: new GraphQLNonNull(transaction_receipt),
   args: {
     transaction_header: { type: new GraphQLNonNull(bytes_type) },
@@ -17,8 +17,8 @@ const push_serialized_transaction = {
     signaures: { type: new GraphQLNonNull(new GraphQLList(signature_type)) }
   },
   resolve(_, args, ctx) {
-    return push_transaction_rpc(args, ctx.network);
+    return send_transaction_rpc(args, ctx.network);
   }
 };
 
-export default push_serialized_transaction;
+export default send_serialized_transaction;

package/{push_transaction.mjs → send_transaction.mjs}

@@ -4,9 +4,9 @@ import sha256 from "universal-sha256-js/sha256.mjs";
 import configuration_type from "./graphql_input_types/configuration.mjs";
 import transaction_receipt from "./graphql_object_types/transaction_receipt.mjs";
 import mutation_resolver from "./mutation_resolver.mjs";
-import push_transaction_rpc from "./push_transaction_rpc.mjs";
+import send_transaction_rpc from "./send_transaction_rpc.mjs";
 
-const push_transaction = (actions, ast_list) => ({
+const send_transaction = (actions, ast_list) => ({
   description:
     "Serialize a list of actions and push them to the blockchain in one step, requires private keys to be supplied to AntelopeQL.",
   type: new GraphQLNonNull(transaction_receipt),
@@ -22,7 +22,11 @@ const push_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(
@@ -41,11 +45,11 @@ const push_transaction = (actions, ast_list) => ({
       transaction
     });
 
-    return push_transaction_rpc(
+    return send_transaction_rpc(
       { transaction_body, transaction_header, signatures },
       network
     );
   }
 });
 
-export default push_transaction;
+export default send_transaction;

package/{push_transaction_rpc.mjs → send_transaction_rpc.mjs}

@@ -1,7 +1,7 @@
 import { GraphQLError } from "graphql";
 
 /**
- * Pushes a serialized transaction to the blockchain.
+ * Send a serialized transaction to the blockchain.
  * @param {Object} root Argument
  * @param {String} root.transaction_header Serialized transaction header.
  * @param {String} root.transaction_body Serialized transaction body.
@@ -12,15 +12,13 @@ import { GraphQLError } from "graphql";
  * @param {Object} network.headers transaction headers.
  *
  */
-export default async function push_transaction_rpc(
+export default async function send_transaction_rpc(
   { transaction_header, transaction_body, signatures },
   network
 ) {
   const { fetch, rpc_url, ...fetchOptions } = network;
 
-  console.log(transaction_body);
-
-  const pushed_txn_req = await fetch(`${rpc_url}/v1/chain/push_transaction`, {
+  const pushed_txn_req = await fetch(`${rpc_url}/v1/chain/send_transaction`, {
     method: "POST",
     ...fetchOptions,
     body: JSON.stringify({

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

@@ -1,5 +1,6 @@
-import { GraphQLNonNull } from "graphql";
+import { GraphQLList, GraphQLNonNull } from "graphql";
 
+import public_key_type from "./eosio_types/public_key_type.mjs";
 import configuration_type from "./graphql_input_types/configuration.mjs";
 import packed_transaction_type from "./graphql_object_types/packed_transaction.mjs";
 import mutation_resolver from "./mutation_resolver.mjs";
@@ -13,10 +14,19 @@ const serialize_transaction = (actions, ast_list) => ({
     },
     configuration: {
       type: configuration_type
+    },
+    available_keys: {
+      type: new GraphQLList(public_key_type)
     }
   },
-  resolve(_, args, { network }) {
-    return mutation_resolver(args, network, ast_list);
+  async resolve(_, { available_keys, ...args }, { network }) {
+    const { transaction, ...serialized_txn } = await mutation_resolver(
+      args,
+      network,
+      ast_list
+    );
+
+    return { ...serialized_txn, available_keys, transaction };
   }
 });