antelopeql 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 H
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/antelopeql.mjs

@@ -0,0 +1,159 @@
+import {
+  execute,
+  GraphQLError,
+  GraphQLObjectType,
+  GraphQLSchema,
+  parse,
+  Source,
+  validate
+} from "graphql";
+
+import blockchain_query_field from "./blockchain_query_field.mjs";
+import build_graphql_fields_from_abis from "./build_graphql_fields_from_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 serialize_transaction from "./serialize_transaction.mjs";
+
+/**
+ * @typedef {Object} AntelopeQLArgument
+ * @property {String} query  GraphQL query that will instruct AntelopeQL to perform a CRUD operation.
+ * @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 {Array<String>} [private_keys] List of private keys used to sign transactions.
+ * @property {Headers} [headers] Headers to pass to the network request.
+ * @property {AbortSignal} [signal] Abort controller signal.
+ */
+
+/**
+ * @typedef {Object} AntelopeQLResult
+ * @property {*} [data] returned data
+ * @property {Array<*>} [errors] returned errors
+ */
+
+/**
+ * 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,
+  fetch,
+  contracts = [],
+  private_keys = [],
+  rpc_url,
+  headers,
+  signal
+}) {
+  try {
+    if (!fetch && !(typeof window == "undefined")) fetch = window.fetch;
+    if (!fetch && typeof window == "undefined")
+      throw new GraphQLError("No fetch implementation provided");
+
+    const fetchOptions = {};
+    if (headers) fetchOptions.headers = headers;
+    if (signal) fetchOptions.signal = signal;
+
+    const uri = `${rpc_url}/v1/chain/get_abi`;
+
+    const abi_req = contracts.map((account_name) =>
+      fetch(uri, {
+        method: "POST",
+        ...fetchOptions,
+        body: JSON.stringify({
+          account_name,
+          json: true
+        })
+      }).then((/** @type {{ json: () => any; }} */ req) => req.json())
+    );
+
+    const ABIs = await Promise.all(abi_req);
+    for (let i = 0; i < contracts.length; i++) {
+      if (ABIs[i].error)
+        throw new GraphQLError(ABIs[i].message, { extensions: ABIs[i] });
+      if (!ABIs[i].abi)
+        throw new GraphQLError(
+          `No smart contract found for “${contracts[i]}”.`
+        );
+    }
+
+    const { mutation_fields, query_fields, ast_list } =
+      build_graphql_fields_from_abis(ABIs);
+
+    const queries = new GraphQLObjectType({
+      name: "Query",
+      description: "Query table data from EOSIO blockchain.",
+      fields: { blockchain: blockchain_query_field, ...query_fields }
+    });
+
+    let mutations;
+
+    if (Object.keys(mutation_fields).length) {
+      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),
+          serialize_transaction: serialize_transaction(action_fields, ast_list),
+          push_serialized_transaction
+        }
+      });
+    } else
+      mutations = new GraphQLObjectType({
+        name: "Mutation",
+        description: "Push transactions to the blockchain.",
+        fields: {
+          push_serialized_transaction
+        }
+      });
+
+    const schema = new GraphQLSchema({
+      query: queries,
+      mutation: mutations
+    });
+
+    const document = parse(new Source(query));
+    const queryErrors = validate(schema, document);
+    if (queryErrors.length) return { errors: queryErrors };
+
+    return execute({
+      schema,
+      document,
+      rootValue: "",
+      contextValue: {
+        network: { rpc_url, fetch, ...fetchOptions },
+        private_keys
+      },
+      variableValues,
+      operationName,
+      fieldResolver(rootValue, args, ctx, { fieldName }) {
+        return rootValue[fieldName];
+      }
+    });
+  } catch (err) {
+    return { errors: [err] };
+  }
+}

package/blockchain/deserialize_action_data.mjs

@@ -0,0 +1,41 @@
+import { GraphQLError, GraphQLNonNull, GraphQLString } from "graphql";
+
+import bytes_type from "../eosio_types/bytes_type.mjs";
+import name_type from "../eosio_types/name_type.mjs";
+
+const deserialize_action_data = {
+  description: "Returns a JSON object containing deserialized action data.",
+  type: GraphQLString,
+  args: {
+    code: {
+      description: "Account name that holds the EOSIO smart contract.",
+      type: new GraphQLNonNull(name_type)
+    },
+    action: {
+      description: "Action name on the EOSIO smart contract.",
+      type: new GraphQLNonNull(name_type)
+    },
+    binargs: {
+      description: "Serialized action data.",
+      type: new GraphQLNonNull(bytes_type)
+    }
+  },
+  async resolve(_, args, { network: { fetch, rpc_url, ...fetchOptions } }) {
+    const uri = `${rpc_url}/v1/chain/abi_bin_to_json`;
+    const req = await fetch(uri, {
+      method: "POST",
+      ...fetchOptions,
+      body: JSON.stringify({
+        ...args,
+        json: true
+      })
+    });
+
+    const data = await req.json();
+
+    if (data.error) throw new GraphQLError(data.message, { extensions: data });
+    return JSON.stringify(data.args);
+  }
+};
+
+export default deserialize_action_data;

