koilib 1.5.0 → 2.3.0

package/lib/jsonDescriptors/protocol-proto.json

@@ -0,0 +1,246 @@
+{
+    "nested": {
+        "koinos": {
+            "nested": {
+                "protocol": {
+                    "options": {
+                        "go_package": "github.com/koinos/koinos-proto-golang/koinos/protocol"
+                    },
+                    "nested": {
+                        "contract_call_bundle": {
+                            "fields": {
+                                "contract_id": {
+                                    "type": "bytes",
+                                    "id": 1,
+                                    "options": {
+                                        "(koinos_bytes_type)": "CONTRACT_ID"
+                                    }
+                                },
+                                "entry_point": {
+                                    "type": "uint32",
+                                    "id": 2
+                                }
+                            }
+                        },
+                        "system_call_target": {
+                            "oneofs": {
+                                "target": {
+                                    "oneof": ["thunk_id", "system_call_bundle"]
+                                }
+                            },
+                            "fields": {
+                                "thunk_id": {
+                                    "type": "uint32",
+                                    "id": 1
+                                },
+                                "system_call_bundle": {
+                                    "type": "contract_call_bundle",
+                                    "id": 2
+                                }
+                            }
+                        },
+                        "upload_contract_operation": {
+                            "fields": {
+                                "contract_id": {
+                                    "type": "bytes",
+                                    "id": 1,
+                                    "options": {
+                                        "(koinos_bytes_type)": "CONTRACT_ID"
+                                    }
+                                },
+                                "bytecode": {
+                                    "type": "bytes",
+                                    "id": 2
+                                }
+                            }
+                        },
+                        "call_contract_operation": {
+                            "fields": {
+                                "contract_id": {
+                                    "type": "bytes",
+                                    "id": 1,
+                                    "options": {
+                                        "(koinos_bytes_type)": "CONTRACT_ID"
+                                    }
+                                },
+                                "entry_point": {
+                                    "type": "uint32",
+                                    "id": 2
+                                },
+                                "args": {
+                                    "type": "bytes",
+                                    "id": 3
+                                }
+                            }
+                        },
+                        "set_system_call_operation": {
+                            "fields": {
+                                "call_id": {
+                                    "type": "uint32",
+                                    "id": 1
+                                },
+                                "target": {
+                                    "type": "system_call_target",
+                                    "id": 2
+                                }
+                            }
+                        },
+                        "operation": {
+                            "oneofs": {
+                                "op": {
+                                    "oneof": [
+                                        "upload_contract",
+                                        "call_contract",
+                                        "set_system_call"
+                                    ]
+                                }
+                            },
+                            "fields": {
+                                "upload_contract": {
+                                    "type": "upload_contract_operation",
+                                    "id": 1
+                                },
+                                "call_contract": {
+                                    "type": "call_contract_operation",
+                                    "id": 2
+                                },
+                                "set_system_call": {
+                                    "type": "set_system_call_operation",
+                                    "id": 3
+                                }
+                            }
+                        },
+                        "active_transaction_data": {
+                            "fields": {
+                                "rc_limit": {
+                                    "type": "uint64",
+                                    "id": 1,
+                                    "options": {
+                                        "jstype": "JS_STRING"
+                                    }
+                                },
+                                "nonce": {
+                                    "type": "uint64",
+                                    "id": 2,
+                                    "options": {
+                                        "jstype": "JS_STRING"
+                                    }
+                                },
+                                "operations": {
+                                    "rule": "repeated",
+                                    "type": "operation",
+                                    "id": 3
+                                }
+                            }
+                        },
+                        "passive_transaction_data": {
+                            "fields": {}
+                        },
+                        "transaction": {
+                            "fields": {
+                                "id": {
+                                    "type": "bytes",
+                                    "id": 1,
+                                    "options": {
+                                        "(koinos_bytes_type)": "TRANSACTION_ID"
+                                    }
+                                },
+                                "active": {
+                                    "type": "bytes",
+                                    "id": 2
+                                },
+                                "passive": {
+                                    "type": "bytes",
+                                    "id": 3
+                                },
+                                "signature_data": {
+                                    "type": "bytes",
+                                    "id": 4
+                                }
+                            }
+                        },
+                        "active_block_data": {
+                            "fields": {
+                                "transaction_merkle_root": {
+                                    "type": "bytes",
+                                    "id": 1
+                                },
+                                "passive_data_merkle_root": {
+                                    "type": "bytes",
+                                    "id": 2
+                                },
+                                "signer": {
+                                    "type": "bytes",
+                                    "id": 3
+                                }
+                            }
+                        },
+                        "passive_block_data": {
+                            "fields": {}
+                        },
+                        "block_header": {
+                            "fields": {
+                                "previous": {
+                                    "type": "bytes",
+                                    "id": 1,
+                                    "options": {
+                                        "(koinos_bytes_type)": "BLOCK_ID"
+                                    }
+                                },
+                                "height": {
+                                    "type": "uint64",
+                                    "id": 2,
+                                    "options": {
+                                        "jstype": "JS_STRING"
+                                    }
+                                },
+                                "timestamp": {
+                                    "type": "uint64",
+                                    "id": 3,
+                                    "options": {
+                                        "jstype": "JS_STRING"
+                                    }
+                                }
+                            }
+                        },
+                        "block": {
+                            "fields": {
+                                "id": {
+                                    "type": "bytes",
+                                    "id": 1,
+                                    "options": {
+                                        "(koinos_bytes_type)": "BLOCK_ID"
+                                    }
+                                },
+                                "header": {
+                                    "type": "block_header",
+                                    "id": 2
+                                },
+                                "active": {
+                                    "type": "bytes",
+                                    "id": 3
+                                },
+                                "passive": {
+                                    "type": "bytes",
+                                    "id": 4
+                                },
+                                "signature_data": {
+                                    "type": "bytes",
+                                    "id": 5
+                                },
+                                "transactions": {
+                                    "rule": "repeated",
+                                    "type": "transaction",
+                                    "id": 6
+                                }
+                            }
+                        },
+                        "block_receipt": {
+                            "fields": {}
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

package/lib/utils.d.ts

@@ -1,3 +1,4 @@
+import { Abi } from "./interface";
 /**
  * Converts an hex string to Uint8Array
  */
@@ -14,6 +15,14 @@ export declare function encodeBase58(buffer: Uint8Array): string;
  * Decodes a buffer formatted in base58
  */
 export declare function decodeBase58(bs58: string): Uint8Array;
+/**
+ * Encodes an Uint8Array in base64
+ */
+export declare function encodeBase64(buffer: Uint8Array): string;
+/**
+ * Decodes a buffer formatted in base64
+ */
+export declare function decodeBase64(bs64: string): Uint8Array;
 /**
  * Encodes a public or private key in base58 using
  * the bitcoin format (see [Bitcoin Base58Check encoding](https://en.bitcoin.it/wiki/Base58Check_encoding)
@@ -39,3 +48,275 @@ export declare function bitcoinDecode(value: string): Uint8Array;
  * address = bitcoinEncode( ripemd160 ( sha256 ( publicKey ) ) )
  */
 export declare function bitcoinAddress(publicKey: Uint8Array): string;
+/**
+ * Function to format a number in a decimal point number
+ * @example
+ * ```js
+ * const amount = formatUnits("123456", 8);
+ * console.log(amount);
+ * // '0.00123456'
+ * ```
+ */
+export declare function formatUnits(value: string | number | bigint, decimals: number): string;
+/**
+ * Function to format a decimal point number in an integer
+ * @example
+ * ```js
+ * const amount = parseUnits("0.00123456", 8);
+ * console.log(amount);
+ * // '123456'
+ * ```
+ */
+export declare function parseUnits(value: string, decimals: number): string;
+/**
+ * ABI for tokens
+ */
+export declare const Krc20Abi: Abi;
+export declare const ProtocolTypes: {
+    nested: {
+        koinos: {
+            nested: {
+                protocol: {
+                    options: {
+                        go_package: string;
+                    };
+                    nested: {
+                        contract_call_bundle: {
+                            fields: {
+                                contract_id: {
+                                    type: string;
+                                    id: number;
+                                    options: {
+                                        "(koinos_bytes_type)": string;
+                                    };
+                                };
+                                entry_point: {
+                                    type: string;
+                                    id: number;
+                                };
+                            };
+                        };
+                        system_call_target: {
+                            oneofs: {
+                                target: {
+                                    oneof: string[];
+                                };
+                            };
+                            fields: {
+                                thunk_id: {
+                                    type: string;
+                                    id: number;
+                                };
+                                system_call_bundle: {
+                                    type: string;
+                                    id: number;
+                                };
+                            };
+                        };
+                        upload_contract_operation: {
+                            fields: {
+                                contract_id: {
+                                    type: string;
+                                    id: number;
+                                    options: {
+                                        "(koinos_bytes_type)": string;
+                                    };
+                                };
+                                bytecode: {
+                                    type: string;
+                                    id: number;
+                                };
+                            };
+                        };
+                        call_contract_operation: {
+                            fields: {
+                                contract_id: {
+                                    type: string;
+                                    id: number;
+                                    options: {
+                                        "(koinos_bytes_type)": string;
+                                    };
+                                };
+                                entry_point: {
+                                    type: string;
+                                    id: number;
+                                };
+                                args: {
+                                    type: string;
+                                    id: number;
+                                };
+                            };
+                        };
+                        set_system_call_operation: {
+                            fields: {
+                                call_id: {
+                                    type: string;
+                                    id: number;
+                                };
+                                target: {
+                                    type: string;
+                                    id: number;
+                                };
+                            };
+                        };
+                        operation: {
+                            oneofs: {
+                                op: {
+                                    oneof: string[];
+                                };
+                            };
+                            fields: {
+                                upload_contract: {
+                                    type: string;
+                                    id: number;
+                                };
+                                call_contract: {
+                                    type: string;
+                                    id: number;
+                                };
+                                set_system_call: {
+                                    type: string;
+                                    id: number;
+                                };
+                            };
+                        };
+                        active_transaction_data: {
+                            fields: {
+                                rc_limit: {
+                                    type: string;
+                                    id: number;
+                                    options: {
+                                        jstype: string;
+                                    };
+                                };
+                                nonce: {
+                                    type: string;
+                                    id: number;
+                                    options: {
+                                        jstype: string;
+                                    };
+                                };
+                                operations: {
+                                    rule: string;
+                                    type: string;
+                                    id: number;
+                                };
+                            };
+                        };
+                        passive_transaction_data: {
+                            fields: {};
+                        };
+                        transaction: {
+                            fields: {
+                                id: {
+                                    type: string; /**
+                                     * Computes a bitcoin address, which is the format used in Koinos
+                                     *
+                                     * address = bitcoinEncode( ripemd160 ( sha256 ( publicKey ) ) )
+                                     */
+                                    id: number;
+                                    options: {
+                                        "(koinos_bytes_type)": string;
+                                    };
+                                };
+                                active: {
+                                    type: string;
+                                    id: number;
+                                };
+                                passive: {
+                                    type: string;
+                                    id: number;
+                                };
+                                signature_data: {
+                                    type: string;
+                                    id: number;
+                                };
+                            };
+                        };
+                        active_block_data: {
+                            fields: {
+                                transaction_merkle_root: {
+                                    type: string;
+                                    id: number;
+                                };
+                                passive_data_merkle_root: {
+                                    type: string;
+                                    id: number;
+                                };
+                                signer: {
+                                    type: string;
+                                    id: number;
+                                };
+                            };
+                        };
+                        passive_block_data: {
+                            fields: {};
+                        };
+                        block_header: {
+                            fields: {
+                                previous: {
+                                    type: string;
+                                    id: number;
+                                    options: {
+                                        "(koinos_bytes_type)": string;
+                                    };
+                                };
+                                height: {
+                                    type: string;
+                                    id: number;
+                                    options: {
+                                        jstype: string;
+                                    };
+                                };
+                                timestamp: {
+                                    type: string;
+                                    id: number; /**
+                                     * ABI for tokens
+                                     */
+                                    options: {
+                                        jstype: string;
+                                    };
+                                };
+                            };
+                        };
+                        block: {
+                            fields: {
+                                id: {
+                                    type: string;
+                                    id: number;
+                                    options: {
+                                        "(koinos_bytes_type)": string;
+                                    };
+                                };
+                                header: {
+                                    type: string;
+                                    id: number;
+                                };
+                                active: {
+                                    type: string;
+                                    id: number;
+                                };
+                                passive: {
+                                    type: string;
+                                    id: number;
+                                };
+                                signature_data: {
+                                    type: string;
+                                    id: number;
+                                };
+                                transactions: {
+                                    rule: string;
+                                    type: string;
+                                    id: number;
+                                };
+                            };
+                        };
+                        block_receipt: {
+                            fields: {};
+                        };
+                    };
+                };
+            };
+        };
+    };
+};

package/lib/utils.js

@@ -22,10 +22,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.bitcoinAddress = exports.bitcoinDecode = exports.copyUint8Array = exports.bitcoinEncode = exports.decodeBase58 = exports.encodeBase58 = exports.toHexString = exports.toUint8Array = void 0;
+exports.ProtocolTypes = exports.Krc20Abi = exports.parseUnits = exports.formatUnits = exports.bitcoinAddress = exports.bitcoinDecode = exports.copyUint8Array = exports.bitcoinEncode = exports.decodeBase64 = exports.encodeBase64 = exports.decodeBase58 = exports.encodeBase58 = exports.toHexString = exports.toUint8Array = void 0;
 const multibase = __importStar(require("multibase"));
 const js_sha256_1 = require("js-sha256");
 const noble_ripemd160_1 = __importDefault(require("noble-ripemd160"));
+const krc20_proto_json_1 = __importDefault(require("./jsonDescriptors/krc20-proto.json"));
+const protocol_proto_json_1 = __importDefault(require("./jsonDescriptors/protocol-proto.json"));
 /**
  * Converts an hex string to Uint8Array
  */
@@ -60,6 +62,20 @@ function decodeBase58(bs58) {
     return multibase.decode(`z${bs58}`);
 }
 exports.decodeBase58 = decodeBase58;
+/**
+ * Encodes an Uint8Array in base64
+ */
+function encodeBase64(buffer) {
+    return new TextDecoder().decode(multibase.encode("U", buffer)).slice(1);
+}
+exports.encodeBase64 = encodeBase64;
+/**
+ * Decodes a buffer formatted in base64
+ */
+function decodeBase64(bs64) {
+    return multibase.decode(`U${bs64}`);
+}
+exports.decodeBase64 = decodeBase64;
 /**
  * Encodes a public or private key in base58 using
  * the bitcoin format (see [Bitcoin Base58Check encoding](https://en.bitcoin.it/wiki/Base58Check_encoding)
@@ -148,4 +164,96 @@ function bitcoinAddress(publicKey) {
     return bitcoinEncode(hash160, "public");
 }
 exports.bitcoinAddress = bitcoinAddress;
+/**
+ * Function to format a number in a decimal point number
+ * @example
+ * ```js
+ * const amount = formatUnits("123456", 8);
+ * console.log(amount);
+ * // '0.00123456'
+ * ```
+ */
+function formatUnits(value, decimals) {
+    let v = typeof value === "string" ? value : BigInt(value).toString();
+    const sign = v[0] === "-" ? "-" : "";
+    v = v.replace("-", "").padStart(decimals + 1, "0");
+    const integerPart = v
+        .substring(0, v.length - decimals)
+        .replace(/^0+(?=\d)/, "");
+    const decimalPart = v.substring(v.length - decimals);
+    return `${sign}${integerPart}.${decimalPart}`.replace(/(\.0+)?(0+)$/, "");
+}
+exports.formatUnits = formatUnits;
+/**
+ * Function to format a decimal point number in an integer
+ * @example
+ * ```js
+ * const amount = parseUnits("0.00123456", 8);
+ * console.log(amount);
+ * // '123456'
+ * ```
+ */
+function parseUnits(value, decimals) {
+    const sign = value[0] === "-" ? "-" : "";
+    // eslint-disable-next-line prefer-const
+    let [integerPart, decimalPart] = value
+        .replace("-", "")
+        .replace(",", ".")
+        .split(".");
+    if (!decimalPart)
+        decimalPart = "";
+    decimalPart = decimalPart.padEnd(decimals, "0");
+    return `${sign}${`${integerPart}${decimalPart}`.replace(/^0+(?=\d)/, "")}`;
+}
+exports.parseUnits = parseUnits;
+/**
+ * ABI for tokens
+ */
+exports.Krc20Abi = {
+    methods: {
+        name: {
+            entryPoint: 0x76ea4297,
+            input: "name_arguments",
+            output: "name_result",
+            readOnly: true,
+        },
+        symbol: {
+            entryPoint: 0x7e794b24,
+            input: "symbol_arguments",
+            output: "symbol_result",
+            readOnly: true,
+        },
+        decimals: {
+            entryPoint: 0x59dc15ce,
+            input: "decimals_arguments",
+            output: "decimals_result",
+            readOnly: true,
+        },
+        totalSupply: {
+            entryPoint: 0xcf2e8212,
+            input: "total_supply_arguments",
+            output: "total_supply_result",
+            readOnly: true,
+        },
+        balanceOf: {
+            entryPoint: 0x15619248,
+            input: "balance_of_arguments",
+            output: "balance_of_result",
+            readOnly: true,
+            defaultOutput: { value: "0" },
+        },
+        transfer: {
+            entryPoint: 0x62efa292,
+            input: "transfer_arguments",
+            output: "transfer_result",
+        },
+        mint: {
+            entryPoint: 0xc2f82bdc,
+            input: "mint_argumnets",
+            output: "mint_result",
+        },
+    },
+    types: krc20_proto_json_1.default,
+};
+exports.ProtocolTypes = protocol_proto_json_1.default;
 //# sourceMappingURL=utils.js.map