antelopeql 1.0.0

package/blockchain/get_block.mjs

@@ -0,0 +1,238 @@
+import {
+  GraphQLError,
+  GraphQLID,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLString
+} from "graphql";
+
+import bytes_type from "../eosio_types/bytes_type.mjs";
+import authorization_type from "../graphql_object_types/authorization.mjs";
+
+const action_type = new GraphQLObjectType({
+  name: "action_type",
+  fields: () => ({
+    account: {
+      type: GraphQLString
+    },
+    name: {
+      type: GraphQLString
+    },
+    authorization: {
+      type: new GraphQLList(authorization_type)
+    },
+    data: {
+      type: GraphQLString,
+      description: "JSON representation of the transaction data.",
+      resolve({ data }) {
+        return JSON.stringify(data);
+      }
+    },
+    hex_data: {
+      type: bytes_type
+    }
+  })
+});
+
+const producer_type = new GraphQLObjectType({
+  name: "producer_type",
+  fields: () => ({
+    producer_name: {
+      type: GraphQLString
+    },
+    block_signing_key: {
+      type: GraphQLString,
+      description: `Base58 encoded EOSIO public key.`
+    }
+  })
+});
+
+const new_producer_type = new GraphQLObjectType({
+  name: "new_producer_type",
+  fields: () => ({
+    version: {
+      type: GraphQLString
+    },
+    producers: {
+      type: new GraphQLList(producer_type)
+    }
+  })
+});
+
+const packed_transaction_type = new GraphQLObjectType({
+  name: "packed_transaction_type",
+  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
+    },
+    delay_sec: {
+      type: GraphQLString
+    },
+    context_free_actions: {
+      type: new GraphQLList(action_type)
+    },
+    actions: {
+      type: new GraphQLList(action_type)
+    }
+  })
+});
+
+const trx_type = new GraphQLObjectType({
+  name: "trx_type",
+  fields: () => ({
+    id: {
+      type: GraphQLID
+    },
+    signatures: {
+      type: new GraphQLList(GraphQLString)
+    },
+    compression: {
+      type: GraphQLString
+    },
+    packed_context_free_data: {
+      type: GraphQLString
+    },
+    context_free_data: {
+      type: new GraphQLList(GraphQLString)
+    },
+    packed_trx: {
+      type: GraphQLString
+    },
+    transaction: {
+      type: packed_transaction_type
+    }
+  })
+});
+
+const transactions_type = new GraphQLObjectType({
+  name: "transaction_type",
+  fields: () => ({
+    status: {
+      type: GraphQLString,
+      description: "List of valid transaction receipts included in block."
+    },
+    cpu_usage_us: {
+      type: GraphQLString
+    },
+    net_usage_words: {
+      type: GraphQLString
+    },
+    trx: {
+      type: trx_type
+    }
+  })
+});
+
+const block_type = new GraphQLObjectType({
+  name: "block_type",
+  description: "",
+  fields: () => ({
+    timestamp: {
+      description: "Date/time string in the format `YYYY-MM-DDTHH:MM:SS.sss`",
+      type: GraphQLString
+    },
+    producer: {
+      description: "The `name` of the producer.",
+      type: GraphQLString
+    },
+    confirmed: {
+      description:
+        "Number of prior blocks confirmed by this block producer in current schedule",
+      type: GraphQLString
+    },
+    previous: {
+      description: "The `sha256` hash representing the previous.",
+      type: GraphQLString
+    },
+    transaction_mroot: {
+      description: "The transaction merkle root `sha256`.",
+      type: GraphQLString
+    },
+    action_mroot: {
+      description: "The action merkle root `sha256` string.",
+      type: GraphQLString
+    },
+    schedule_version: {
+      description:
+        "Number of times producer schedule has changed since genesis.",
+      type: GraphQLString
+    },
+    new_producers: {
+      description: "A list of new producers.",
+      type: new_producer_type
+    },
+    header_extensions: {
+      type: new GraphQLList(GraphQLString)
+    },
+    producer_signature: {
+      type: GraphQLString,
+      description: `Base58 encoded EOSIO cryptographic signature.`
+    },
+    transactions: {
+      type: new GraphQLList(transactions_type),
+      description: "List of valid transaction receipts included in block."
+    },
+    block_extensions: {
+      type: new GraphQLList(GraphQLString)
+    },
+    id: {
+      description: "The ID of the a given block `sha256`.",
+      type: GraphQLString
+    },
+    block_num: {
+      description:
+        "Height of this block in the chain, no. of blocks since genesis.",
+      type: GraphQLString
+    },
+    ref_block_prefix: {
+      description: "32-bit portion of block ID",
+      type: GraphQLString
+    }
+  })
+});
+
+const get_block = {
+  description: "Return info relating to a specific block.",
+  type: block_type,
+  args: {
+    block_num_or_id: {
+      description: "The `block number` or a `block id`.",
+      type: new GraphQLNonNull(GraphQLString)
+    }
+  },
+  async resolve(
+    _,
+    { block_num_or_id },
+    { network: { fetch, rpc_url, ...fetchOptions } }
+  ) {
+    const uri = `${rpc_url}/v1/chain/get_block`;
+    const req = await fetch(uri, {
+      method: "POST",
+      ...fetchOptions,
+      body: JSON.stringify({
+        block_num_or_id,
+        json: true
+      })
+    });
+    const data = await req.json();
+
+    if (data.error) throw new GraphQLError(data.message, { extensions: data });
+
+    return data;
+  }
+};
+
+export default get_block;

