antelopeql 1.0.0

package/eosio_types/symbol_type.mjs

@@ -0,0 +1,33 @@
+import { GraphQLScalarType } from "graphql";
+
+const symbol_type = new GraphQLScalarType({
+  description: `\`Symbol type\`
+
+---
+
+An eosio symbol is an all uppercase string of 7 or less characters from [A-Z].
+
+  ### Symbol rules
+
+  - Ends with a symbol up to 7 characters long
+  - Symbol must be uppercase
+  - Maximum value (2^62 - 1)
+  - Maximum decimal precision of 18
+
+  `,
+  name: "symbol",
+  parseValue: (symbol) => {
+    if (!symbol.match(/^[0-9]{1,2},[A-Z]{1,7}$/gmu))
+      throw new Error(
+        "Invalid symbol format, correct format is <precision,code>"
+      );
+    const [precision] = symbol.split(",");
+
+    if (!(precision > -1 && precision < 18))
+      throw new RangeError("Invalid symbol precision, maximum 18");
+
+    return symbol;
+  }
+});
+
+export default symbol_type;

package/eosio_types/time_point_sec_type.mjs

@@ -0,0 +1,12 @@
+import { GraphQLScalarType } from "graphql";
+
+const time_point_sec_type = new GraphQLScalarType({
+  description: `\`time point sec\`
+
+  Number of seconds since epoch (Unix time).
+  `,
+  name: "time_point_sec",
+  parseValue: (time) => time
+});
+
+export default time_point_sec_type;

package/eosio_types/time_point_type.mjs

@@ -0,0 +1,12 @@
+import { GraphQLScalarType } from "graphql";
+
+const time_point_type = new GraphQLScalarType({
+  description: `\`time point\`
+
+  Number of milliseconds since epoch (Unix time).
+  `,
+  name: "time_point",
+  parseValue: (time) => time
+});
+
+export default time_point_type;

package/eosio_types/varint32_type.mjs

@@ -0,0 +1,13 @@
+import { GraphQLScalarType } from "graphql";
+
+const varuint32_type = new GraphQLScalarType({
+  description: `\`varint32\`
+
+  A Signed LEB128 variable-length integer, limited to 32 bits (i.e., the values [-2^(32-1), +2^(32-1)-1]), represented by at most ceil(32/7) bytes that may contain padding 0x80 or 0xFF bytes.
+
+  `,
+  name: "varint32",
+  parseValue: (varint32) => varint32
+});
+
+export default varuint32_type;

package/eosio_types/varuint32_type.mjs

@@ -0,0 +1,12 @@
+import { GraphQLScalarType } from "graphql";
+
+const varuint32_type = new GraphQLScalarType({
+  description: `\`varuint32\`
+
+  A LEB128 variable-length integer, limited to 32 bits (i.e., the values [0, 2^32-1]), represented by at most ceil(32/7) bytes that may contain padding 0x80 bytes.
+  `,
+  name: "varuint32",
+  parseValue: (varuint32) => varuint32
+});
+
+export default varuint32_type;

package/eosio_types.mjs

@@ -0,0 +1,59 @@
+import { GraphQLString } from "graphql";
+
+import asset from "./eosio_types/asset_type.mjs";
+import block_timestamp_type from "./eosio_types/block_timestamp_type.mjs";
+import bool from "./eosio_types/boolean_type.mjs";
+import bytes from "./eosio_types/bytes_type.mjs";
+import extended_asset from "./eosio_types/extended_asset_type.mjs";
+import generate_checksum from "./eosio_types/generate_checksum_type.mjs";
+import generate_float_type from "./eosio_types/generate_float_type.mjs";
+import generate_int_type from "./eosio_types/generate_int_type.mjs";
+import generate_uint_type from "./eosio_types/generate_uint_type.mjs";
+import name from "./eosio_types/name_type.mjs";
+import public_key from "./eosio_types/public_key_type.mjs";
+import signature from "./eosio_types/signature_type.mjs";
+import symbol_code from "./eosio_types/symbol_code_type.mjs";
+import symbol from "./eosio_types/symbol_type.mjs";
+import time_point_sec from "./eosio_types/time_point_sec_type.mjs";
+import time_point from "./eosio_types/time_point_type.mjs";
+import varint32 from "./eosio_types/varint32_type.mjs";
+import varuint32 from "./eosio_types/varuint32_type.mjs";
+
+/**
+ * An object containing EOSIO native types.
+ */
+const eosio_types = {
+  asset,
+  block_timestamp_type,
+  bool,
+  bytes,
+  checksum160: generate_checksum(20),
+  checksum256: generate_checksum(32),
+  checksum512: generate_checksum(64),
+  extended_asset,
+  float32: generate_float_type(32),
+  float64: generate_float_type(64),
+  float128: generate_float_type(128),
+  int8: generate_int_type(8),
+  int16: generate_int_type(16),
+  int32: generate_int_type(32),
+  int64: generate_int_type(64),
+  int128: generate_int_type(128),
+  name,
+  public_key,
+  signature,
+  string: GraphQLString,
+  symbol,
+  symbol_code,
+  time_point,
+  time_point_sec,
+  uint8: generate_uint_type(8),
+  uint16: generate_uint_type(16),
+  uint32: generate_uint_type(32),
+  uint64: generate_uint_type(64),
+  uint128: generate_uint_type(128),
+  varint32,
+  varuint32
+};
+
+export default eosio_types;

