koilib 2.1.0 → 2.4.1

package/dist/koinos.min.js.LICENSE.txt

@@ -1,14 +1,5 @@
 /*! koilib - MIT License (c) Julian Gonzalez (joticajulian@gmail.com) */
 
-/*! noble-ripemd160 - MIT License (c) Paul Miller (paulmillr.com) */
+/*! noble-hashes - MIT License (c) 2021 Paul Miller (paulmillr.com) */
 
 /*! noble-secp256k1 - MIT License (c) Paul Miller (paulmillr.com) */
-
-/**
- * [js-sha256]{@link https://github.com/emn178/js-sha256}
- *
- * @version 0.9.0
- * @author Chen, Yi-Cyuan [emn178@gmail.com]
- * @copyright Chen, Yi-Cyuan 2014-2017
- * @license MIT
- */

package/lib/Contract.d.ts

@@ -1,120 +1,7 @@
-import { Root, INamespace } from "protobufjs/light";
 import { Signer, SignerInterface } from "./Signer";
-import { Provider, SendTransactionResponse } from "./Provider";
-import { CallContractOperationNested, UploadContractOperationNested, TransactionJson } from "./interface";
-/**
- * Application Binary Interface (ABI)
- *
- * ABIs are composed of 2 elements: methods and types.
- * - The methods define the names of the entries of the smart contract,
- * the corresponding endpoints and the name of the types used.
- * - The types all the description to serialize and deserialize
- * using proto buffers.
- *
- * To generate the types is necessary to use the dependency
- * protobufjs. The following example shows how to generate the
- * protobuf descriptor from a .proto file.
- *
- * ```js
- * const fs = require("fs");
- * const pbjs = require("protobufjs/cli/pbjs");
- *
- * pbjs.main(
- *   ["--target", "json", "./token.proto"],
- *   (err, output) => {
- *     if (err) throw err;
- *     fs.writeFileSync("./token-proto.json", output);
- *   }
- * );
- * ```
- *
- * Then this descriptor can be loaded to define the ABI:
- * ```js
- * const tokenJson = require("./token-proto.json");
- * const abiToken = {
- *   methods: {
- *     balanceOf: {
- *       entryPoint: 0x15619248,
- *       inputs: "balance_of_arguments",
- *       outputs: "balance_of_result",
- *       readOnly: true,
- *       defaultOutput: { value: "0" },
- *     },
- *     transfer: {
- *       entryPoint: 0x62efa292,
- *       inputs: "transfer_arguments",
- *       outputs: "transfer_result",
- *     },
- *     mint: {
- *       entryPoint: 0xc2f82bdc,
- *       inputs: "mint_argumnets",
- *       outputs: "mint_result",
- *     },
- *   },
- *   types: tokenJson,
- * };
- * ```
- *
- * Note that this example uses "defaultOutput" for the method
- * "balanceOf". This is used when the smart contract returns an
- * empty response (for instance when there are no balance records
- * for a specific address) and you require a default output in
- * such cases.
- */
-export interface Abi {
-    methods: {
-        /** Name of the method */
-        [x: string]: {
-            /** Entry point ID */
-            entryPoint: number;
-            /** Protobuffer type for input */
-            inputs?: string;
-            /** Protobuffer type for output */
-            outputs?: string;
-            /** Boolean to differentiate write methods
-             * (using transactions) from read methods
-             * (query the contract)
-             */
-            readOnly?: boolean;
-            /** Default value when the output is undefined */
-            defaultOutput?: unknown;
-            /** Description of the method */
-            description?: string;
-        };
-    };
-    /**
-     * Protobuffers descriptor in JSON format.
-     * See https://www.npmjs.com/package/protobufjs#using-json-descriptors
-     */
-    types: INamespace;
-}
-/**
- * Human readable format operation
- *
- * @example
- * ```ts
- * const opDecoded = {
- *   name: "transfer",
- *   args: {
- *     from: "1Krs7v1rtpgRyfwEZncuKMQQnY5JhqXVSx",
- *     to: "1BqtgWBcqm9cSZ97avLGZGJdgso7wx6pCA",
- *     value: 1000,
- *   },
- * };
- * ```
- */
-export interface DecodedOperationJson {
-    /** Operation name */
-    name: string;
-    /** Arguments decoded. See [[Abi]] */
-    args?: Record<string, unknown>;
-}
-export interface TransactionOptions {
-    rcLimit?: number | bigint | string;
-    nonce?: number;
-    sendTransaction?: boolean;
-    sendAbis?: boolean;
-}
+import { Provider } from "./Provider";
+import { Serializer } from "./Serializer";
+import { CallContractOperationNested, UploadContractOperationNested, TransactionJson, Abi, TransactionOptions, DecodedOperationJson, SendTransactionResponse } from "./interface";
 /**
  * The contract class contains the contract ID and contract entries
  * definition needed to encode/decode operations during the
@@ -125,9 +12,9 @@ export interface TransactionOptions {
  * ```ts
  * const { Contract, Provider, Signer, utils } = require("koilib");
  * const rpcNodes = ["http://api.koinos.io:8080"];
- * const privateKeyHex = "f186a5de49797bfd52dc42505c33d75a46822ed5b60046e09d7c336242e20200";
+ * const privateKey = "f186a5de49797bfd52dc42505c33d75a46822ed5b60046e09d7c336242e20200";
  * const provider = new Provider(rpcNodes);
- * const signer = new Signer(privateKeyHex, true, provider);
+ * const signer = new Signer({ privateKey, provider });
  * const koinContract = new Contract({
  *   id: "19JntSm8pSNETT9aHTwAUHC5RMoaSmgZPJ",
  *   abi: utils.Krc20Abi,
@@ -136,18 +23,26 @@ export interface TransactionOptions {
  * });
  * const koin = koinContract.functions;
  *
+ * // optional: preformat input/output
+ * koinContract.abi.methods.balanceOf.preformatInput = (owner) =>
+ *   ({ owner });
+ * koinContract.abi.methods.balanceOf.preformatOutput = (res) =>
+ *   utils.formatUnits(res.value, 8);
+ * koinContract.abi.methods.transfer.preformatInput = (input) => ({
+ *   from: signer.getAddress(),
+ *   to: input.to,
+ *   value: utils.parseUnits(input.value, 8),
+ * });
+ *
  * async funtion main() {
  *   // Get balance
- *   const { result } = await koin.balanceOf({
- *     owner: "12fN2CQnuJM8cMnWZ1hPtM4knjLME8E4PD"
- *   });
- *   console.log(balance.result)
+ *   const { result } = await koin.balanceOf("12fN2CQnuJM8cMnWZ1hPtM4knjLME8E4PD");
+ *   console.log(result)
  *
  *   // Transfer
  *   const { transaction, transactionResponse } = await koin.transfer({
- *     from: "12fN2CQnuJM8cMnWZ1hPtM4knjLME8E4PD",
  *     to: "172AB1FgCsYrRAW5cwQ8KjadgxofvgPFd6",
- *     value: "1000",
+ *     value: "10.0001",
  *   });
  *   console.log(`Transaction id ${transaction.id} submitted`);
  *
@@ -164,17 +59,19 @@ export declare class Contract {
      * Contract ID
      */
     id?: Uint8Array;
