opnet 1.2.26 → 1.3.0

package/src/contracts/Contract.ts

@@ -378,14 +378,6 @@ export abstract class IBaseContract<T extends BaseContractProperties> implements
                 writer.writeAddress(value as Address);
                 break;
             }
-            case ABIDataTypes.TUPLE: {
-                if (!(value instanceof Array)) {
-                    throw new Error(`Expected value to be of type Array (${name})`);
-                }
-
-                writer.writeTuple(value as bigint[]);
-                break;
-            }
             case ABIDataTypes.UINT8: {
                 if (typeof value !== 'number') {
                     throw new Error(`Expected value to be of type number (${name})`);
@@ -415,7 +407,7 @@ export abstract class IBaseContract<T extends BaseContractProperties> implements
                 break;
             }
             case ABIDataTypes.ADDRESS_UINT256_TUPLE: {
-                writer.writeAddressValueTupleMap(value as AddressMap<bigint>);
+                writer.writeAddressValueTuple(value as AddressMap<bigint>);
                 break;
             }
             case ABIDataTypes.BYTES: {
@@ -553,9 +545,6 @@ export abstract class IBaseContract<T extends BaseContractProperties> implements
                 case ABIDataTypes.ADDRESS:
                     decodedResult = reader.readAddress();
                     break;
-                case ABIDataTypes.TUPLE:
-                    decodedResult = reader.readTuple();
-                    break;
                 case ABIDataTypes.UINT8:
                     decodedResult = reader.readU8();
                     break;
@@ -641,7 +630,7 @@ export abstract class IBaseContract<T extends BaseContractProperties> implements
         const exactGas = ((gas / 1000000n) * gasPerSat) / 1000000n;
 
         // Add 15% extra gas
-        const extraGas = (exactGas * 50n) / 100n;
+        const extraGas = (exactGas * 15n) / 100n;
 
         return this.max(exactGas + extraGas, 330n);
     }

package/src/contracts/TypeToStr.ts

@@ -23,5 +23,4 @@ export const AbiTypeToStr: { [key in ABIDataTypes]: string } = {
     [ABIDataTypes.ARRAY_OF_UINT8]: 'uint8[]',
     [ABIDataTypes.ARRAY_OF_BYTES]: 'bytes[]',
     [ABIDataTypes.ARRAY_OF_STRING]: 'string[]',
-    [ABIDataTypes.TUPLE]: 'tuple256',
 };

package/src/providers/AbstractRpcProvider.ts

@@ -132,8 +132,8 @@ export abstract class AbstractRpcProvider {
      * @returns {Promise<Buffer>} The preimage
      */
     public async getPreimage(): Promise<Buffer> {
-        if(this.preimageCache) {
-            if(this.preimageCache.expireAt > Date.now()) {
+        if (this.preimageCache) {
+            if (this.preimageCache.expireAt > Date.now()) {
                 return this.preimageCache.preimage;
             }
         }
@@ -144,17 +144,22 @@ export abstract class AbstractRpcProvider {
         );
 
         const rawBlockNumber: JsonRpcResult = await this.callPayloadSingle(payload);
-        const result: { preimage: string } = rawBlockNumber.result as {preimage: string};
+        const result: { preimage: string } = rawBlockNumber.result as { preimage: string };
 
-        if(!result || result.preimage === '0000000000000000000000000000000000000000000000000000000000000000') {
-            throw new Error('No preimage found. OPNet is probably not active yet on this blockchain.');
+        if (
+            !result ||
+            result.preimage === '0000000000000000000000000000000000000000000000000000000000000000'
+        ) {
+            throw new Error(
+                'No preimage found. OPNet is probably not active yet on this blockchain.',
+            );
         }
 
         const preimage = Buffer.from(result.preimage, 'hex');
         this.preimageCache = {
             preimage: preimage,
-            expireAt: Date.now() + 10_000
-        }
+            expireAt: Date.now() + 10_000,
+        };
 
         return preimage;
     }
@@ -710,30 +715,6 @@ export abstract class AbstractRpcProvider {
         return data as JSONRpc2ResponseResult<JSONRpcMethods>;
     }
 
-    /*
-     * Generate parameters needed to wrap bitcoin.
-     * @description This method is used to generate the parameters needed to wrap bitcoin.
-     * @param {BigNumberish} amount The amount to wrap
-     * @returns {Promise<WrappedGeneration>} The wrapped generation parameters
-     * @example await requestTrustedPublicKeyForBitcoinWrapping(100000000n);
-     * @throws {Error} If something went wrong while generating the parameters
-     */
-
-    /*public async requestTrustedPublicKeyForBitcoinWrapping(
-        amount: BigNumberish,
-    ): Promise<WrappedGeneration> {
-        const payload: JsonRpcPayload = this.buildJsonRpcPayload(JSONRpcMethods.GENERATE, [
-            GenerateTarget.WRAP,
-            amount.toString(),
-        ]);
-
-        const rawPublicKey: JsonRpcResult = await this.callPayloadSingle(payload);
-        const result: WrappedGenerationParameters =
-            rawPublicKey.result as WrappedGenerationParameters;
-
-        return new WrappedGeneration(result);
-    }*/
-
     /**
      * Send multiple payloads. This method is used to send multiple payloads.
      * @param {JsonRpcPayload[]} payloads The payloads to send
@@ -778,12 +759,14 @@ export abstract class AbstractRpcProvider {
      * Get the public key information.
      * @description This method is used to get the public key information.
      * @param {string | string[] | Address | Address[]} addresses The address or addresses to get the public key information of
+     * @param logErrors
      * @returns {Promise<AddressesInfo>} The public keys information
      * @example await getPublicKeysInfo(['addressA', 'addressB']);
      * @throws {Error} If the address is invalid
      */
     public async getPublicKeysInfo(
         addresses: string | string[] | Address | Address[],
+        logErrors: boolean = false,
     ): Promise<AddressesInfo> {
         const addressArray = Array.isArray(addresses) ? addresses : [addresses];
 
@@ -808,7 +791,13 @@ export abstract class AbstractRpcProvider {
         for (const pubKey of keys) {
             const pubKeyValue = result[pubKey];
             if ('error' in pubKeyValue) {
-                throw new Error(`Error fetching public key info: ${pubKeyValue.error}`);
+                if (logErrors) {
+                    console.error(
+                        `Error fetching public key info for ${pubKey}: ${pubKeyValue.error}`,
+                    );
+                }
+
+                continue;
             }
 
             response[pubKey] = pubKeyValue.originalPubKey