antelopeql 2.0.0-rc.0 → 2.0.0-rc.2

package/blockchain/bandwidth_quote.mjs

@@ -0,0 +1,244 @@
+import { GraphQLObjectType, GraphQLScalarType, GraphQLString } from "graphql";
+
+const string_or_int = new GraphQLScalarType({
+  name: "string_or_int",
+  description: "`String` or `Integer` type."
+});
+
+/**
+ * Calculates the fraction of bw needed for power up action for the EOSIO blockchain.
+ * @param {number | string} us Microseconds needed to supply to account.
+ * @param {number | string} us Kibibytes needed to supply to account.
+ * @param {Object} power_up_state Power up state.
+ * @param {Object} account_info Account to get an approximate cost of BW.
+ * @returns {number} Fraction of CPU and Netwotk bandwidth to supply to powerup action.
+ */
+function calculate_fraction(us, bytes, power_up_state, account_info) {
+  function get_sample_usage({ cpu_limit, cpu_weight, net_limit, net_weight }) {
+    const c = BigInt(1000000);
+
+    const cpu = parseInt(
+      (BigInt(cpu_limit.max) * c) / BigInt(cpu_weight) + BigInt(1)
+    );
+
+    const net = parseInt(
+      (BigInt(net_limit.max) * c) / BigInt(net_weight) + BigInt(1)
+    );
+
+    return { cpu, net };
+  }
+
+  function frac_by_us(cpu) {
+    const { weight } = power_up_state.cpu;
+    const n = Math.floor((us / cpu) * 1e6) / parseInt(weight);
+    return Math.floor(n * 1e15);
+  }
+
+  function frac_by_bytes(net) {
+    const { weight } = power_up_state.net;
+    return Math.floor((Math.floor((bytes / net) * 1e6) / weight) * 1e15);
+  }
+
+  const { cpu, net } = get_sample_usage(account_info);
+
+  return {
+    net_frac: frac_by_bytes(net),
+    cpu_frac: frac_by_us(cpu)
+  };
+}
+
+/**
+ * Return an approximate EOS amount for the fraction of bandwidth.
+ * @param {number} frac The bandwidth fraction required.
+ * @param {Object} bw Powerup state bandwidth.
+ * @returns {{Asset}} The EOS value for CPU and Network bandwidth fraction
+ */
+function calculate_price(frac, bw) {
+  let { utilization, weight, exponent, max_price, min_price } = bw;
+  min_price = parseFloat(min_price.replace(" EOS").split(".")[0]);
+  max_price = parseFloat(max_price.replace(" EOS").split(".")[0]);
+  exponent = parseFloat(exponent);
+  utilization = parseInt(utilization);
+  weight = parseInt(weight);
+
+  const determine_adjusted_utilization = () => {
+    const { decay_secs, utilization, utilization_timestamp } = bw;
+    let { adjusted_utilization } = bw;
+
+    if (parseInt(utilization) < parseInt(adjusted_utilization)) {
+      const now = Math.floor(new Date().getTime() / 1e3);
+      const diff = parseInt(adjusted_utilization) - parseInt(utilization);
+      let delta =
+        diff *
+        Math.exp(
+          -(now - parseInt(utilization_timestamp)) / parseInt(decay_secs)
+        );
+
+      delta = Math.min(Math.max(delta, 0), diff);
+      adjusted_utilization = parseInt(utilization) + delta;
+    }
+    return adjusted_utilization;
+  };
+
+  const utilization_increase = Math.ceil((frac * weight) / 1e15);
+  const adjusted_utilization = determine_adjusted_utilization(bw);
+
+  const price_function = (utilization) => {
+    let price = min_price;
+    const new_exponent = exponent - 1.0;
+    if (new_exponent <= 0.0) return max_price;
+    else
+      price +=
+        (max_price - min_price) * Math.pow(utilization / weight, new_exponent);
+
+    return price;
+  };
+
+  const price_integral_delta = (start_utilization, end_utilization) => {
+    const coefficient = (max_price - min_price) / exponent;
+    const start_u = start_utilization / weight;
+    const end_u = end_utilization / weight;
+    const delta =
+      min_price * end_u -
+      min_price * start_u +
+      coefficient * Math.pow(end_u, exponent) -
+      coefficient * Math.pow(start_u, exponent);
+    return delta;
+  };
+
+  let start_utilization = utilization;
+  const end_utilization = start_utilization + utilization_increase;
+  let fee = 0;
+
+  if (start_utilization < adjusted_utilization) {
+    fee +=
+      (price_function(adjusted_utilization) *
+        Math.min(
+          utilization_increase,
+          adjusted_utilization - start_utilization
+        )) /
+      weight;
+    start_utilization = adjusted_utilization;
+  }
+  if (start_utilization < end_utilization)
+    fee += price_integral_delta(start_utilization, end_utilization);
+
+  return fee;
+  // return Math.ceil(fee * 1e4) / 1e4
+}
+
+const eos_bandwidth_price = {
+  description: "`EOS` bandwidth powerup quote.",
+  type: new GraphQLObjectType({
+    name: "eos_bandwidth_price",
+    fields: {
+      cpu_frac: {
+        type: GraphQLString
+      },
+      net_frac: {
+        type: GraphQLString
+      },
+      cpu_estimate: {
+        type: GraphQLString
+      },
+      net_estimate: {
+        type: GraphQLString
+      }
+    }
+  }),
+  args: {
+    us: {
+      type: string_or_int,
+      description:
+        "Number of micro seconds of CPU bandwidth you want a quote for.",
+      defaultValue: 0
+    },
+    bytes: {
+      type: string_or_int,
+      description: "Number of bytes of network bandwidth you want a quote for.",
+      defaultValue: 0
+    }
+  },
+  async resolve(_, { us, bytes }, { network: { fetch, rpc_url } }) {
+    rpc_url = "https://jungle.relocke.io";
+
+    const get_sample_account = async () => {
+      const account_names = await fetch(rpc_url + "/v1/chain/get_table_rows", {
+        method: "post",
+        body: JSON.stringify({
+          code: "eosio",
+          table: "powup.order",
+          scope: "",
+          json: true
+        })
+      });
+
+      const { rows } = await account_names.json();
+
+      const request = await fetch(rpc_url + "/v1/chain/get_account", {
+        method: "post",
+        body: JSON.stringify({ account_name: rows[2].owner })
+      });
+
+      return request.json();
+    };
+
+    const get_powerup_state = fetch(rpc_url + "/v1/chain/get_table_rows", {
+      method: "post",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        code: "eosio",
+        table: "powup.state",
+        scope: "",
+        json: true
+      })
+    });
+
+    const [sample_account, get_powerup_state_req] = await Promise.all([
+      await get_sample_account(),
+      get_powerup_state
+    ]);
+
+    const power_up_state = await get_powerup_state_req.json();
+
+    let { cpu_frac, net_frac } = calculate_fraction(
+      us,
+      bytes,
+      power_up_state.rows[0],
+      sample_account
+    );
+
+    let cpu_estimate = Number(
+      calculate_price(cpu_frac, power_up_state.rows[0].cpu)
+    );
+    let net_estimate = Number(
+      calculate_price(net_frac, power_up_state.rows[0].net)
+    );
+
+    // handle the net and cpu estimates so that they are > minimum system token.
+    const MIN_TOKEN = Number(
+      power_up_state.rows[0].min_powerup_fee.replace(/[A-Z\s]+/gmu, "")
+    );
+    console.log(MIN_TOKEN);
+    // if (cpu_estimate < MIN_TOKEN) {
+    //   cpu_frac *= Math.floor(MIN_TOKEN / cpu_estimate);
+    //   cpu_estimate = Number(MIN_TOKEN) + cpu_estimate;
+    // }
+
+    // if (net_estimate < MIN_TOKEN) {
+    //   net_frac *= Math.floor(MIN_TOKEN / net_estimate);
+    //   net_estimate = MIN_TOKEN + net_estimate;
+    // }
+
+    return {
+      cpu_frac,
+      net_frac,
+      cpu_estimate,
+      net_estimate
+    };
+  }
+};
+
+export default eos_bandwidth_price;

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/serialize_abi.mjs

