antelopeql 1.0.0

package/blockchain_query_field.mjs

@@ -0,0 +1,44 @@
+import { GraphQLError, GraphQLObjectType } from "graphql";
+
+import deserialize_action_data from "./blockchain/deserialize_action_data.mjs";
+import get_abi from "./blockchain/get_abi.mjs";
+import get_account from "./blockchain/get_account.mjs";
+import get_accounts_by_authorizers from "./blockchain/get_accounts_by_authorizers.mjs";
+import get_block from "./blockchain/get_block.mjs";
+import get_currency_balance from "./blockchain/get_currency_balance.mjs";
+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_table from "./blockchain/get_table_by_scope.mjs";
+
+const blockchain_query_field = {
+  description: `Retrieve infomation about the blockchain, cryptocurrency and accounts.`,
+  type: new GraphQLObjectType({
+    name: "blockchain",
+    fields: {
+      get_account,
+      get_abi,
+      get_accounts_by_authorizers,
+      get_block,
+      get_currency_balance,
+      get_currency_stats,
+      get_info,
+      get_producers,
+      deserialize_action_data,
+      get_table,
+      get_ram_price
+    }
+  }),
+  resolve(_, __, { network: { fetch, rpc_url } }) {
+    if (!fetch)
+      throw new GraphQLError(
+        "Fetch was not supplied to the `antelopeql_context`."
+      );
+    if (!rpc_url)
+      throw new GraphQLError("No RPC url supplied to `antelopeql_context`");
+    return {};
+  }
+};
+
+export default blockchain_query_field;

package/build_graphql_fields_from_abis.mjs

@@ -0,0 +1,122 @@
+import {
+  GraphQLError,
+  GraphQLInputObjectType,
+  GraphQLObjectType
+} from "graphql";
+
+import {
+  eosio_abi_to_graphql_ast,
+  get_graphql_fields_from_AST
+} from "./eosio_abi_to_graphql_ast.mjs";
+
+/** @typedef {import("./types.mjs").ABI} ABI */
+
+/**
+ * @typedef AccountABI
+ * @type {Object}
+ * @property {ABI} abi
+ * @property {String} account_name
+ */
+
+/**
+ * Builds GraphQL query and mutation fields from a list of ABIs. These GraphQL fields can readily be consumed by a GraphQL Schema, enabling developers the ability to integrate a varienty of EOSIO based blockchains into their GraphQL service.
+ * @param {Array<AccountABI>} abi_list Argument.
+ * @returns {Object} AntelopeQL fields.
+ * @example <caption>`Usage` in a custom GraphQL API.</caption>
+ * ```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'
+ *
+ * const network = { fetch, rpc_url: 'https://eos.relocke.io', headers: {}, signal }
+ * const ABI_list = [{ account_name: 'eosio.token', abi: … }]
+ * const { mutation_fields, query_fields, ast_list } =
+ *   build_graphql_fields_from_abis(ABI_list)
+ *
+ * // GraphQL query with `eosio.token` queries.
+ * const queries = new GraphQLObjectType({
+ *   name: 'Query',
+ *   fields: query_fields
+ * })
+ *
+ * const action_fields = actions_type(mutation_fields)
+ *
+ * // GraphQL mutation with `eosio.token` actions added.
+ * const mutations = new GraphQLObjectType({
+ *   name: 'Mutation',
+ *   fields: {
+ *     push_transaction: push_transaction(action_fields, ast_list),
+ *     serialize_transaction: serialize_transaction(action_fields, ast_list),
+ *     push_serialized_transaction
+ *   }
+ * })
+ *
+ * const schema = new GraphQLSchema({
+ *   query: queries,
+ *   mutation: mutations
+ * })
+ *
+ * const document = parse(new Source(query)) // GraphQL document.
+ *
+ * return execute({
+ *   schema,
+ *   document,
+ *   rootValue: '',
+ *   contextValue: { network },
+ *   fieldResolver(rootValue, args, ctx, { fieldName }) {
+ *     return rootValue[fieldName]
+ *   }
+ * })
+ * ```
+ */
+export default function build_graphql_fields_from_abis(abi_list) {
+  const contract_query_fields = {};
+  const contract_mutation_fields = {};
+  const ast_list = {};
+
+  for (const { abi, account_name } of abi_list) {
+    const name = account_name.replace(/\./gmu, "_");
+    const AST = eosio_abi_to_graphql_ast(abi);
+
+    ast_list[name] = AST; // For use in serializing data in mutation resolver.
+    const { query_fields, mutation_fields } = get_graphql_fields_from_AST(
+      AST,
+      abi,
+      name
+    );
+
+    contract_query_fields[name] = {
+      name,
+      type: new GraphQLObjectType({
+        name: name + "_query",
+        fields: query_fields
+      }),
+      resolve(__, _, { network: { rpc_url, fetch } = {} }, { fieldName }) {
+        if (!fetch)
+          throw new GraphQLError(
+            "No fetch argument found on the context of the GraphQL.execute."
+          );
+
+        if (!rpc_url)
+          throw new GraphQLError(
+            "No rpc_url argument found on the context of the GraphQL.execute."
+          );
+
+        return { code: fieldName.replace(/_/gmu, ".") };
+      }
+    };
+
+    contract_mutation_fields[name] = {
+      type: new GraphQLInputObjectType({
+        name,
+        fields: mutation_fields
+      })
+    };
+  }
+
+  return {
+    query_fields: contract_query_fields,
+    mutation_fields: contract_mutation_fields,
+    ast_list
+  };
+}