package/blockchain/get_abi.mjs

@@ -0,0 +1,172 @@
+import {
+  GraphQLError,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLString
+} from "graphql";
+
+import name_type from "../eosio_types/name_type.mjs";
+
+const variants_type = new GraphQLObjectType({
+  name: "abi_variant_type",
+  fields: () => ({
+    name: {
+      type: GraphQLString
+    },
+    types: {
+      type: new GraphQLList(GraphQLString)
+    }
+  })
+});
+
+const ricardian_clauses_type = new GraphQLObjectType({
+  name: "abi_richardian_clauses",
+  fields: () => ({
+    id: {
+      type: GraphQLString
+    },
+    body: {
+      type: GraphQLString
+    }
+  })
+});
+
+const tables_type = new GraphQLObjectType({
+  name: "abi_tables_type",
+  fields: () => ({
+    name: {
+      type: GraphQLString
+    },
+    index_type: {
+      type: GraphQLString
+    },
+    type: {
+      type: GraphQLString
+    },
+    key_names: {
+      type: new GraphQLList(GraphQLString)
+    },
+    key_types: {
+      type: new GraphQLList(GraphQLString)
+    }
+  })
+});
+
+const actions_type = new GraphQLObjectType({
+  name: "abi_actions_type",
+  fields: () => ({
+    name: {
+      type: GraphQLString
+    },
+    type: {
+      type: GraphQLString
+    },
+    ricardian_contract: {
+      type: GraphQLString
+    }
+  })
+});
+
+const types_type = new GraphQLObjectType({
+  name: "abi_types_type",
+  fields: () => ({
+    new_type_name: {
+      type: GraphQLString
+    },
+    type: {
+      desciption: "Native and blockchain types.",
+      type: GraphQLString
+    }
+  })
+});
+
+const field_type = new GraphQLObjectType({
+  name: "abi_field_type",
+  fields: () => ({
+    name: {
+      type: GraphQLString
+    },
+    type: {
+      type: GraphQLString
+    }
+  })
+});
+
+const struct_type = new GraphQLObjectType({
+  name: "abi_struct_type",
+  fields: () => ({
+    name: {
+      type: GraphQLString
+    },
+    base: {
+      type: GraphQLString
+    },
+    fields: {
+      type: new GraphQLList(field_type)
+    }
+  })
+});
+
+const abi_type = new GraphQLObjectType({
+  name: "abi_type",
+  description:
+    "The Application Binary Interface (ABI) is a JSON-based description on how to convert user actions between their JSON and Binary representations.",
+  fields: () => ({
+    actions: {
+      type: new GraphQLList(actions_type)
+    },
+    ricardian_clauses: {
+      description:
+        "Ricardian clauses describe the intended outcome of a particular actions. It may also be utilized to establish terms between the sender and the contract.",
+      type: new GraphQLList(ricardian_clauses_type)
+    },
+    structs: {
+      type: new GraphQLList(struct_type)
+    },
+    types: {
+      type: new GraphQLList(types_type)
+    },
+    tables: {
+      type: new GraphQLList(tables_type)
+    },
+    variants: {
+      type: new GraphQLList(variants_type)
+    },
+    version: {
+      type: GraphQLString
+    }
+  })
+});
+
+const get_abi = {
+  description: "Retrieve an application binary interface (ABI).",
+  type: abi_type,
+  args: {
+    account_name: {
+      description: "Account name of the smart contract holder.",
+      type: new GraphQLNonNull(name_type)
+    }
+  },
+  async resolve(
+    _,
+    { account_name },
+    { network: { fetch, rpc_url, ...fetchOptions } }
+  ) {
+    const uri = `${rpc_url}/v1/chain/get_abi`;
+    const req = await fetch(uri, {
+      method: "POST",
+      ...fetchOptions,
+      body: JSON.stringify({
+        account_name,
+        json: true
+      })
+    });
+    const data = await req.json();
+
+    if (data.error) throw new GraphQLError(data.message, { extensions: data });
+    return data.abi;
+  }
+};
+
+export default get_abi;