package/graphql_input_types/actions.mjs

@@ -0,0 +1,15 @@
+import { GraphQLInputObjectType, GraphQLList, GraphQLNonNull } from "graphql";
+
+const actions_type = (fields) =>
+  new GraphQLNonNull(
+    new GraphQLList(
+      new GraphQLNonNull(
+        new GraphQLInputObjectType({
+          name: "actions_type",
+          fields
+        })
+      )
+    )
+  );
+
+export default actions_type;

package/graphql_input_types/authorization.mjs

@@ -0,0 +1,30 @@
+import { GraphQLInputObjectType, GraphQLNonNull } from "graphql";
+
+import name_type from "../eosio_types/name_type.mjs";
+
+/**
+ * The action authorization type for action validation.
+ * @kind typedef
+ * @name authorization
+ * @type {Object}
+ * @prop {String} actor Name of the account that is trying to authorize.
+ * @prop {String} permission Name of the `permission` of the the `actor`
+ */
+
+const authorization_type = new GraphQLInputObjectType({
+  name: "authorization",
+  description: "Authorization object type.",
+  fields: () => ({
+    actor: {
+      description: "The name of the account name to sign the transaction.",
+      type: new GraphQLNonNull(name_type)
+    },
+    permission: {
+      description: "The name of the account permission.",
+      type: name_type,
+      defaultValue: "active"
+    }
+  })
+});
+
+export default authorization_type;

package/graphql_input_types/configuration.mjs