package/eosio_abi_to_graphql_ast.mjs

@@ -0,0 +1,222 @@
+import {
+  GraphQLInputObjectType,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType
+} from "graphql";
+
+import eosio_types from "./eosio_types.mjs";
+import authorization_type from "./graphql_input_types/authorization.mjs";
+import query_argument_fields from "./graphql_input_types/query_argument_fields.mjs";
+import resolve from "./query_resolver.mjs";
+
+/**
+ * Recursively resolves all the base fields and collects them into a single array.
+ * @param {String} base Base struct field name.
+ * @param {Array<Object>} structs List of ABI structs.
+ * @returns {Array<Object>} List of base fields.
+ */
+function handleBaseFields(base, structs) {
+  const base_struct = structs.find(({ name }) => name == base);
+  const { fields, base: nested_base } = base_struct;
+  return [
+    ...(nested_base ? handleBaseFields(nested_base, structs) : []),
+    ...fields
+  ];
+}
+
+/**
+ * Performs some transformations on the ABI structs to make it malleable to the GraphQL spec.
+ * ABI structs are converted onto GraphQL Types.
+ * @param {Object} structs ABI structs
+ * @returns {Object} Struct AST that will be consumed by [eosio_abi_to_graphql_ast](./eosio_abi_to_graphql_ast.mjs).
+ */
+function handleStructs(structs) {
+  let graphql_ast_structs = {};
+
+  for (const struct of structs) {
+    const { name, base, fields } = struct;
+    const fields_with_base_fields = base
+      ? [...handleBaseFields(base, structs), ...fields]
+      : fields;
+    let i = 0;
+    let ast_fields = new Array(fields_with_base_fields.length);
+    for (const field of fields_with_base_fields) {
+      const optional = !!field.type.match(/[$?]/gmu);
+      const binary_ex = !!field.type.match(/\$/gmu);
+      const variant = !!field.type.match(/@/gmu);
+      const list = !!field.type.match(/\[\]/gmu);
+      let type = field.type.replace(/[[\]?$@]/gmu, "");
+      const object = !eosio_types[type];
+      ast_fields[i] = {
+        name: field.name,
+        type,
+        $info: { object, optional, list, binary_ex, variant }
+      };
+      i++;
+    }
+    graphql_ast_structs[name] = ast_fields;
+  }
+  return graphql_ast_structs;
+}
+
+/**
+ * Generate an Abstract syntax tree (AST) for an EOSIO application Binary interface (ABI).
+ * @param {ABI} abi EOSIO smart contract Application Binary interface (ABI).
+ * @returns {Object} a GraphQL AST for a given smart contract.
+ */
+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.
+    })),
+    ...abi.structs
+  ];
+
+  if (types.length)
+    for (const { type: real_type, new_type_name } of types)
+      structs = structs.map(({ fields, ...struct }) => ({
+        ...struct,
+        fields: fields.map(({ name, type }) =>
+          type.match(new RegExp(`^${new_type_name}[?$]?([])?$`, "gmu"))
+            ? { name, type: type.replace(new_type_name, real_type) }
+            : { name, type }
+        )
+      }));
+
+  const structs_ast = handleStructs(structs);
+
+  return Object.freeze(structs_ast);
+}
+
+/**
+ * Wraps a GraphQL type in a GraphQLNonNullType and GraphQLListType.
+ * @param {Object} type GraphQL type to wrap.
+ * @param {Object} Arg Argument
+ * @param {Boolean} Arg.optional Wraps GraphQL type optional type.
+ * @param {Boolean} Arg.list Wraps GraphQL type in list type.
+ * @returns {Object} wrapped GraphQL type.
+ */
+function Wrap(type, { optional, list }) {
+  let gql_type = type;
+  if (list) gql_type = new GraphQLList(gql_type);
+  if (!optional) gql_type = new GraphQLNonNull(gql_type);
+  return gql_type;
+}
+
+/**
+ * Generates GraphQL query and mutation fields from an ABI AST.
+ * @param {Object} AST Abstract syntax tree generated by `eosio_abi_to_graphql_ast` function.
+ * @param {Object} ABI EOSIO application binary interface (ABI).
+ * @param {String} [account_name] Blockchain account name.
+ * @returns {Object} GraphQL query and mutation fields.
+ */
+export function get_graphql_fields_from_AST(AST, ABI, account_name = "") {
+  const { tables, actions } = ABI;
+  const gql_account_name = account_name.replace(/\./gmu, "_") + "_";
+
+  let query_fields = {};
+  const queryTypes = {};
+  const GQL_TYPES = {};
+
+  for (const table of tables) {
+    let { name: table_name, type: table_type } = table;
+    table_name = table_name.replace(/\./gmu, "_");
+    const table_fields = AST[table_type];
+
+    const buildQGL = (fields, acc = {}) => {
+      for (const field of fields) {
+        const { name, type, $info } = field;
+
+        // Do this because of variant type from table.
+        const resolve = (data, args, context, { fieldName }) => {
+          if ($info.variant) return type == data[0] ? data[1] : null;
+          return data[fieldName];
+        };
+
+        if ($info.object) {
+          if (!GQL_TYPES[type])
+            GQL_TYPES[type] = new GraphQLObjectType({
+              name: gql_account_name + type,
+              fields: buildQGL(AST[type])
+            });
+
+          acc = {
+            ...acc,
+            [name]: { type: Wrap(GQL_TYPES[type], $info), resolve }
+          };
+        } else
+          acc = {
+            ...acc,
+            [name]: { type: Wrap(eosio_types[type], $info), resolve }
+          };
+      }
+      return acc;
+    };
+
+    if (!queryTypes[table_type])
+      queryTypes[table_type] = {
+        type: new GraphQLList(
+          new GraphQLObjectType({
+            name: gql_account_name + table_type + "_query",
+            fields: buildQGL(table_fields)
+          })
+        ),
+        args: {
+          arg: {
+            name: "argument_type",
+            type: query_argument_fields
+          }
+        },
+        resolve
+      };
+
+    query_fields[table_name] = queryTypes[table_type];
+  }
+
+  const GQL_MTYPES = {};
+  let mutation_fields = {};
+  const mutationTypes = {};
+  for (const action of actions) {
+    let { name: action_name, type: action_type } = action;
+    action_name = action_name.replace(/\./gmu, "_");
+    const action_fields = AST[action_type];
+
+    const buildQGL = (fields, acc = {}) => {
+      for (const field of fields) {
+        const { name, type, $info } = field;
+        if ($info.object) {
+          if (!GQL_MTYPES[type])
+            GQL_MTYPES[type] = new GraphQLInputObjectType({
+              name: gql_account_name + "input_" + type,
+              fields: buildQGL(AST[type])
+            });
+          acc = { ...acc, [name]: { type: Wrap(GQL_MTYPES[type], $info) } };
+        } else
+          acc = { ...acc, [name]: { type: Wrap(eosio_types[type], $info) } };
+      }
+      return acc;
+    };
+
+    if (!mutationTypes[action_type])
+      mutationTypes[action_type] = {
+        type: new GraphQLInputObjectType({
+          name: gql_account_name + action_type,
+          fields: {
+            ...buildQGL(action_fields),
+            authorization: {
+              type: new GraphQLList(new GraphQLNonNull(authorization_type))
+            }
+          }
+        })
+      };
+
+    mutation_fields[action_name] = mutationTypes[action_type];
+  }
+
+  return { query_fields, mutation_fields };
+}