package/blockchain/get_account.mjs

@@ -0,0 +1,233 @@
+import {
+  GraphQLBoolean,
+  GraphQLError,
+  GraphQLInt,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLString
+} from "graphql";
+
+import asset_type from "../eosio_types/asset_type.mjs";
+import EOSIO_key_type from "../eosio_types/eosio_key_type.mjs";
+import name_type from "../eosio_types/name_type.mjs";
+
+const resource_type = new GraphQLObjectType({
+  name: "resource_type",
+  fields: () => ({
+    owner: { type: name_type },
+    net_weight: { type: GraphQLString },
+    cpu_weight: { type: GraphQLString },
+    ram_bytes: { type: GraphQLString }
+  })
+});
+
+const bandwidth_type = new GraphQLObjectType({
+  name: "bandwith_type",
+  fields: () => ({
+    used: { type: GraphQLString },
+    available: { type: GraphQLString },
+    max: { type: GraphQLString }
+  })
+});
+
+const require_auth_type = new GraphQLObjectType({
+  name: "require_auth_type",
+  fields: () => ({
+    threshold: { type: GraphQLInt },
+    keys: { type: new GraphQLList(EOSIO_key_type) },
+    accounts: {
+      type: new GraphQLList(
+        new GraphQLObjectType({
+          name: "accounts_auth_type",
+          fields: () => ({
+            weight: { type: GraphQLInt },
+            permission: {
+              type: new GraphQLObjectType({
+                name: "account_auth_permission_type",
+                fields: () => ({
+                  actor: { type: name_type },
+                  permission: { type: name_type }
+                })
+              })
+            }
+          })
+        })
+      )
+    },
+    waits: {
+      type: new GraphQLList(
+        new GraphQLObjectType({
+          name: "account_auth_waits_type",
+          description:
+            "specifies that a transaction will not be executed without a required delay",
+          fields: () => ({
+            wait_sec: { type: GraphQLInt },
+            weight: { type: GraphQLInt }
+          })
+        })
+      )
+    }
+  })
+});
+
+const linked_actions_type = new GraphQLObjectType({
+  name: "linked_actions_type",
+  fields: {
+    account: { type: name_type },
+    action: { type: name_type }
+  }
+});
+
+const permission_type = new GraphQLObjectType({
+  name: "permission_type",
+  description: "EOS account permissions",
+  fields: {
+    perm_name: { type: name_type },
+    parent: { type: name_type },
+    required_auth: { type: require_auth_type },
+    linked_actions: {
+      type: new GraphQLList(linked_actions_type)
+    }
+  }
+});
+
+const account_type = new GraphQLObjectType({
+  name: "account_type",
+  fields: () => ({
+    account_name: {
+      type: name_type
+    },
+    head_block_num: { type: GraphQLString },
+    head_block_time: { type: GraphQLString },
+    privileged: { type: GraphQLBoolean },
+    last_code_update: { type: GraphQLString },
+    created: { type: GraphQLString },
+    core_liquid_balance: { type: asset_type },
+    ram_quota: { type: GraphQLString },
+    net_weight: { type: GraphQLString },
+    cpu_weight: { type: GraphQLString },
+    net_limit: { type: bandwidth_type },
+    cpu_limit: { type: bandwidth_type },
+    ram_usage: { type: GraphQLString },
+    permissions: {
+      description: "List of the EOS `account_name` permissions",
+      type: new GraphQLList(permission_type)
+    },
+    total_resources: {
+      type: resource_type
+    },
+    self_delegated_bandwidth: {
+      type: new GraphQLObjectType({
+        name: "self_delegated_badwidth",
+        description: "Lists the amount of bandwidth your account has delegated",
+        fields: () => ({
+          to: { type: name_type },
+          from: { type: name_type },
+          net_weight: { type: asset_type },
+          cpu_weight: { type: asset_type }
+        })
+      })
+    },
+    refund_request: {
+      type: new GraphQLObjectType({
+        name: "account_refund_request",
+        description: "",
+        fields: () => ({
+          owner: { type: name_type },
+          request_time: { type: GraphQLString },
+          net_amount: { type: asset_type },
+          cpu_amount: { type: asset_type }
+        })
+      })
+    },
+    voter_info: {
+      type: new GraphQLObjectType({
+        name: "voter_info_type",
+        fields: () => ({
+          owner: { type: GraphQLString },
+          proxy: { type: GraphQLString },
+          producers: {
+            type: new GraphQLList(GraphQLString)
+          },
+          staked: { type: GraphQLString },
+          last_vote_weight: { type: GraphQLString },
+          proxied_vote_weight: { type: GraphQLString },
+          is_proxy: { type: GraphQLInt },
+          flags1: { type: GraphQLInt },
+          reserved2: { type: GraphQLInt },
+          reserved3: { type: GraphQLString }
+        })
+      })
+    },
+    subjective_cpu_bill_limit: {
+      type: new GraphQLObjectType({
+        name: "subjective_cpu_bill_limit_type",
+        fields: {
+          used: { type: GraphQLString },
+          available: { type: GraphQLString },
+          max: { type: GraphQLString }
+        }
+      })
+    },
+    rex_info: {
+      type: new GraphQLObjectType({
+        name: "rex_info_type",
+        fields: {
+          version: { type: GraphQLString },
+          owner: { type: GraphQLString },
+          vote_stake: { type: GraphQLString },
+          rex_balance: { type: GraphQLString },
+          matured_rex: { type: GraphQLString },
+          rex_maturities: {
+            type: new GraphQLList(
+              new GraphQLObjectType({
+                name: "pair_time_point_sec_int64",
+                fields: {
+                  key: { type: GraphQLString },
+                  value: { type: GraphQLString }
+                }
+              })
+            )
+          }
+        }
+      })
+    },
+    eosio_any_linked_actions: {
+      type: new GraphQLList(linked_actions_type)
+    }
+  })
+});
+
+const get_account = {
+  description: `Retreive details about a specific account on the blockchain.`,
+  type: account_type,
+  args: {
+    account_name: {
+      type: new GraphQLNonNull(name_type)
+    }
+  },
+  async resolve(
+    _,
+    { account_name },
+    { network: { fetch, rpc_url, ...fetchOptions } }
+  ) {
+    const uri = `${rpc_url}/v1/chain/get_account`;
+    const req = await fetch(uri, {
+      method: "POST",
+      ...fetchOptions,
+      body: JSON.stringify({
+        account_name,
+        json: true
+      })
+    });
+
+    const data = await req.json();
+
+    if (data.error) throw new GraphQLError(data.message, { extensions: data });
+
+    return data;
+  }
+};
+
+export default get_account;

