antelopeql 2.0.0-rc.2 → 2.0.0-rc.21

package/{push_transaction.mjs → send_transaction.mjs}

@@ -4,9 +4,9 @@ import sha256 from "universal-sha256-js/sha256.mjs";
 import configuration_type from "./graphql_input_types/configuration.mjs";
 import transaction_receipt from "./graphql_object_types/transaction_receipt.mjs";
 import mutation_resolver from "./mutation_resolver.mjs";
-import push_transaction_rpc from "./push_transaction_rpc.mjs";
+import send_transaction_rpc from "./send_transaction_rpc.mjs";
 
-const push_transaction = (actions, ast_list) => ({
+const send_transaction = (actions, ast_list) => ({
   description:
     "Serialize a list of actions and push them to the blockchain in one step, requires private keys to be supplied to AntelopeQL.",
   type: new GraphQLNonNull(transaction_receipt),
@@ -18,11 +18,17 @@ const push_transaction = (actions, ast_list) => ({
       type: configuration_type
     }
   },
-  async resolve(_, args, { network, signTransaction }) {
+  async resolve(root, args, getContext, info) {
+    const { network, signTransaction } = getContext(root, args, info);
+
     const { chain_id, transaction_header, transaction_body, transaction } =
       await mutation_resolver(args, network, ast_list);
 
-    const transaction_bytes = chain_id + transaction_header + transaction_body;
+    const transaction_bytes =
+      chain_id +
+      transaction_header +
+      transaction_body +
+      "0000000000000000000000000000000000000000000000000000000000000000";
 
     const hash_to_sign = await sha256(
       Uint8Array.from(
@@ -41,11 +47,11 @@ const push_transaction = (actions, ast_list) => ({
       transaction
     });
 
-    return push_transaction_rpc(
+    return send_transaction_rpc(
       { transaction_body, transaction_header, signatures },
       network
     );
   }
 });
 
-export default push_transaction;
+export default send_transaction;

package/{push_transaction_rpc.mjs → send_transaction_rpc.mjs}

@@ -1,7 +1,7 @@
 import { GraphQLError } from "graphql";
 
 /**
- * Pushes a serialized transaction to the blockchain.
+ * Send a serialized transaction to the blockchain.
  * @param {Object} root Argument
  * @param {String} root.transaction_header Serialized transaction header.
  * @param {String} root.transaction_body Serialized transaction body.
@@ -12,7 +12,7 @@ import { GraphQLError } from "graphql";
  * @param {Object} network.headers transaction headers.
  *
  */
-export default async function push_transaction_rpc(
+export default async function send_transaction_rpc(
   { transaction_header, transaction_body, signatures },
   network
 ) {

package/{blockchain/serialize_abi.mjs → serialize_abi.mjs}

@@ -1,7 +1,6 @@
 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";
+import { eosio_abi_to_graphql_ast } from "./eosio_abi_to_graphql_ast.mjs";
 
 const ABI = {
   version: "eosio::abi/1.1",
@@ -196,89 +195,79 @@ const ABI = {
     }
   ]
 };
+
 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
+/**
+ * Given a Smart contract convert the ABI to serialized byte code representation.
+ * @param {Object} abi JS Object of the Antelope ABI for a given smart contract.
+ * @returns {String} serialized Byte code representation of the ABI.
+ */
+export default async function serialize_abi(abi) {
+  let JSON_ABI = abi;
+
+  ABI.structs[9].fields.forEach(({ name }) => {
+    if (JSON_ABI[name] == undefined) {
+      JSON_ABI[name] = [];
     }
-  },
-  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 = [];
+  const build_serialize_list = async (data, instructions) => {
+    const serialize_list = [];
 
-      for (const instruction of instructions) {
-        const { $info, name, type } = instruction;
-        const datum = data[name];
+    for (const instruction of instructions) {
+      const { $info, name, type } = instruction;
+      const datum = data[name];
 
-        const next_instruction = AST[type];
+      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.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.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.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.
+      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;
-    };
+      // 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.
+    }
 
-    const ser_list = await build_serialize_list(JSON_ABI, AST.abi_def);
+    return serialize_list;
+  };
 
-    let hex_string = "";
-    ser_list.forEach(
-      ({ type, value }) => (hex_string += serialize[type](value))
-    );
+  const ser_list = await build_serialize_list(JSON_ABI, AST.abi_def);
 
-    return hex_string;
-  }
-};
+  let hex_string = "";
+  ser_list.forEach(({ type, value }) => (hex_string += serialize[type](value)));
 
-export default serialize_abi;
+  return hex_string;
+}

package/serialize_transaction.mjs

@@ -1,5 +1,6 @@
-import { GraphQLNonNull } from "graphql";
+import { GraphQLList, GraphQLNonNull } from "graphql";
 
+import public_key_type from "./eosio_types/public_key_type.mjs";
 import configuration_type from "./graphql_input_types/configuration.mjs";
 import packed_transaction_type from "./graphql_object_types/packed_transaction.mjs";
 import mutation_resolver from "./mutation_resolver.mjs";
@@ -13,10 +14,21 @@ const serialize_transaction = (actions, ast_list) => ({
     },
     configuration: {
       type: configuration_type
+    },
+    available_keys: {
+      type: new GraphQLList(public_key_type)
     }
   },
-  resolve(_, args, { network }) {
-    return mutation_resolver(args, network, ast_list);
+  async resolve(root, { available_keys, ...args }, getContext, info) {
+    const { network } = getContext(root, { available_keys, ...args }, info);
+
+    const { transaction, ...serialized_txn } = await mutation_resolver(
+      args,
+      network,
+      ast_list
+    );
+
+    return { ...serialized_txn, available_keys, transaction };
   }
 });
 

package/blockchain/bandwidth_quote.mjs

@@ -1,244 +0,0 @@
-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;