package/eosio_types/asset_type.mjs

@@ -0,0 +1,35 @@
+import { GraphQLScalarType } from "graphql";
+
+const asset_type = new GraphQLScalarType({
+  description: `
+\`Asset type\`
+
+---
+
+An \`asset\` type describes a blockchain asset and includes a quantity and a symbol section.
+
+
+- The quantity must include decimal precision (with a maximum precision of 18)
+- Symbol must be an uppercase string of 7 or less characters from [A-Z]
+
+***example*** - \`1.0010 EOS\`
+
+- Quantity is 1.0010
+- Symbol is EOS
+
+`,
+  name: "asset",
+  parseValue(asset_string) {
+    if (asset_string == "") return "";
+
+    if (!asset_string.match(/^\d+(\.\d+)?\s[A-Z]{1,7}$/gmu))
+      throw new TypeError("Invalid asset type supplied.");
+
+    if (asset_string.replace(/[A-Z.\s]/gmu, "").length > 21)
+      throw new RangeError("Invalid asset size, maximum (2 ^ 62) - 1");
+
+    return asset_string;
+  }
+});
+
+export default asset_type;

package/eosio_types/block_timestamp_type.mjs

@@ -0,0 +1,14 @@
+import { GraphQLScalarType } from "graphql";
+
+const block_timestamp_type = new GraphQLScalarType({
+  description: "`Block timestamp type`",
+  name: "block_timestamp_type",
+  parseValue(block_time_stamp) {
+    if (block_time_stamp == "") return "";
+    if (Number.isNaN(Date.parse(block_time_stamp)))
+      throw new TypeError("Invalid block timestamp " + block_time_stamp);
+    return block_time_stamp;
+  }
+});
+
+export default block_timestamp_type;