package/blockchain/get_accounts_by_authorizers.mjs

@@ -0,0 +1,79 @@
+import {
+  GraphQLError,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLString
+} from "graphql";
+
+import name_type from "../eosio_types/name_type.mjs";
+import public_key_type from "../eosio_types/public_key_type.mjs";
+import authorizing_account_type from "../graphql_object_types/authorizing_account_type.mjs";
+
+const authorized_accounts_type = new GraphQLObjectType({
+  name: "authorized_accounts_type",
+  fields: () => ({
+    account_name: {
+      type: name_type
+    },
+    permission_name: {
+      type: name_type
+    },
+    authorizing_key: {
+      type: public_key_type
+    },
+    authorizing_account: {
+      type: authorizing_account_type
+    },
+    weight: {
+      type: GraphQLString
+    },
+    threshold: {
+      type: GraphQLString
+    }
+  })
+});
+
+const accounts_by_authorizers_type = new GraphQLObjectType({
+  name: "accounts_by_authorizers",
+  fields: () => ({
+    accounts: {
+      type: new GraphQLList(authorized_accounts_type)
+    }
+  })
+});
+
+const accounts_by_authorizers = {
+  description:
+    "Fetch permissions authorities that are, in part or whole, satisfiable.",
+  type: accounts_by_authorizers_type,
+  args: {
+    accounts: {
+      type: new GraphQLList(new GraphQLNonNull(name_type))
+    },
+    keys: {
+      type: new GraphQLList(new GraphQLNonNull(public_key_type))
+    }
+  },
+  async resolve(
+    _,
+    { accounts = [], keys = [] },
+    { network: { fetch, rpc_url, ...fetchOptions } }
+  ) {
+    const uri = `${rpc_url}/v1/chain/get_accounts_by_authorizers`;
+    const data = await fetch(uri, {
+      method: "POST",
+      ...fetchOptions,
+      body: JSON.stringify({
+        keys: await Promise.all(keys),
+        accounts,
+        json: true
+      })
+    }).then((req) => req.json());
+
+    if (data.error) throw new GraphQLError(data.message, { extensions: data });
+    return data;
+  }
+};
+
+export default accounts_by_authorizers;