koilib 7.1.1 → 8.1.0

package/README.md

@@ -342,6 +342,37 @@ const receipt = await tx.send();
 await tx.wait();
 ```
 
+### Estimate mana
+
+Here is an example to estimate the mana. First create a transaction and sign it:
+
+```ts
+const tx = new Transaction({ signer, provider });
+await tx.pushOperation(koin.transfer, {
+  from: "1NRYHBYr9qxYQAeVqfdSvyjJemRQ4qD3Mt",
+  to: "13UdKjYuzfBYbB6bGLQkUN9DJRFPCmG1mU",
+  value: "1000",
+});
+await tx.sign();
+```
+
+Now send it with broadcast:false. With this option the rpc node will compute the
+transaction but it will not broadcast it, then it will not be included in a block:
+
+```ts
+let receipt = await tx.send({ broadcast: false });
+```
+
+Finally, adjust the mana by taking a look to the rc used. In this example we will
+adjust it by increasing it 10%. Then sign and send with the default option
+(broadcast:true):
+
+```ts
+tx.adjustRcLimit(Math.round(1.1 * Number(receipt.rc_used)));
+await tx.sign();
+receipt = await tx.send();
+```
+
 ### Create ABIs
 
 ABIs are composed of 2 elements: methods and types.

package/dist/koinos.js

@@ -23766,7 +23766,7 @@ class Provider {
     }
     /**
      * Function to get the contract metadata of a specific contract.
-     * @param contractId contract ID
+     * @param contractId - contract ID
      *
      * @example
      * ```ts
@@ -23844,6 +23844,56 @@ class Provider {
             contract_id: contractId,
         });
     }
+    /**
+     * Function to get the address of a system contract
+     * @param name - contract name
+     *
+     * @example
+     * * ```ts
+     * const provider = new Provider("https://api.koinos.io");
+     * const result = await provider.invokeGetContractAddress("koin");
+     * console.log(result);
+     *
+     * // { value: { address: '15DJN4a8SgrbGhhGksSBASiSYjGnMU8dGL' } }
+     * ```
+     */
+    async invokeGetContractAddress(name) {
+        const serializer = new Serializer_1.Serializer({
+            nested: {
+                get_address_arguments: {
+                    fields: {
+                        name: {
+                            type: "string",
+                            id: 1,
+                        },
+                    },
+                },
+                get_address_result: {
+                    fields: {
+                        value: {
+                            type: "address_record",
+                            id: 1,
+                        },
+                    },
+                },
+                address_record: {
+                    fields: {
+                        address: {
+                            type: "bytes",
+                            id: 1,
+                            options: {
+                                "(koinos.btype)": "ADDRESS",
+                            },
+                        },
+                    },
+                },
+            },
+        }, {
+            argumentsTypeName: "get_address_arguments",
+            returnTypeName: "get_address_result",
+        });
+        return this.invokeSystemCall(serializer, "get_contract_address", { name });
+    }
 }
 exports.Provider = Provider;
 exports["default"] = Provider;
@@ -24190,7 +24240,6 @@ exports.Signer = void 0;
 /* eslint-disable no-param-reassign, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment */
 const sha256_1 = __webpack_require__(3061);
 const secp = __importStar(__webpack_require__(9656));