package/eosio_types/boolean_type.mjs

@@ -0,0 +1,10 @@
+import { GraphQLScalarType } from "graphql";
+
+const boolean_type = new GraphQLScalarType({
+  description: "`Boolean type` true=1 or false=0",
+  name: "bool",
+  parseValue: (boolean) => boolean,
+  serialize: (boolean) => (boolean ? true : false)
+});
+
+export default boolean_type;

package/eosio_types/bytes_type.mjs

@@ -0,0 +1,17 @@
+import { GraphQLScalarType } from "graphql";
+
+const bytes_type = new GraphQLScalarType({
+  description: "Hexedecimal text string type.",
+  name: "bytes",
+  parseValue(bytes) {
+    if (bytes == "") return bytes;
+    if (!bytes.match(/^[A-Fa-f0-9]+$/gmu))
+      throw new TypeError("Invald hexadecimal string: " + bytes);
+    if (bytes.length % 2 != 0)
+      throw new TypeError("Invalid Hexadecimal string length");
+
+    return bytes;
+  }
+});
+
+export default bytes_type;

package/eosio_types/eosio_key_type.mjs

@@ -0,0 +1,13 @@
+import { GraphQLInt, GraphQLObjectType } from "graphql";
+
+import public_key_type from "./public_key_type.mjs";
+
+const EOSIO_key_type = new GraphQLObjectType({
+  name: "key_type",
+  fields: () => ({
+    key: { type: public_key_type },
+    weight: { type: GraphQLInt }
+  })
+});
+
+export default EOSIO_key_type;

package/eosio_types/extended_asset_type.mjs

@@ -0,0 +1,19 @@
+import { GraphQLScalarType } from "graphql";
+
+const extended_asset_type = new GraphQLScalarType({
+  description: `\`Extended_asset\`
+
+Extended asset which stores the information of the owner of the asset.
+
+### extended asset
+- Start with asset type followed by “@” and the account name.
+
+example:
+
+1.0000 EOS@eosio.token
+  `,
+  name: "extended_asset",
+  parseValue: (extended_asset) => extended_asset
+});
+
+export default extended_asset_type;

package/eosio_types/generate_checksum_type.mjs

@@ -0,0 +1,20 @@
+import { GraphQLScalarType } from "graphql";
+
+/**
+ * Generates a GraphQL scalar type for checksum of `size`.
+ * @name generate_int_type
+ * @param {number} size Size of the checksum.
+ * @returns {GraphQLScalarType} GraphQL scalar type.
+ */
+function generate_checksum(size) {
+  return new GraphQLScalarType({
+    description: `\`Checksum${8 * size} type\`
+
+Represented as a hexadecimal string of ${2 * size} characters.
+`,
+    name: `checksum${size * 8}`,
+    parseValue: (checksum) => checksum
+  });
+}
+
+export default generate_checksum;

package/eosio_types/generate_float_type.mjs

@@ -0,0 +1,16 @@
+import { GraphQLScalarType } from "graphql";
+
+/**
+ * Generates a GraphQL scalar Float type of `size`.
+ * @param {number} size Size of the float can be 32, 64 or 128.
+ * @returns {GraphQLScalarType} GraphQL scalar float type.
+ */
+function generate_float_type(size) {
+  return new GraphQLScalarType({
+    description: `\`Float${size} type\``,
+    name: `float${size}`,
+    parseValue: (float) => float
+  });
+}
+
+export default generate_float_type;