package/blockchain/get_currency_balance.mjs

@@ -0,0 +1,48 @@
+import {
+  GraphQLError,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLString
+} from "graphql";
+
+import name_type from "../eosio_types/name_type.mjs";
+import symbol_code_type from "../eosio_types/symbol_code_type.mjs";
+
+const currency_balance = {
+  description: "Retrieve current balance.",
+  type: new GraphQLList(GraphQLString),
+  args: {
+    code: {
+      description: "The account name that holds the currency tokens",
+      type: name_type,
+      defaultValue: "eosio.token"
+    },
+    account: {
+      description: "Account name to query the balance for.",
+      type: new GraphQLNonNull(name_type)
+    },
+    symbol: {
+      description: "The crytpo currency token symbol.",
+      type: new GraphQLNonNull(symbol_code_type),
+      defaultValue: "EOS"
+    }
+  },
+  async resolve(_, args, { network: { fetch, rpc_url, ...fetchOptions } }) {
+    const uri = `${rpc_url}/v1/chain/get_currency_balance`;
+    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 data;
+  }
+};
+
+export default currency_balance;

package/blockchain/get_currency_stats.mjs

@@ -0,0 +1,60 @@
+import {
+  GraphQLError,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLString
+} from "graphql";
+
+import name_type from "../eosio_types/name_type.mjs";
+import symbol_code_type from "../eosio_types/symbol_code_type.mjs";
+
+const currency_stats_type = new GraphQLObjectType({
+  name: "currency_stats_type",
+  fields: () => ({
+    supply: {
+      type: GraphQLString
+    },
+    max_supply: {
+      type: GraphQLString
+    },
+    issuer: {
+      type: name_type
+    }
+  })
+});
+
+const get_currency_stats = {
+  description: "Retrieve currency stats.",
+  type: currency_stats_type,
+  args: {
+    code: {
+      type: new GraphQLNonNull(name_type)
+    },
+    symbol: {
+      type: new GraphQLNonNull(symbol_code_type)
+    }
+  },
+  async resolve(
+    _,
+    { symbol, ...args },
+    { network: { fetch, rpc_url, ...fetchOptions } }
+  ) {
+    const uri = `${rpc_url}/v1/chain/get_currency_stats`;
+    const req = await fetch(uri, {
+      method: "POST",
+      ...fetchOptions,
+      body: JSON.stringify({
+        symbol,
+        json: true,
+        ...args
+      })
+    });
+    const data = await req.json();
+
+    if (data.error) throw new GraphQLError(data.message, { extensions: data });
+
+    return data[symbol];
+  }
+};
+
+export default get_currency_stats;

package/blockchain/get_info.mjs