-const Transaction_1 = __webpack_require__(7592);
 const utils_1 = __webpack_require__(8593);
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
@@ -24275,7 +24324,6 @@ class Signer {
      * @param compressed - compressed format is true by default
      * @param provider - provider to connect with the blockchain
      * @param sendOptions - Send options
-     * @param rcOptions - options for mana estimation
      * @example
      * ```ts
      * const privateKey = "ec8601a24f81decd57f4b611b5ac6eb801cb3780bb02c0f9cdfe9d09daaddf9c";
@@ -24283,42 +24331,8 @@ class Signer {
      * console.log(signer.getAddress());
      * // 1MbL6mG8ASAvSYdoMnGUfG3ZXkmQ2dpL5b
      * ```
-     *
-     * By default the mana is estimated as 110% the mana used. This
-     * estimation is computed using the "broadcast:false" option.
-     * For instance, if the transaction consumes 1 mana, the rc_limit
-     * will be set to 1.1 mana.
-     *
-     * You can also adjust the rc limit.
-     * @example
-     * ```ts
-     * const privateKey = "ec8601a24f81decd57f4b611b5ac6eb801cb3780bb02c0f9cdfe9d09daaddf9c";
-     * cons signer = new Signer({
-     *   privateKey,
-     *   provider,
-     *   rcOptions: {
-     *     estimateRc: true,
-     *     // use 2 times rc_used as rc_limit
-     *     adjustRcLimit: (r) => 2 * Number(r.rc_used),
-     *   },
-     * });
-     * ```
-     *
-     * The rpc node must be highly trusted because the transaction
-     * is signed during the estimation of the mana. You can also
-     * disable the mana estimation:
-     * @example
-     * ```ts
-     * const privateKey = "ec8601a24f81decd57f4b611b5ac6eb801cb3780bb02c0f9cdfe9d09daaddf9c";
-     * cons signer = new Signer({
-     *   privateKey,
-     *   provider,
-     *   rcOptions: { estimateRc: false },
-     * });
-     * ```
      */
     constructor(c) {
-        var _a;
         this.compressed = typeof c.compressed === "undefined" ? true : c.compressed;
         this.privateKey = c.privateKey;
         this.provider = c.provider;
@@ -24334,10 +24348,6 @@ class Signer {
             broadcast: true,
             ...c.sendOptions,
         };
-        this.rcOptions = (_a = c.rcOptions) !== null && _a !== void 0 ? _a : {
-            estimateRc: true,
-            adjustRcLimit: (receipt) => Promise.resolve(Math.min(Number(receipt.max_payer_rc), Math.floor(1.1 * Number(receipt.rc_used)))),
-        };
     }
     /**
      * Function to import a private key from the WIF
@@ -24457,15 +24467,6 @@ class Signer {
     async signTransaction(tx, _abis) {
         if (!tx.id)
             throw new Error("Missing transaction id");
-        // estimation of rcLimit
-        if (this.rcOptions.estimateRc &&
-            (!tx.signatures || tx.signatures.length === 0)) {
-            const receipt = await this.estimateReceipt(tx);
-            tx.header.rc_limit = this.rcOptions.adjustRcLimit
-                ? await this.rcOptions.adjustRcLimit(receipt)
-                : receipt.rc_used;
-            tx.id = Transaction_1.Transaction.computeTransactionId(tx.header);
-        }
         // multihash 0x1220. 12: code sha2-256. 20: length (32 bytes)
         // tx id is a stringified multihash, need to extract the hash digest only
         const hash = (0, utils_1.toUint8Array)(tx.id.slice(6));
@@ -24514,43 +24515,6 @@ class Signer {
         }
         return this.provider.sendTransaction(transaction, opts.broadcast);
     }
-    /**
-     * Estimate the receipt associated to the transaction if
-     * it sent to the blockchain. It is useful to estimate the
-     * consumption of mana.
-     * The transaction is signed during this process and sent
-     * to the rpc node with the "broadcast:false" option to
-     * just compute the transaction without broadcasting it to
-     * the network.
-     * After that, the initial signatures are restored (if any)
-     * and the ones used for the estimation will be removed.
-     */
-    async estimateReceipt(tx) {
-        if (!tx.id)
-            throw new Error("Missing transaction id");
-        if (!tx.signatures)
-            tx.signatures = [];
-        const signaturesCopy = [...tx.signatures];
-        // sign if there are no signatures
-        if (tx.signatures.length === 0) {
-            const hash = (0, utils_1.toUint8Array)(tx.id.slice(6));
-            const signature = await this.signHash(hash);
-            tx.signatures.push((0, utils_1.encodeBase64url)(signature));
-        }
-        try {
-            const { receipt } = await this.sendTransaction(tx, {
-                broadcast: false,
-            });
-            // restore signatures
-            tx.signatures = signaturesCopy;
-            return receipt;
-        }
-        catch (error) {
-            // restore signatures
-            tx.signatures = signaturesCopy;
-            throw error;
-        }
-    }
     /**
      * Function to recover the public key from hash and signature
      * @param hash - hash sha256
@@ -24627,7 +24591,7 @@ class Signer {
      *  });
      * ```
      */
-    async recoverPublicKeys(txOrBlock, opts) {
+    static async recoverPublicKeys(txOrBlock, opts) {
         let compressed = true;
         if (opts && opts.compressed !== undefined) {
             compressed = opts.compressed;
@@ -24712,7 +24676,7 @@ class Signer {
      *  });
      * ```
      */
-    async recoverAddresses(txOrBlock, opts) {
+    static async recoverAddresses(txOrBlock, opts) {
         const publicKeys = await this.recoverPublicKeys(txOrBlock, opts);
         return publicKeys.map((publicKey) => (0, utils_1.bitcoinAddress)((0, utils_1.toUint8Array)(publicKey)));
     }
@@ -24876,6 +24840,7 @@ class Transaction {
                 ...(((_f = c === null || c === void 0 ? void 0 : c.options) === null || _f === void 0 ? void 0 : _f.payee) && { payee: c.options.payee }),
             },
             operations: [],
+            ...c === null || c === void 0 ? void 0 : c.transaction,
         };
     }
     /**
@@ -24893,14 +24858,17 @@ class Transaction {
      * signer.provider = provider;
      * const tx = new Transaction({ signer });
      *
-     * // method 1
+     * // Method 1 (using 2 arguments)
+     * // note that with 2 arguments it is not necessary to
+     * // set "onlyOperation: true". For the rest of the
+     * // methods it's necessary to do that.
      * await tx.pushOperation(koin.transfer, {
      *   from: "1NRYHBYr9qxYQAeVqfdSvyjJemRQ4qD3Mt",
      *   to: "13UdKjYuzfBYbB6bGLQkUN9DJRFPCmG1mU",
      *   value: "1000",
      * });
      *
-     * // method 2
+     * // Method 2
      * await tx.pushOperation(
      *   koin.transfer({
      *     from: "1NRYHBYr9qxYQAeVqfdSvyjJemRQ4qD3Mt",
@@ -24911,7 +24879,7 @@ class Transaction {
      *   })
      * );
      *
-     * // method 3
+     * // Method 3
      * await tx.pushOperation(
      *   await koin.transfer({
      *     from: "1NRYHBYr9qxYQAeVqfdSvyjJemRQ4qD3Mt",
@@ -24922,7 +24890,7 @@ class Transaction {
      *   })
      * );
      *
-     * // method 4
+     * // Method 4
      * const { operation } = await koin.transfer({
      *   from: "1NRYHBYr9qxYQAeVqfdSvyjJemRQ4qD3Mt",
      *   to: "13UdKjYuzfBYbB6bGLQkUN9DJRFPCmG1mU",
@@ -25062,6 +25030,21 @@ class Transaction {
         this.transaction = await Transaction.prepareTransaction(this.transaction, this.provider, (_a = this.signer) === null || _a === void 0 ? void 0 : _a.getAddress());
         return this.transaction;
     }
+    /**
+     * Update the rc limit with a new value and update the
+     * transaction ID accordingly. The signatures will be removed
+     * if the transaction ID changed
+     */
+    adjustRcLimit(newRcLimit) {
+        if (!this.transaction.header)
+            throw new Error("transaction header not defined");
+        this.transaction.header.rc_limit = newRcLimit;
+        const newTxId = Transaction.computeTransactionId(this.transaction.header);
+        if (this.transaction.id !== newTxId) {
+            this.transaction.signatures = [];
+        }
+        this.transaction.id = newTxId;
+    }
     /**
      * Function to sign the transaction
      */