koilib 5.6.0 → 5.7.0

package/lib/utilsNode.d.ts

@@ -269,6 +269,22 @@ export declare const ChainTypes: {
                         go_package: string;
                     };
                     nested: {
+                        object_space: {
+                            fields: {
+                                system: {
+                                    type: string;
+                                    id: number;
+                                };
+                                zone: {
+                                    type: string;
+                                    id: number;
+                                };
+                                id: {
+                                    type: string;
+                                    id: number;
+                                };
+                            };
+                        };
                         event_data: {
                             fields: {
                                 sequence: {
@@ -287,123 +303,7 @@ export declare const ChainTypes: {
                                     id: number;
                                 };
                                 data: {
-                                    type: string; /**
-                                     * Function to encode genesis data in order to launch a
-                                     * new blockchain. The different values are serialized using
-                                     * protobuffers. One of the arguments is the dictionary which
-                                     * contains the relevant information to perform the serialization.
-                                     * By default the function contains the dictionary for the
-                                     * following keys:
-                                     *
-                                     * - "object_key::head_block"
-                                     * - "object_key::chain_id"
-                                     * - "object_key::genesis_key"
-                                     * - "object_key::resource_limit_data"
-                                     * - "object_key::max_account_resources"
-                                     * - "object_key::protocol_descriptor"
-                                     * - "object_key::compute_bandwidth_registry"
-                                     * - "object_key::block_hash_code"
-                                     *
-                                     * @param genesisDataDecoded - Genesis data where the values are
-                                     * objects.
-                                     * @param dictionary - Set of keys which contains the relevant
-                                     * information to perform the serialization
-                                     *
-                                     * @example
-                                     *
-                                     * ```ts
-                                     * const signer = Signer.fromSeed("seed");
-                                     * const genesisDataDecoded = {
-                                     *   entries: [
-                                     *     {
-                                     *       space: { system: true },
-                                     *       alias: "object_key::genesis_key",
-                                     *       value: signer.address,
-                                     *     },
-                                     *   ],
-                                     * };
-                                     *
-                                     * const genesisData = await encodeGenesisData(genesisDataDecoded);
-                                     * console.log(genesisData);
-                                     *
-                                     * // {
-                                     * //   entries: [
-                                     * //     {
-                                     * //       space: { system: true },
-                                     * //       key: "EiC3nO+XbeKg4C8ugW7M7XdfmJKY4i3l91KoJWxosQPImA==",
-                                     * //       value: "AMpASH7CjUHBpl2QR8E5lGKVjVLAvJRg5g==",
-                                     * //     },
-                                     * //   ],
-                                     * // }
-                                     * ```
-                                     *
-                                     * @example adding a custom dictionary
-                                     *
-                                     * ```ts
-                                     * const contractId = Signer.fromSeed("seed").address;
-                                     * const zone = encodeBase64(decodeBase58(contractId));
-                                     * const genesisDataDecoded = {
-                                     *   entries: [
-                                     *     {
-                                     *       space: { system: true, zone, id: 1 },
-                                     *       key: "difficulty_metadata_key",
-                                     *       value: {
-                                     *         target: encodeBase64url(toUint8Array("F".repeat(64))),
-                                     *         last_block_time: "1641038400000",
-                                     *         difficulty: encodeBase64url(toUint8Array("1".repeat(64))),
-                                     *         target_block_interval: "10",
-                                     *       },
-                                     *     },
-                                     *   ],
-                                     * };
-                                     *
-                                     * const powJson = {
-                                     *   nested: {
-                                     *     mypackage: {
-                                     *       nested: {
-                                     *         difficulty_metadata: {
-                                     *           "fields": {
-                                     *             "target": { "type": "bytes", "id": 1 },
-                                     *             "last_block_time": { "type": "uint64", "id": 2,
-                                     *               "options": { "jstype": "JS_STRING" }
-                                     *             },
-                                     *             "difficulty": { "type": "bytes", "id": 3 },
-                                     *             "target_block_interval": { "type": "uint64", "id": 4,
-                                     *                "options": { "jstype": "JS_STRING" }
-                                     *             }
-                                     *           }
-                                     *         },
-                                     *       }
-                                     *     }
-                                     *   }
-                                     * }
-                                     *
-                                     * const dic = {
-                                     *   difficulty_metadata_key: {
-                                     *     serializer: new Serializer(powJson),
-                                     *     typeName: "difficulty_metadata",
-                                     *   },
-                                     * };
-                                     *
-                                     * const genesisData = await encodeGenesisData(genesisDataDecoded, dic);
-                                     * console.log(genesisData);
-                                     *
-                                     * // {
-                                     * //   entries: [
-                                     * //     {
-                                     * //       key: "difficulty_metadata_key",
-                                     * //       space: {
-                                     * //         id: 1,
-                                     * //         system: true,
-                                     * //         zone: "AMpASH7CjUHBpl2QR8E5lGKVjVLAvJRg5g==",
-                                     * //       },
-                                     * //       value:
-                                     * //         "CiD//////////////////////////////////////////xCAlIus4S8aIBERERERERERERERERERERERERERERERERERERERERERIAo=",
-                                     * //     },
-                                     * //   ],
-                                     * // };
-                                     * ```
-                                     */
+                                    type: string;
                                     id: number;
                                 };
                                 impacted: {
@@ -684,6 +584,11 @@ export declare const ChainTypes: {
                                     type: string;
                                     id: number;
                                 };
+                                state_delta_entries: {
+                                    rule: string;
+                                    type: string;
+                                    id: number;
+                                };
                             };
                         };
                         block_header: {
@@ -814,6 +719,56 @@ export declare const ChainTypes: {
                                     type: string;
                                     id: number;
                                 };
+                                disk_storage_charged: {
+                                    type: string;
+                                    id: number;
+                                    options: {
+                                        jstype: string;
+                                    };
+                                };
+                                network_bandwidth_charged: {
+                                    type: string;
+                                    id: number;
+                                    options: {
+                                        jstype: string;
+                                    };
+                                };
+                                compute_bandwidth_charged: {
+                                    type: string;
+                                    id: number;
+                                    options: {
+                                        jstype: string;
+                                    };
+                                };
+                                state_delta_entries: {
+                                    rule: string;
+                                    type: string;
+                                    id: number;
+                                };
+                            };
+                        };
+                        state_delta_entry: {
+                            oneofs: {
+                                _value: {
+                                    oneof: string[];
+                                };
+                            };
+                            fields: {
+                                object_space: {
+                                    type: string;
+                                    id: number;
+                                };
+                                key: {
+                                    type: string;
+                                    id: number;
+                                };
+                                value: {
+                                    type: string;
+                                    id: number;
+                                    options: {
+                                        proto3_optional: boolean;
+                                    };
+                                };
                             };
                         };
                     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koilib",
-  "version": "5.6.0",
+  "version": "5.7.0",
   "description": "JS Koinos Library",
   "author": "Julian Gonzalez",
   "repository": {
@@ -45,12 +45,12 @@
     ".": "./lib/index.js"
   },
   "dependencies": {
-    "@noble/hashes": "^1.1.2",
-    "@noble/secp256k1": "^1.6.3",
+    "@noble/hashes": "^1.3.1",
+    "@noble/secp256k1": "^1.7.1",
     "@roamin/koinos-pb-to-proto": "^0.0.3",
     "cross-fetch": "^3.1.5",
     "multibase": "^4.0.6",
-    "protobufjs": "^7.0.0"
+    "protobufjs": "^7.2.4"
   },
   "devDependencies": {
     "@tsconfig/node12": "^1.0.11",
@@ -81,7 +81,7 @@
     "ts-node": "^10.9.1",
     "typedoc": "^0.23.10",
     "typescript": "^4.7.4",
-    "webpack": "^5.74.0",
-    "webpack-cli": "^4.10.0"
+    "webpack": "^5.88.2",
+    "webpack-cli": "^5.1.4"
   }
 }

package/src/Contract.ts

@@ -1,5 +1,5 @@
 /* eslint-disable no-await-in-loop */
-import { Signer, SignerInterface } from "./Signer";
+import { SignerInterface } from "./Signer";
 import { Provider } from "./Provider";
 import { Serializer } from "./Serializer";
 import {
@@ -158,7 +158,7 @@ export class Contract {
     abi?: Abi;
     bytecode?: Uint8Array;
     options?: CallContractOptions;
-    signer?: Signer;
+    signer?: SignerInterface;
     provider?: Provider;
     /**
      * Set this option if you can not use _eval_ functions
@@ -256,7 +256,6 @@ export class Contract {
         result?: T;
         receipt?: TransactionReceipt;
       }> => {
-        if (!this.provider) throw new Error("provider not found");
         if (!this.abi || !this.abi.methods)
           throw new Error("Methods are not defined");
         if (!this.abi.methods[name])
@@ -286,6 +285,8 @@ export class Contract {
           return { operation };
         }
 
+        if (!this.provider) throw new Error("provider not found");
+
         if (readOnly) {
           if (!output) throw new Error(`No output defined for ${name}`);
           // read contract
@@ -481,7 +482,7 @@ export class Contract {
    * @returns Operation encoded
    * @example
    * ```ts
-   * const opEncoded = contract.encodeOperation({
+   * const opEncoded = await contract.encodeOperation({
    *   name: "transfer",
    *   args: {
    *     from: "12fN2CQnuJM8cMnWZ1hPtM4knjLME8E4PD",
@@ -529,7 +530,7 @@ export class Contract {
    * Decodes a contract operation to be human readable
    * @example
    * ```ts
-   * const opDecoded = contract.decodeOperation({
+   * const opDecoded = await contract.decodeOperation({
    *   call_contract: {
    *     contract_id: "19JntSm8pSNETT9aHTwAUHC5RMoaSmgZPJ",
    *     entry_point: 0x27f576ca,

package/src/Provider.ts

@@ -5,11 +5,13 @@ import {
   CallContractOperationJson,
   TransactionReceipt,
   TransactionJsonWait,
+  BlockTopology,
 } from "./interface";
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import { koinos } from "./protoModules/protocol-proto.js";
 import { decodeBase64url, encodeBase64url } from "./utils";
+import { Serializer } from "./Serializer";
 
 /* eslint-disable @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access */
 
@@ -32,10 +34,7 @@ export class Provider {
    *
    * @example
    * ```ts
-   * const provider = new Provider([
-   *   "http://45.56.104.152:8080",
-   *   "http://159.203.119.0:8080"
-   * ]);
+   * const provider = new Provider(["https://api.koinos.io"]);
    *
    * provider.onError = (error, node, newNode) => {
    *   console.log(`Error from node ${node}: ${error.message}`);
@@ -219,7 +218,13 @@ export class Provider {
     });
   }
 
-  async getBlocksById(blockIds: string[]): Promise<{
+  async getBlocksById(
+    blockIds: string[],
+    opts?: {
+      returnBlock: boolean;
+      returnReceipt: boolean;
+    }
+  ): Promise<{
     block_items: {
       block_id: string;
       block_height: string;
@@ -228,8 +233,10 @@ export class Provider {
   }> {
     return this.call("block_store.get_blocks_by_id", {
       block_ids: blockIds,
-      return_block: true,
-      return_receipt: false,
+      return_block:
+        opts && opts.returnBlock !== undefined ? opts.returnBlock : true,
+      return_receipt:
+        opts && opts.returnReceipt !== undefined ? opts.returnReceipt : false,
     });
   }
 
@@ -238,21 +245,13 @@ export class Provider {
    */
   async getHeadInfo(): Promise<{
     head_block_time: string;
-    head_topology: {
-      id: string;
-      height: string;
-      previous: string;
-    };
+    head_topology: BlockTopology;
     head_state_merkle_root: string;
     last_irreversible_block: string;
   }> {
     return this.call<{
       head_block_time: string;
-      head_topology: {
-        id: string;
-        height: string;
-        previous: string;
-      };
+      head_topology: BlockTopology;
       head_state_merkle_root: string;
       last_irreversible_block: string;
     }>("chain.get_head_info", {});
@@ -280,7 +279,11 @@ export class Provider {
   async getBlocks(
     height: number,
     numBlocks = 1,
-    idRef?: string
+    idRef?: string,
+    opts?: {
+      returnBlock: boolean;
+      returnReceipt: boolean;
+    }
   ): Promise<
     {
       block_id: string;
@@ -310,8 +313,10 @@ export class Provider {
         head_block_id: blockIdRef,
         ancestor_start_height: height,
         num_blocks: numBlocks,
-        return_block: true,
-        return_receipt: false,
+        return_block:
+          opts && opts.returnBlock !== undefined ? opts.returnBlock : true,
+        return_receipt:
+          opts && opts.returnReceipt !== undefined ? opts.returnReceipt : false,
       })
     ).block_items;
   }
@@ -507,6 +512,131 @@ export class Provider {
   }> {
     return this.call("chain.read_contract", operation);
   }
+
+  /**
+   * Function to call "chain.get_fork_heads" to get fork heads
+   */
+  async getForkHeads(): Promise<{
+    last_irreversible_block: BlockTopology;
+    fork_heads: BlockTopology[];
+  }> {
+    return this.call("chain.get_fork_heads", {});
+  }
+
+  /**
+   * Funciont to call "chain.get_resource_limits" to get
+   * resource limits
+   */
+  async getResourceLimits(): Promise<{
+    resource_limit_data: {
+      disk_storage_limit: string;
+      disk_storage_cost: string;
+      network_bandwidth_limit: string;
+      network_bandwidth_cost: string;
+      compute_bandwidth_limit: string;
+      compute_bandwidth_cost: string;
+    };
+  }> {
+    return this.call("chain.get_resource_limits", {});
+  }
+
+  /**
+   * Function to call "chain.invoke_system_call" to invoke a system
+   * call.
+   */
+  async invokeSystemCall<T = Record<string, unknown>>(
+    serializer: Serializer,
+    nameOrId: string | number,
+    args: Record<string, unknown>,
+    callerData?: { caller: string; caller_privilege: number }
+  ): Promise<T> {
+    if (!serializer.argumentsTypeName)
+      throw new Error("argumentsTypeName not defined");
+    if (!serializer.returnTypeName)
+      throw new Error("returnTypeName not defined");
+    const argsEncoded = await serializer.serialize(
+      args,
+      serializer.argumentsTypeName
+    );
+    const response = await this.call<{ value: string }>(
+      "chain.invoke_system_call",
+      {
+        ...(typeof nameOrId === "number" && { id: nameOrId }),
+        ...(typeof nameOrId === "string" && { name: nameOrId }),
+        args: encodeBase64url(argsEncoded),
+        caller_data: callerData,
+      }
+    );
+    if (!response || !response.value)
+      throw new Error("no value in the response");
+    const result = await serializer.deserialize(
+      response.value,
+      serializer.returnTypeName
+    );
+    return result as T;
+  }
+
+  async invokeGetContractMetadata(contractId: string) {
+    const serializer = new Serializer(
+      {
+        nested: {
+          get_contract_metadata_arguments: {
+            fields: {
+              contract_id: {
+                type: "bytes",
+                id: 1,
+                options: {
+                  "(koinos.btype)": "CONTRACT_ID",
+                },
+              },
+            },
+          },
+          get_contract_metadata_result: {
+            fields: {
+              value: {
+                type: "contract_metadata_object",
+                id: 1,
+              },
+            },
+          },
+          contract_metadata_object: {
+            fields: {
+              hash: {
+                type: "bytes",
+                id: 1,
+                options: {
+                  "(koinos.btype)": "HEX",
+                },
+              },
+              system: {
+                type: "bool",
+                id: 2,
+              },
+              authorizes_call_contract: {
+                type: "bool",
+                id: 3,
+              },
+              authorizes_transaction_application: {
+                type: "bool",
+                id: 4,
+              },
+              authorizes_upload_contract: {
+                type: "bool",
+                id: 5,
+              },
+            },
+          },
+        },
+      },
+      {
+        argumentsTypeName: "get_contract_metadata_arguments",
+        returnTypeName: "get_contract_metadata_result",
+      }
+    );
+    return this.invokeSystemCall(serializer, "get_contract_metadata", {
+      contract_id: contractId,
+    });
+  }
 }
 
 export default Provider;

package/src/Serializer.ts

@@ -103,6 +103,18 @@ export class Serializer {
    */
   defaultType?: Type;
 
+  /**
+   * Type name for arguments when using
+   * [[Provider.invokeSystemCall]]
+   */
+  argumentsTypeName?: string;
+
+  /**
+   * Type name for the output when using
+   * [[Provider.invokeSystemCall]]
+   */
+  returnTypeName?: string;
+
   /**
    * Preformat bytes for base64url, base58 or hex string
    */
@@ -126,6 +138,18 @@ export class Serializer {
        */
       defaultTypeName?: string;
 
+      /**
+       * Type name for arguments when using
+       * [[Provider.invokeSystemCall]]
+       */
+      argumentsTypeName?: string;
+
+      /**
+       * Type name for the output when using
+       * [[Provider.invokeSystemCall]]
+       */
+      returnTypeName?: string;
+
       /**
        * Bytes conversion. Option to preformat bytes
        * when "(koinos_bytes_type)" is defined in the type
@@ -146,6 +170,9 @@ export class Serializer {
     }
     if (opts?.defaultTypeName)
       this.defaultType = this.root.lookupType(opts.defaultTypeName);
+    if (opts?.argumentsTypeName)
+      this.argumentsTypeName = opts.argumentsTypeName;
+    if (opts?.returnTypeName) this.returnTypeName = opts.returnTypeName;
     if (opts && typeof opts.bytesConversion !== "undefined")
       this.bytesConversion = opts.bytesConversion;
   }