@@ -0,0 +1,96 @@
+import { GraphQLError, GraphQLObjectType, GraphQLString } from "graphql";
+
+const info_type = new GraphQLObjectType({
+  name: "info_type",
+  description: "Returns various details about the EOS blockchain",
+  fields: () => ({
+    server_version: {
+      type: GraphQLString,
+      description: "Hash representing the last commit in the tagged release"
+    },
+    chain_id: {
+      type: GraphQLString,
+      description: "Hash representing the ID of the chain"
+    },
+    head_block_num: {
+      type: GraphQLString,
+      description: "Highest block number on the chain"
+    },
+    head_block_id: {
+      type: GraphQLString,
+      description: "Highest block ID on the chain"
+    },
+    head_block_time: {
+      type: GraphQLString,
+      description: "Highest block unix timestamp"
+    },
+    head_block_producer: {
+      type: GraphQLString,
+      description: "Producer that signed the highest block (head block)"
+    },
+    last_irreversible_block_num: {
+      type: GraphQLString,
+      description:
+        "Highest block number on the chain that has been irreversibly applied to state"
+    },
+    last_irreversible_block_id: {
+      type: GraphQLString,
+      description:
+        "Highest block ID on the chain that has been irreversibly applied to state"
+    },
+    virtual_block_cpu_limit: {
+      type: GraphQLString,
+      description:
+        "CPU limit calculated after each block is produced, approximately 1000 times block_cpu_limit"
+    },
+    virtual_block_net_limit: {
+      type: GraphQLString,
+      description:
+        "NET limit calculated after each block is produced, approximately 1000 times block_net_limit"
+    },
+    block_cpu_limit: {
+      type: GraphQLString,
+      description: "Actual maximum CPU limit"
+    },
+    block_net_limit: {
+      type: GraphQLString,
+      description: "Actual maximum NET limit"
+    },
+    server_version_string: {
+      type: GraphQLString,
+      description:
+        "String representation of server version - Majorish-Minorish-Patchy - Warning - Not actually SEMVER!"
+    },
+    fork_db_head_block_num: {
+      type: GraphQLString,
+      description:
+        "Sequential block number representing the best known head in the fork database tree"
+    },
+    fork_db_head_block_id: {
+      type: GraphQLString,
+      description:
+        "Sequential block number representing the best known head in the fork database tree"
+    }
+  })
+});
+
+const info = {
+  description: "Return info about the operational state of the blockchain.",
+  type: info_type,
+  args: {},
+  async resolve(_, __, { network: { fetch, rpc_url, ...fetchOptions } }) {
+    const uri = `${rpc_url}/v1/chain/get_info`;
+    const req = await fetch(uri, {
+      method: "POST",
+      ...fetchOptions
+    });
+
+    const data = await req.json();
+
+    if (data.error) throw new GraphQLError(data.message, { extensions: data });
+
+    return data;
+  }
+};
+
+export default info;

package/blockchain/get_producers.mjs

@@ -0,0 +1,104 @@
+import {
+  GraphQLError,
+  GraphQLInt,
+  GraphQLList,
+  GraphQLObjectType,
+  GraphQLString
+} from "graphql";
+
+import EOSIO_key_type from "../eosio_types/eosio_key_type.mjs";
+import public_key_type from "../eosio_types/public_key_type.mjs";
+
+const producers = new GraphQLObjectType({
+  name: "blockchain_block_producers",
+  fields: {
+    owner: {
+      type: GraphQLString
+    },
+    total_votes: {
+      type: GraphQLString
+    },
+    producer_key: {
+      type: public_key_type
+    },
+    is_active: {
+      type: GraphQLString
+    },
+    url: {
+      type: GraphQLString
+    },
+    unpaid_blocks: {
+      type: GraphQLString
+    },
+    last_claim_time: {
+      type: GraphQLString
+    },
+    location: {
+      type: GraphQLString
+    },
+    producer_authority: {
+      type: new GraphQLObjectType({
+        name: "block_producer_authority",
+        fields: {
+          threshold: {
+            type: GraphQLInt
+          },
+          keys: {
+            type: new GraphQLList(EOSIO_key_type)
+          }
+        }
+      }),
+      resolve(data) {
+        return data.producer_authority[1];
+      }
+    }
+  }
+});
+
+const get_producers = {
+  description: "Return info about block producers.",
+  type: new GraphQLObjectType({
+    name: "blockchain_producers",
+    fields: {
+      total_producer_vote_weight: {
+        type: GraphQLString
+      },
+      more: {
+        type: GraphQLString,
+        description: "the next block producer in the list"
+      },
+      rows: {
+        type: new GraphQLList(producers)
+      }
+    }
+  }),
+  args: {
+    limit: {
+      description: "total number of producers to retrieve",
+      type: GraphQLString,
+      defaultValue: "10"
+    },
+    lower_bound: {
+      description:
+        "In conjunction with limit can be used to paginate through the results. For example, limit=10 and lower_bound=10 would be page 2.",
+      type: GraphQLString
+    }
+  },
+  async resolve(_, args, { network: { fetch, rpc_url, ...fetchOptions } }) {
+    const uri = `${rpc_url}/v1/chain/get_producers`;
+
+    const req = await fetch(uri, {
+      method: "POST",
+      body: JSON.stringify({ ...args, json: true }),
+      ...fetchOptions
+    });
+
+    const data = await req.json();
+
+    if (data.error) throw new GraphQLError(data.message, { extensions: data });
+
+    return data;
+  }
+};
+
+export default get_producers;