@@ -0,0 +1,284 @@
+import serialize from "eosio-wasm-js/serialize.mjs";
+
+import { eosio_abi_to_graphql_ast } from "../eosio_abi_to_graphql_ast.mjs";
+import Bytes from "../eosio_types/bytes_type.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);
+
+const serialize_abi = {
+  description:
+    "Serializes ABI to WASM hex code, this function is useful when you are using set ABI",
+  type: Bytes,
+  args: {
+    abi: {
+      type: Bytes,
+      description: "ABI to serialize as buffer",
+      defaultValue: 0
+    }
+  },
+  async resolve(_, { abi }) {
+    const JSON_ABI = JSON.parse(
+      abi
+        .match(/[a-z0-9]{2}/gmu)
+        .map((i) => String.fromCharCode(`0x${i}`))
+        .join("")
+    );
+
+    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;
+  }
+};
+
+export default serialize_abi;

package/blockchain_query_field.mjs

@@ -1,5 +1,6 @@
 import { GraphQLError, GraphQLObjectType } from "graphql";
 
+import eos_bandwidth_price from "./blockchain/bandwidth_quote.mjs";
 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";
@@ -10,7 +11,9 @@ 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_smart_contract from "./blockchain/get_smart_contract.mjs";
 import get_table from "./blockchain/get_table_by_scope.mjs";
+import serialize_abi from "./blockchain/serialize_abi.mjs";
 
 const blockchain_query_field = {
   type: new GraphQLObjectType({
@@ -21,13 +24,16 @@ const blockchain_query_field = {
       get_abi,
       get_accounts_by_authorizers,
       get_block,
+      get_smart_contract,
       get_currency_balance,
       get_currency_stats,
       get_info,
       get_producers,
       deserialize_action_data,
       get_table,
-      get_ram_price
+      get_ram_price,
+      eos_bandwidth_price,
+      serialize_abi
     }
   }),
   resolve(_, __, { network: { fetch, rpc_url } }) {

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/graphql_object_types/packed_transaction.mjs

@@ -16,11 +16,11 @@ const packed_transaction_type = new GraphQLObjectType({
   fields: {
     chain_id: {
       type: GraphQLString,
-      description: "A unique ID that Specifies which chain we are operating on."
+      description: "A unique ID that specifies which chain we are operating on."
     },
     transaction_header: {
       type: GraphQLString,
-      description: "Serialized transaction header _(TaPoS protection)_."
+      description: "Serialized transaction header."
     },
     transaction_body: {
       type: GraphQLString,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antelopeql",
-  "version": "2.0.0-rc.0",
+  "version": "2.0.0-rc.2",
   "description": "A GraphQL implementation for interacting with Antelope based blockchains.",
   "repository": "github:pur3miish/antelopeql",
   "bugs": "https://github.com/pur3miish/antelopeql/issues",
@@ -92,7 +92,7 @@
   },
   "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/push_transaction_rpc.mjs

@@ -18,9 +18,7 @@ export default async function push_transaction_rpc(
 ) {
   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({