@@ -0,0 +1,55 @@
+// @ts-check
+
+import { GraphQLInputObjectType, GraphQLInt } from "graphql";
+
+const configuration_default_value = {
+  blocksBehind: 3,
+  expireSeconds: 30,
+  max_net_usage_words: 0,
+  max_cpu_usage_ms: 0,
+  delay_sec: 0
+};
+
+/**
+ * Handles various elements relating to the `EOSIO` transaction.
+ * @typedef {Object} configuration_type
+ * @param {Number} blocksBehind Number of blocks behind the current block (TaPoS protection).
+ * @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",
+  description:
+    "Configuration input to control various aspects of the transaction.",
+  fields: () => ({
+    blocksBehind: {
+      description: "Number of blocks behind the current block",
+      type: GraphQLInt,
+      defaultValue: configuration_default_value.blocksBehind
+    },
+    expireSeconds: {
+      description: "Seconds past before transaction is no longer valid",
+      type: GraphQLInt,
+      defaultValue: configuration_default_value.expireSeconds
+    },
+    max_net_usage_words: {
+      description: `Maximum NET bandwidth usage a transaction can consume, \nwhen set to 0 there is no limit`,
+      type: GraphQLInt,
+      defaultValue: configuration_default_value.max_net_usage_words
+    },
+    max_cpu_usage_ms: {
+      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
+    }
+  })
+});
+
+export default configuration_type;

package/graphql_input_types/query_argument_fields.mjs

@@ -0,0 +1,82 @@
+import {
+  GraphQLEnumType,
+  GraphQLInputObjectType,
+  GraphQLInt,
+  GraphQLString
+} from "graphql";
+
+const index_position_enum_type = new GraphQLEnumType({
+  name: "index_position_enum_type",
+  values: {
+    primary: { value: "primary" },
+    secondary: { value: "secondary" }
+  }
+});
+
+const key_type_enum_type = new GraphQLEnumType({
+  name: "key_type_enum",
+  description: `Primary only supports i64. All others support i64, i128, i256, float64, float128, ripemd160, sha256.`,
+  values: {
+    name: { value: "name", description: "Indicates an account name." },
+    i64: { value: "i64" },
+    i128: { value: "i128" },
+    i256: { value: "i256" },
+    float64: { value: "float64" },
+    float128: { value: "float128" },
+    ripemd160: { value: "ripemd160" },
+    sha256: { value: "sha256" }
+  }
+});
+
+const encode_type_enum_type = new GraphQLEnumType({
+  name: "encode_type_enum",
+  description: `
+  \`dec\` for decimal encoding of (i[64|128|256] and float[64|128])
+  \`hex\` for hexadecimal encoding of (i256, ripemd160, sha256).`,
+  values: {
+    dec: { value: "dec" },
+    hex: { value: "hex" }
+  }
+});
+
+const query_arg_fields = new GraphQLInputObjectType({
+  name: "arguments",
+  fields: {
+    scope: {
+      type: GraphQLString,
+      description: `The scope within the table to query data from.`,
+      defaultValue: ""
+    },
+    index_position: {
+      type: index_position_enum_type,
+      description: "Position of the index used.",
+      defaultValue: "primary"
+    },
+    key_type: {
+      type: key_type_enum_type,
+      description: "The key type of `index_position`",
+      defaultValue: "name"
+    },
+    encode_type: {
+      type: encode_type_enum_type,
+      description: "`key_type` encoding",
+      defaultValue: "dec"
+    },
+    upper_bound: {
+      type: GraphQLString,
+      description:
+        "Filters results to return the first element that is greater than provided value in set."
+    },
+    lower_bound: {
+      type: GraphQLString,
+      description:
+        "Filters results to return the first element that is not less than provided value in set."
+    },
+    limit: {
+      type: GraphQLInt,
+      description: "The maximum number of items to return"
+    }
+  }
+});
+
+export default query_arg_fields;

package/graphql_object_types/authorization.mjs

@@ -0,0 +1,15 @@
+import { GraphQLObjectType, GraphQLString } from "graphql";
+
+const authorization_type = new GraphQLObjectType({
+  name: "authorization_type",
+  fields: () => ({
+    actor: {
+      type: GraphQLString
+    },
+    permission: {
+      type: GraphQLString
+    }
+  })
+});
+
+export default authorization_type;

package/graphql_object_types/authorizing_account_type.mjs

@@ -0,0 +1,15 @@
+import { GraphQLNonNull, GraphQLObjectType, GraphQLString } from "graphql";
+
+const authorizing_account_type = new GraphQLObjectType({
+  name: "authorizing_account_type",
+  fields: () => ({
+    actor: {
+      type: new GraphQLNonNull(GraphQLString)
+    },
+    permission: {
+      type: GraphQLString
+    }
+  })
+});
+
+export default authorizing_account_type;

package/graphql_object_types/packed_transaction.mjs

@@ -0,0 +1,32 @@
+import { GraphQLObjectType, GraphQLString } from "graphql";
+
+/**
+ * The packed transaction type.
+ * @kind typedef
+ * @name packed_transaction
+ * @type {Object}
+ * @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.
+
+ */
+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)_."
+    }
+  }
+});
+
+export default packed_transaction_type;

package/graphql_object_types/transaction_receipt.mjs