package/blockchain/get_ram_price.mjs

@@ -0,0 +1,57 @@
+import { GraphQLError, GraphQLObjectType, GraphQLString } from "graphql";
+
+const RAM_quote_type = new GraphQLObjectType({
+  name: "blockchain_ram_price",
+  fields: () => ({
+    quote: {
+      type: GraphQLString,
+      resolve: (EOS) => EOS
+    }
+  })
+});
+
+const get_ram_price = {
+  description: "RAM quote (bytes)",
+  type: RAM_quote_type,
+  args: {
+    quantity: {
+      type: GraphQLString,
+      description: "Number of bytes of RAM."
+    }
+  },
+  async resolve(
+    _,
+    { quantity },
+    { network: { fetch, rpc_url, ...fetchOptions } }
+  ) {
+    const data = await fetch(rpc_url + "/v1/chain/get_table_rows", {
+      method: "POST",
+      ...fetchOptions,
+      body: JSON.stringify({
+        code: "eosio",
+        json: true,
+        table: "rammarket",
+        scope: "eosio",
+        index_position: 1,
+        key_type: "i128",
+        lower_bound: "",
+        upper_bound: ""
+      })
+    }).then((req) => req.json());
+
+    if (data.error) throw new GraphQLError(data.message, { extensions: data });
+
+    if (data.rows) {
+      // Connector Balance / (Smart Token’s Outstanding supply × Connector Weight)
+      const [RAM] = data.rows;
+      const CORE_TOKEN = RAM.quote.balance.match(/[\sA-Z]+/gmu);
+
+      const supply = RAM.base.balance.replace(" RAM", "");
+      const total_value = RAM.quote.balance.replace(CORE_TOKEN, "");
+      const byte_price = quantity * (total_value / supply);
+      return byte_price + CORE_TOKEN;
+    }
+  }
+};
+
+export default get_ram_price;

package/blockchain/get_table_by_scope.mjs

@@ -0,0 +1,96 @@
+import {
+  GraphQLError,
+  GraphQLInt,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLString
+} from "graphql";
+
+import name_type from "../eosio_types/name_type.mjs";
+
+const table_type = new GraphQLObjectType({
+  name: "table_type",
+  fields: {
+    rows: {
+      type: new GraphQLList(
+        new GraphQLObjectType({
+          name: "table_rows_type",
+          fields: {
+            scope: { type: name_type },
+            table_name: { type: name_type, resolve: ({ table }) => table },
+            ram_payer: {
+              type: name_type,
+              description: "The account that pays for the data entries.",
+              resolve: ({ payer }) => payer
+            },
+            count: {
+              type: name_type,
+              description: "No. of entries in the table."
+            }
+          }
+        })
+      )
+    },
+    more: {
+      type: name_type
+    }
+  }
+});
+
+const get_table = {
+  description: "Retrieve a table from the blockchain.",
+  type: table_type,
+  args: {
+    account_name: {
+      description: "The account name of the `smart contract`.",
+      type: new GraphQLNonNull(name_type)
+    },
+    table_name: {
+      description: "The table name on the smart contract.",
+      type: name_type
+    },
+    limit: {
+      description:
+        "Limit number of results returned (how many items to return).",
+      type: GraphQLInt,
+      defaultValue: 10
+    },
+    lower_bound: {
+      description:
+        "Filters results to return the first element that is not less than provided value in the table.",
+      type: GraphQLString
+    },
+    upper_bound: {
+      description:
+        "Filters results to return the first element that is greater than provided value in the table.",
+      type: GraphQLString
+    }
+  },
+  async resolve(
+    _,
+    { account_name, table_name, limit, lower_bound, upper_bound },
+    { network: { fetch, rpc_url, ...fetchOptions } }
+  ) {
+    const uri = `${rpc_url}/v1/chain/get_table_by_scope`;
+    const data = await fetch(uri, {
+      method: "POST",
+      ...fetchOptions,
+      body: JSON.stringify({
+        code: account_name,
+        table: table_name,
+        limit,
+        lower_bound,
+        upper_bound,
+        json: true,
+        show_payer: true
+      })
+    }).then((req) => req.json());
+
+    if (data.error) throw new GraphQLError(data.message, { extensions: data });
+
+    return data;
+  }
+};
+
+export default get_table;