package/eosio_types/generate_int_type.mjs

@@ -0,0 +1,28 @@
+import { GraphQLScalarType } from "graphql";
+
+/**
+ * Generates a GraphQL scalar signed integer type of size `bytes`.
+ * @name generate_int_type
+ * @param {number} bits Size of the integer.
+ * @returns {GraphQLScalarType} GraphQL scalar integer type.
+ */
+function generate_int_type(bits) {
+  bits = BigInt(bits);
+  const max = 2n ** (bits - 1n) - 1n;
+  const min = 2n ** (bits - 1n) * -1n;
+  return new GraphQLScalarType({
+    description: `\`Integer t${bits} type\`
+
+Signed integer range is between ${min} - ${max}`,
+    name: `int${bits.toString()}`,
+    parseValue(int) {
+      if (int == "") return "";
+      int = BigInt(int);
+      if (int > max || int < min)
+        throw new RangeError(`Integer range is outside uint${bits}.`);
+      return int.toString();
+    }
+  });
+}
+
+export default generate_int_type;

package/eosio_types/generate_uint_type.mjs

@@ -0,0 +1,27 @@
+import { GraphQLScalarType } from "graphql";
+/**
+ * Generates a GraphQL scalar unsigend integer type of size `bits`.
+ * @param {Number} bits Size of the unint.
+ * @returns {GraphQLScalarType} GraphQL scalar integer type.
+ */
+function generate_uint_type(bits) {
+  const size = 2n ** BigInt(bits);
+  return new GraphQLScalarType({
+    description: `\`Unsigned integer${bits.toString()} type\`
+
+Unsigned integer range is between 0 - ${size.toString()}`,
+    name: `uint${bits}`,
+    parseValue(uint) {
+      if (uint === "") return "";
+
+      uint = BigInt(uint);
+      if (uint >= size || uint < 0n)
+        throw new RangeError(
+          `Integer range is outside uint${bits.toString()}.`
+        );
+      return uint.toString();
+    }
+  });
+}
+
+export default generate_uint_type;

package/eosio_types/name_type.mjs

@@ -0,0 +1,29 @@
+import { GraphQLScalarType } from "graphql";
+
+const name_type = new GraphQLScalarType({
+  description: `\`Name type\`
+
+Names are unique identifiers on the blockchain.
+
+---
+
+  ### name rules
+
+  - Combination of lowercase characters
+  - Can include numbers 1 - 5 and period “.” character
+  - Must NOT end with a period “.”
+  - Must NOT be longer than 12 characters
+
+  `,
+  name: "name",
+  parseValue(_name) {
+    if (_name == "") return _name;
+
+    if (!_name.match(/^[1-5a-z]{1}[1-5a-z.]{0,10}[1-5a-z]{1}$/gmu))
+      throw new TypeError(`Invalid name “${_name}”.`);
+
+    return _name;
+  }
+});
+
+export default name_type;

package/eosio_types/public_key_type.mjs

@@ -0,0 +1,26 @@
+import legacy_to_public_key from "eosio-ecc/legacy_to_public_key.mjs";
+import validate_public_key from "eosio-ecc/validate_public_key.mjs";
+import { GraphQLScalarType } from "graphql";
+
+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 serialize(legacy_key) {
+    if (!legacy_key.startsWith("EOS")) return legacy_key;
+
+    return legacy_to_public_key(legacy_key);
+  },
+  async parseValue(public_key) {
+    if (public_key == "") return "";
+
+    const { valid, message } = await validate_public_key(public_key);
+    if (!valid) throw new RangeError(message);
+    return public_key;
+  }
+});
+
+export default public_key_type;

package/eosio_types/signature_type.mjs

@@ -0,0 +1,19 @@
+import { GraphQLScalarType } from "graphql";
+
+const signature_type = new GraphQLScalarType({
+  description: `\`Signature type\`
+
+  EOS K1 signature supported.`,
+  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;
+  }
+});
+
+export default signature_type;

package/eosio_types/symbol_code_type.mjs

@@ -0,0 +1,13 @@
+import { GraphQLScalarType } from "graphql";
+
+const symbol_code_type = new GraphQLScalarType({
+  description: `\`Symbol code type\``,
+  name: "symbol_code",
+  parseValue: (symbol_code) => {
+    if (!symbol_code.match(/[A-Z]{1,7}/gmu))
+      throw new Error("Invalid symbol code.");
+    return symbol_code;
+  }
+});
+
+export default symbol_code_type;