@@ -0,0 +1,159 @@
+import {
+  GraphQLBoolean,
+  GraphQLEnumType,
+  GraphQLID,
+  GraphQLInt,
+  GraphQLList,
+  GraphQLObjectType,
+  GraphQLString
+} from "graphql";
+
+import name_type from "../eosio_types/name_type.mjs";
+import authorizing_account_type from "./authorization.mjs";
+
+/**
+ * @typedef {Enumerator} Transaction_status
+ * @prop {String} executed succeed, no error handler executed.
+ * @prop {String} soft_fail objectively failed (not executed), error handler executed.
+ * @prop {String} hard_fail objectively failed and error handler objectively failed thus no state change.
+ * @prop {String} delayed transaction delayed/deferred/scheduled for future execution.
+ * @prop {String} expired transaction expired and storage space refunded to user.
+ */
+const transaction_status = new GraphQLEnumType({
+  name: "transaction_receipt_status",
+  description: `Describes the status of the transaction.`,
+  values: {
+    executed: {
+      value: "executed",
+      description: "succeed, no error handler executed"
+    },
+    soft_fail: {
+      value: "soft_fail",
+      description: "objectively failed (not executed), error handler executed"
+    },
+    hard_fail: {
+      value: "hard_fail",
+      description:
+        "objectively failed and error handler objectively failed thus no state change"
+    },
+    delayed: {
+      value: "delayed",
+      description: "transaction delayed/deferred/scheduled for future execution"
+    },
+    expired: {
+      value: "expired",
+      description: "transaction expired and storage space refunded to user"
+    }
+  }
+});
+
+/**
+ * Bandwidth reciept for EOSIO transaction.
+ * @typedef {Object} Bandwidth_cost
+ * @prop {Number} net_usage_words Consumption of network bandwidth (bytes).
+ * @prop {Number} cpu_usage_us Consumption of CPU bandwidth (µs).
+ * @prop {Transaction_status} status Transaction receipt status Enum.
+ */
+const bandwidth_cost_type = new GraphQLObjectType({
+  name: "bandwidth_cost",
+  fields: () => ({
+    cpu_usage_us: {
+      type: GraphQLInt,
+      resolve: ({ cpu_usage_us }) => cpu_usage_us
+    },
+    net_usage_words: {
+      type: GraphQLInt,
+      resolve: ({ net_usage_words }) => net_usage_words
+    },
+    status: {
+      type: transaction_status
+    }
+  })
+});
+
+const action_trace_type = new GraphQLObjectType({
+  name: "action_trace",
+  description: "list of actions that the transaction includes.",
+  fields: () => ({
+    account: {
+      type: name_type,
+      description: "Contract name of the action you are calling.",
+      resolve: ({ act }) => act.account
+    },
+    name: {
+      type: name_type,
+      description: "The action name of the contract.",
+      resolve: ({ act }) => act.name
+    },
+    authorization: {
+      type: new GraphQLList(authorizing_account_type),
+      description: "Action authorization",
+      resolve: ({ act }) => act.authorization
+    },
+    data: {
+      type: GraphQLString,
+      description: "JSON representation of the action data.",
+      resolve: ({ act }) => JSON.stringify(act.data)
+    },
+    inline_traces: {
+      description: "Inline action trace.",
+      type: new GraphQLList(action_trace_type),
+      resolve: ({ inline_traces }) => inline_traces
+    }
+  })
+});
+
+/**
+ * @typedef {Object} transaction_receipt
+ * @type {Object}
+ * @prop {String} transaction_id ID of the transaction.
+ * @prop {Number} block_num Block number where teh transaction can be found.
+ * @prop {Stiring} block_time The time of the transaction.
+ * @prop {String} producer_block_id The block producer ID that processed the transaction.
+ * @prop {Bandwidth_cost} resource_cost Network cost for the transaction.
+ * @prop {Boolean} scheduled Scheduled transactions are executed at a later time.
+ */
+const transaction_receipt_type = new GraphQLObjectType({
+  name: "transaction_receipt",
+  description: "Receipt for the action (mutation) for a blockchain transaction",
+  fields: () => ({
+    transaction_id: {
+      type: GraphQLID,
+      description: "`eosio` blockchain transaction id “reciept”"
+    },
+    block_num: {
+      type: GraphQLInt,
+      description: "What block the transaction is located in",
+      resolve: ({ processed }) => processed.block_num
+    },
+    block_time: {
+      type: GraphQLString,
+      description: "transaction time (GMT)",
+      resolve: ({ processed }) => processed.block_time
+    },
+    producer_block_id: {
+      type: GraphQLString,
+      description: "Block producer ID that processed the transaction.",
+      resolve: ({ processed }) => processed.producer_block_id
+    },
+    resource_cost: {
+      description:
+        "A resource object for the network cost of running the transaction",
+      type: bandwidth_cost_type,
+      resolve: ({ processed }) => processed.receipt
+    },
+    scheduled: {
+      type: GraphQLBoolean,
+      description: "Scheduled transactions are executed at a later time.",
+      resolve: ({ processed }) => processed.scheduled
+    },
+    action_traces: {
+      description:
+        "A JSON string trace of the actions performed for the transaction.",
+      type: new GraphQLList(action_trace_type),
+      resolve: ({ processed }) => processed.action_traces
+    }
+  })
+});
+
+export default transaction_receipt_type;