-    /**
-     * Protobuffer definitions
-     */
-    protobuffers?: Root;
     /**
      * Set of functions to interact with the smart
      * contract. These functions are automatically generated
      * in the constructor of the class
+     *
+     * @example
+     * ```ts
+     * const owner = "1Gvqdo9if6v6tFomEuTuMWP1D7H7U9yksb";
+     * await koinContract.functions.balanceOf({ owner });
+     * ```
      */
     functions: {
-        [x: string]: <T = Record<string, unknown>>(args?: Record<string, unknown>, opts?: TransactionOptions) => Promise<{
+        [x: string]: <T = Record<string, unknown>>(args?: unknown, opts?: TransactionOptions) => Promise<{
             operation: CallContractOperationNested;
             transaction?: TransactionJson;
             transactionResponse?: SendTransactionResponse;
@@ -193,13 +90,17 @@ export declare class Contract {
      * Provider to connect with the blockchain
      */
     provider?: Provider;
+    /**
+     * Serializer to serialize/deserialize data types
+     */
+    serializer?: Serializer;
     /**
      * Bytecode. Needed to deploy the smart contract.
      */
     bytecode?: Uint8Array;
     /**
      * Options to apply when creating transactions.
-     * By default it set rcLimit to 1e8, sendTransaction true,
+     * By default it set rc_limit to 1e8, sendTransaction true,
      * sendAbis true, and nonce undefined (to get it from the blockchain)
      */
     options: TransactionOptions;
@@ -210,6 +111,13 @@ export declare class Contract {
         options?: TransactionOptions;
         signer?: Signer;
         provider?: Provider;
+        /**
+         * Set this option if you can not use _eval_ functions
+         * in the current environment. In such cases, the
+         * serializer must come from an environment where it
+         * is able to use those functions.
+         */
+        serializer?: Serializer;
     });
     /**
      * Compute contract Id
@@ -224,8 +132,9 @@ export declare class Contract {
      * The Bytecode must be defined in the constructor of the class
      * @example
      * ```ts
-     * const signer = new Signer("f186a5de49797bfd52dc42505c33d75a46822ed5b60046e09d7c336242e20200", true, provider);
+     * const privateKey = "f186a5de49797bfd52dc42505c33d75a46822ed5b60046e09d7c336242e20200";
      * const provider = new Provider(["http://api.koinos.io:8080"]);
+     * const signer = new Signer({ privateKey, provider });
      * const bytecode = new Uint8Array([1, 2, 3, 4]);
      * const contract = new Contract({ signer, provider, bytecode });
      * const { transactionResponse } = await contract.deploy();
@@ -257,23 +166,23 @@ export declare class Contract {
      *
      * console.log(opEncoded);
      * // {
-     * //   callContract: {
-     * //     contractId: "19JntSm8pSNETT9aHTwAUHC5RMoaSmgZPJ",
-     * //     entryPoint: 0x62efa292,
+     * //   call_contract: {
+     * //     contract_id: "19JntSm8pSNETT9aHTwAUHC5RMoaSmgZPJ",
+     * //     entry_point: 0x62efa292,
      * //     args: "MBWFsaWNlA2JvYgAAAAAAAAPo",
      * //   }
      * // }
      * ```
      */
-    encodeOperation(op: DecodedOperationJson): CallContractOperationNested;
+    encodeOperation(op: DecodedOperationJson): Promise<CallContractOperationNested>;
     /**
      * Decodes a contract operation to be human readable
      * @example
      * ```ts
      * const opDecoded = contract.decodeOperation({
-     *   callContract: {
-     *     contractId: "19JntSm8pSNETT9aHTwAUHC5RMoaSmgZPJ",
-     *     entryPoint: 0x62efa292,
+     *   call_contract: {
+     *     contract_id: "19JntSm8pSNETT9aHTwAUHC5RMoaSmgZPJ",
+     *     entry_point: 0x62efa292,
      *     args: "MBWFsaWNlA2JvYgAAAAAAAAPo",
      *   }
      * });
@@ -288,16 +197,6 @@ export declare class Contract {
      * // }
      * ```
      */
-    decodeOperation(op: CallContractOperationNested): DecodedOperationJson;
-    /**
-     * Function to encode a type using the protobuffer definitions
-     * It also prepares the bytes for special cases (base58, hex string)
-     */
-    encodeType(valueDecoded: Record<string, unknown>, typeName: string): Uint8Array;
-    /**
-     * Function to decode bytes using the protobuffer definitions
-     * It also encodes the bytes for special cases (base58, hex string)
-     */
-    decodeType<T = Record<string, unknown>>(valueEncoded: string | Uint8Array, typeName: string): T;
+    decodeOperation(op: CallContractOperationNested): Promise<DecodedOperationJson>;
 }
 export default Contract;

package/lib/Contract.js

@@ -1,24 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Contract = void 0;
-const light_1 = require("protobufjs/light");
+const Serializer_1 = require("./Serializer");
 const utils_1 = require("./utils");
-const OP_BYTES = "(koinos_bytes_type)";
-/**
- * Makes a copy of a value. The returned value can be modified
- * without altering the original one. Although this is not needed
- * for strings or numbers and only needed for objects and arrays,
- * all these options are covered in a single function
- *
- * It is assumed that the argument is number, string, or contructions
- * of these types inside objects or arrays.
- */
-function copyValue(value) {
-    if (typeof value === "string" || typeof value === "number") {
-        return value;
-    }
-    return JSON.parse(JSON.stringify(value));
-}
 /**
  * The contract class contains the contract ID and contract entries
  * definition needed to encode/decode operations during the
@@ -29,9 +13,9 @@ function copyValue(value) {
  * ```ts
  * const { Contract, Provider, Signer, utils } = require("koilib");
  * const rpcNodes = ["http://api.koinos.io:8080"];
- * const privateKeyHex = "f186a5de49797bfd52dc42505c33d75a46822ed5b60046e09d7c336242e20200";
+ * const privateKey = "f186a5de49797bfd52dc42505c33d75a46822ed5b60046e09d7c336242e20200";
  * const provider = new Provider(rpcNodes);
- * const signer = new Signer(privateKeyHex, true, provider);
+ * const signer = new Signer({ privateKey, provider });
  * const koinContract = new Contract({
  *   id: "19JntSm8pSNETT9aHTwAUHC5RMoaSmgZPJ",
  *   abi: utils.Krc20Abi,
@@ -40,18 +24,26 @@ function copyValue(value) {
  * });
  * const koin = koinContract.functions;
  *
+ * // optional: preformat input/output
+ * koinContract.abi.methods.balanceOf.preformatInput = (owner) =>
+ *   ({ owner });
+ * koinContract.abi.methods.balanceOf.preformatOutput = (res) =>
+ *   utils.formatUnits(res.value, 8);
+ * koinContract.abi.methods.transfer.preformatInput = (input) => ({
+ *   from: signer.getAddress(),
+ *   to: input.to,
+ *   value: utils.parseUnits(input.value, 8),
+ * });
+ *
  * async funtion main() {
  *   // Get balance
- *   const { result } = await koin.balanceOf({
- *     owner: "12fN2CQnuJM8cMnWZ1hPtM4knjLME8E4PD"
- *   });
- *   console.log(balance.result)
+ *   const { result } = await koin.balanceOf("12fN2CQnuJM8cMnWZ1hPtM4knjLME8E4PD");
+ *   console.log(result)
  *
  *   // Transfer
  *   const { transaction, transactionResponse } = await koin.transfer({
- *     from: "12fN2CQnuJM8cMnWZ1hPtM4knjLME8E4PD",
  *     to: "172AB1FgCsYrRAW5cwQ8KjadgxofvgPFd6",
- *     value: "1000",
+ *     value: "10.0001",
  *   });
  *   console.log(`Transaction id ${transaction.id} submitted`);
  *
@@ -65,46 +57,67 @@ function copyValue(value) {
  */
 class Contract {
     constructor(c) {
-        var _a, _b;
+        var _a;
         if (c.id)
             this.id = utils_1.decodeBase58(c.id);
         this.signer = c.signer;
         this.provider = c.provider || ((_a = c.signer) === null || _a === void 0 ? void 0 : _a.provider);
         this.abi = c.abi;
         this.bytecode = c.bytecode;
-        if ((_b = c.abi) === null || _b === void 0 ? void 0 : _b.types)
-            this.protobuffers = light_1.Root.fromJSON(c.abi.types);
+        if (c.serializer) {
+            this.serializer = c.serializer;
+        }
+        else if (c.abi && c.abi.types) {
+            this.serializer = new Serializer_1.Serializer(c.abi.types);
+        }
         this.options = {
-            rcLimit: 1e8,
+            rc_limit: 1e8,
             sendTransaction: true,
             sendAbis: true,
             ...c.options,
         };
         this.functions = {};
-        if (this.signer && this.provider && this.abi && this.abi.methods) {
+        if (this.signer &&
+            this.provider &&
+            this.abi &&
+            this.abi.methods &&
+            this.serializer) {
             Object.keys(this.abi.methods).forEach((name) => {
-                this.functions[name] = async (args = {}, options) => {
+                this.functions[name] = async (argu = {}, options) => {
                     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])
+                        throw new Error(`Method ${name} not defined in the ABI`);
                     const opts = {
                         ...this.options,
                         ...options,
                     };
-                    const operation = this.encodeOperation({ name, args });
-                    if (this.abi.methods[name].readOnly) {
-                        if (!this.abi.methods[name].outputs)
-                            throw new Error(`No outputs defined for ${name}`);
+                    const { readOnly, output, defaultOutput, preformatInput, preformatOutput, } = this.abi.methods[name];
+                    let args;
+                    if (typeof preformatInput === "function") {
+                        args = preformatInput(argu);
+                    }
+                    else {
+                        args = argu;
+                    }
+                    const operation = await this.encodeOperation({ name, args });
+                    if (readOnly) {
+                        if (!output)
+                            throw new Error(`No output defined for ${name}`);
                         // read contract
                         const { result: resultEncoded } = await this.provider.readContract({
-                            contractId: utils_1.encodeBase58(operation.callContract.contractId),
-                            entryPoint: operation.callContract.entryPoint,
-                            args: utils_1.encodeBase64(operation.callContract.args),
+                            contract_id: utils_1.encodeBase58(operation.call_contract.contract_id),
+                            entry_point: operation.call_contract.entry_point,
+                            args: utils_1.encodeBase64(operation.call_contract.args),
                         });
-                        let result = this.abi.methods[name].defaultOutput;
+                        let result = defaultOutput;
                         if (resultEncoded) {
-                            result = this.decodeType(resultEncoded, this.abi.methods[name].outputs);
+                            result = await this.serializer.deserialize(resultEncoded, output);
+                        }
+                        if (typeof preformatOutput === "function") {
+                            result = preformatOutput(result);
                         }
                         return { operation, result };
                     }
@@ -148,8 +161,9 @@ class Contract {
      * The Bytecode must be defined in the constructor of the class
      * @example
      * ```ts
-     * const signer = new Signer("f186a5de49797bfd52dc42505c33d75a46822ed5b60046e09d7c336242e20200", true, provider);
+     * const privateKey = "f186a5de49797bfd52dc42505c33d75a46822ed5b60046e09d7c336242e20200";
      * const provider = new Provider(["http://api.koinos.io:8080"]);
+     * const signer = new Signer({ privateKey, provider });
      * const bytecode = new Uint8Array([1, 2, 3, 4]);
      * const contract = new Contract({ signer, provider, bytecode });
      * const { transactionResponse } = await contract.deploy();
@@ -168,8 +182,8 @@ class Contract {
             ...options,
         };
         const operation = {
-            uploadContract: {
-                contractId: Contract.computeContractId(this.signer.getAddress()),
+            upload_contract: {
+                contract_id: Contract.computeContractId(this.signer.getAddress()),
                 bytecode: this.bytecode,
             },
         };
@@ -201,32 +215,32 @@ class Contract {
      *
      * console.log(opEncoded);
      * // {
-     * //   callContract: {
-     * //     contractId: "19JntSm8pSNETT9aHTwAUHC5RMoaSmgZPJ",
-     * //     entryPoint: 0x62efa292,
+     * //   call_contract: {
+     * //     contract_id: "19JntSm8pSNETT9aHTwAUHC5RMoaSmgZPJ",
+     * //     entry_point: 0x62efa292,
      * //     args: "MBWFsaWNlA2JvYgAAAAAAAAPo",
      * //   }
      * // }
      * ```
      */
-    encodeOperation(op) {
+    async encodeOperation(op) {
         if (!this.abi || !this.abi.methods || !this.abi.methods[op.name])
             throw new Error(`Operation ${op.name} unknown`);
-        if (!this.protobuffers)
-            throw new Error("Protobuffers are not defined");
+        if (!this.serializer)
+            throw new Error("Serializer is not defined");
         if (!this.id)
             throw new Error("Contract id is not defined");
         const method = this.abi.methods[op.name];
         let bufferInputs = new Uint8Array(0);
-        if (method.inputs) {
+        if (method.input) {
             if (!op.args)
-                throw new Error(`No arguments defined for type '${method.inputs}'`);
-            bufferInputs = this.encodeType(op.args, method.inputs);
+                throw new Error(`No arguments defined for type '${method.input}'`);
+            bufferInputs = await this.serializer.serialize(op.args, method.input);
         }
         return {
-            callContract: {
-                contractId: this.id,
-                entryPoint: method.entryPoint,
+            call_contract: {
+                contract_id: this.id,
+                entry_point: method.entryPoint,
                 args: bufferInputs,
             },
         };
@@ -236,9 +250,9 @@ class Contract {
      * @example
      * ```ts
      * const opDecoded = contract.decodeOperation({
-     *   callContract: {
-     *     contractId: "19JntSm8pSNETT9aHTwAUHC5RMoaSmgZPJ",
-     *     entryPoint: 0x62efa292,
+     *   call_contract: {
+     *     contract_id: "19JntSm8pSNETT9aHTwAUHC5RMoaSmgZPJ",
+     *     entry_point: 0x62efa292,
      *     args: "MBWFsaWNlA2JvYgAAAAAAAAPo",
      *   }
      * });
@@ -253,118 +267,30 @@ class Contract {
      * // }
      * ```
      */
-    decodeOperation(op) {
+    async decodeOperation(op) {
         if (!this.id)
             throw new Error("Contract id is not defined");
         if (!this.abi || !this.abi.methods)
             throw new Error("Methods are not defined");
-        if (!op.callContract)
+        if (!this.serializer)
+            throw new Error("Serializer is not defined");
+        if (!op.call_contract)
             throw new Error("Operation is not CallContractOperation");
-        if (op.callContract.contractId !== this.id)
-            throw new Error(`Invalid contract id. Expected: ${utils_1.encodeBase58(this.id)}. Received: ${utils_1.encodeBase58(op.callContract.contractId)}`);
+        if (op.call_contract.contract_id !== this.id)
+            throw new Error(`Invalid contract id. Expected: ${utils_1.encodeBase58(this.id)}. Received: ${utils_1.encodeBase58(op.call_contract.contract_id)}`);
         for (let i = 0; i < Object.keys(this.abi.methods).length; i += 1) {
             const opName = Object.keys(this.abi.methods)[i];
             const method = this.abi.methods[opName];
-            if (op.callContract.entryPoint === method.entryPoint) {
-                if (!method.inputs)
+            if (op.call_contract.entry_point === method.entryPoint) {
+                if (!method.input)
                     return { name: opName };
                 return {
                     name: opName,
-                    args: this.decodeType(op.callContract.args, method.inputs),
+                    args: await this.serializer.deserialize(op.call_contract.args, method.input),
                 };
             }
         }
-        throw new Error(`Unknown method id ${op.callContract.entryPoint}`);
-    }
-    /**
-     * Function to encode a type using the protobuffer definitions
-     * It also prepares the bytes for special cases (base58, hex string)
-     */
-    encodeType(valueDecoded, typeName) {
-        if (!this.protobuffers)
-            throw new Error("Protobuffers are not defined");
-        const protobufType = this.protobuffers.lookupType(typeName);
-        const object = {};
-        // TODO: format from Buffer to base58/base64 for nested fields
-        Object.keys(protobufType.fields).forEach((fieldName) => {
-            const { options, name, type } = protobufType.fields[fieldName];
-            // No byte conversion
-            if (type !== "bytes") {
-                object[name] = copyValue(valueDecoded[name]);
-                return;
-            }
-            // Default byte conversion
-            if (!options || !options[OP_BYTES]) {
-                object[name] = utils_1.decodeBase64(valueDecoded[name]);
-                return;
-            }
-            // Specific byte conversion
-            switch (options[OP_BYTES]) {
-                case "BASE58":
-                case "CONTRACT_ID":
-                case "ADDRESS":
-                    object[name] = utils_1.decodeBase58(valueDecoded[name]);
-                    break;
-                case "BASE64":
-                    object[name] = utils_1.decodeBase64(valueDecoded[name]);
-                    break;
-                case "HEX":
-                case "BLOCK_ID":
-                case "TRANSACTION_ID":
-                    object[name] = utils_1.toUint8Array(valueDecoded[name].replace("0x", ""));
-                    break;
-                default:
-                    throw new Error(`unknown koinos_byte_type ${options[OP_BYTES]}`);
-            }
-        });
-        const message = protobufType.create(object);
-        const buffer = protobufType.encode(message).finish();
-        return buffer;
-    }
-    /**
-     * Function to decode bytes using the protobuffer definitions
-     * It also encodes the bytes for special cases (base58, hex string)
-     */
-    decodeType(valueEncoded, typeName) {
-        if (!this.protobuffers)
-            throw new Error("Protobuffers are not defined");
-        const valueBuffer = typeof valueEncoded === "string"
-            ? utils_1.decodeBase64(valueEncoded)
-            : valueEncoded;
-        const protobufType = this.protobuffers.lookupType(typeName);
-        const message = protobufType.decode(valueBuffer);
-        const object = protobufType.toObject(message, { longs: String });
-        // TODO: format from Buffer to base58/base64 for nested fields
-        Object.keys(protobufType.fields).forEach((fieldName) => {
-            const { options, name, type } = protobufType.fields[fieldName];
-            // No byte conversion
-            if (type !== "bytes")
-                return;
-            // Default byte conversion
-            if (!options || !options[OP_BYTES]) {
-                object[name] = utils_1.encodeBase64(object[name]);
-                return;
-            }
-            // Specific byte conversion
-            switch (options[OP_BYTES]) {
-                case "BASE58":
-                case "CONTRACT_ID":
-                case "ADDRESS":
-                    object[name] = utils_1.encodeBase58(object[name]);
-                    break;
-                case "BASE64":
-                    object[name] = utils_1.encodeBase64(object[name]);
-                    break;
-                case "HEX":
-                case "BLOCK_ID":
-                case "TRANSACTION_ID":
-                    object[name] = `0x${utils_1.toHexString(object[name])}`;
-                    break;
-                default:
-                    throw new Error(`unknown koinos_byte_type ${options[OP_BYTES]}`);
-            }
-        });
-        return object;
+        throw new Error(`Unknown method id ${op.call_contract.entry_point}`);
     }
 }
 exports.Contract = Contract;