@witnet/solidity 3.0.4 → 3.0.5

package/dist/src/lib/wrappers/WitOracleRadonRegistry.js

@@ -0,0 +1,140 @@
+import { utils, Witnet } from "@witnet/sdk";
+import { abiEncodeRadonAsset } from "../utils.js";
+import { WitArtifact } from "./WitArtifact.js";
+/**
+ * Wrapper class for the Wit/Oracle Radon Registry core contract as deployed in some supported EVM network.
+ * It allows formal verification of Radon Requests and Witnet-compliant data sources into such network,
+ * as to be securely referred on both Wit/Oracle queries pulled from within smart contracts,
+ * or Wit/Oracle query results pushed into smart contracts from offchain workflows.
+ */
+export class WitOracleRadonRegistry extends WitArtifact {
+    constructor(signer, network) {
+        super(signer, network, "WitOracleRadonRegistry");
+    }
+    /// ===========================================================================================================
+    /// --- IWitOracleRadonRegistry -------------------------------------------------------------------------------
+    /**
+     * Determines the unique hash that would identify the given Radon Retrieval, if it was
+     * formally verified into the connected EVM network.
+     * @param retrieval Instance of a Radon Retrieval object.
+     */
+    async determineRadonRetrievalHash(retrieval) {
+        return this.contract
+            .getFunction("verifyRadonRetrieval(uint8,string,string,string[2][],bytes)")
+            .staticCall(...abiEncodeRadonAsset(retrieval))
+            .then((hash) => {
+            return hash.slice(2);
+        });
+    }
+    /**
+     * Returns information related to some previously verified Radon Request, on the connected EVM network.
+     * @param radHash The RAD hash that uniquely identifies the Radon Request.
+     */
+    async lookupRadonRequest(radHash) {
+        return this.contract
+            .getFunction("lookupRadonRequestBytecode(bytes32)")
+            .staticCall(`0x${radHash}`)
+            .then((bytecode) => Witnet.Radon.RadonRequest.fromBytecode(bytecode));
+    }
+    /**
+     * Returns the bytecode of some previously verified Radon Request, on the connected EVM network.
+     * @param radHash The RAD hash that uniquely identifies the Radon Request.
+     */
+    async lookupRadonRequestBytecode(radHash) {
+        return this.contract
+            .getFunction("lookupRadonRequestBytecode(bytes32)")
+            .staticCall(`${radHash.startsWith("0x") ? radHash : `0x${radHash}`}`);
+    }
+    /**
+     * Returns information about some previously verified Radon Retrieval on the connected EVM network.
+     * This information includes retrieval the method, URL, body, headers and the Radon script in charge
+     * to transform data before delivery, on the connected EVM network.
+     * @param radHash The RAD hash that uniquely identifies the Radon Request.
+     */
+    async lookupRadonRetrieval(hash) {
+        return this.contract
+            .getFunction("lookupRadonRetrieval(bytes32)")
+            .staticCall(`0x${hash}`)
+            .then((result) => {
+            return new Witnet.Radon.RadonRetrieval({
+                method: result[1],
+                url: result[3],
+                body: result[4],
+                headers: Object.fromEntries(result[5]),
+                script: utils.parseRadonScript(result[6]),
+            });
+        });
+    }
+    /**
+     * Formally verify the given Radon Request object into the connected EVM network.
+     * It also verifies all the Radon Retrieval scripts (i.e. data source) the Request
+     * relies on, if not yet done before.
+     *
+     * Verifying Radon assets modifies the EVM storage and therefore requires
+     * spending gas in proportion to the number and complexity of the data sources,
+     * and whether these had been previously verified before or not.
+     *
+     * If the given Radon Request happened to be already verified, no gas would be actually consumed.
+     *
+     * @param request Instance of a Radon Request object.
+     * @param options Async EVM transaction handlers.
+     * @returns The RAD hash of the Radon Request, as verified on the connected EVM network.
+     */
+    async verifyRadonRequest(request, options) {
+        const radHash = request.radHash;
+        await this.lookupRadonRequest(radHash).catch(async () => {
+            const hashes = [];
+            for (const index in request.sources) {
+                const retrieval = request.sources[index];
+                hashes.push(`0x${await this.verifyRadonRetrieval(retrieval, options)}`);
+            }
+            const aggregate = abiEncodeRadonAsset(request.sourcesReducer);
+            const tally = abiEncodeRadonAsset(request.witnessReducer);
+            if (options?.onVerifyRadonRequest) {
+                options.onVerifyRadonRequest(radHash);
+            }
+            await this.contract
+                .getFunction("verifyRadonRequest(bytes32[],(uint8,(uint8,bytes)[]),(uint8,(uint8,bytes)[]))")
+                .send(hashes, aggregate, tally)
+                .then(async (tx) => {
+                const receipt = await tx.wait(options?.confirmations || 1);
+                if (options?.onVerifyRadonRequestReceipt) {
+                    options.onVerifyRadonRequestReceipt(receipt);
+                }
+            });
+        });
+        return radHash;
+    }
+    /**
+     * Formally verify the given Radon Retrieval script (i.e. data source), into the connected EVM network.
+     *
+     * Verifying Radon assets modifies the EVM storage and therefore requires
+     * spending gas in proportion to the size of the data source parameters (e.g. URL, body, headers, or Radon script).
+     *
+     * If the given Radon Retrieval object happened to be already verified, no EVM gas would be actually consumed.
+     *
+     * @param request Instance of a Radon Retrieval object.
+     * @param options Async EVM transaction handlers.
+     * @returns The unique hash of the Radon Retrieval object, as verified on the connected EVM network.
+     */
+    async verifyRadonRetrieval(retrieval, options) {
+        return this.determineRadonRetrievalHash(retrieval).then(async (hash) => {
+            await this.lookupRadonRetrieval(hash).catch(async () => {
+                if (options?.onVerifyRadonRetrieval) {
+                    options.onVerifyRadonRetrieval(hash);
+                }
+                await this.contract
+                    .getFunction("verifyRadonRetrieval(uint8,string,string,string[2][],bytes)")
+                    .send(...abiEncodeRadonAsset(retrieval))
+                    .then(async (tx) => {
+                    const receipt = await tx.wait(options?.confirmations || 1);
+                    if (options?.onVerifyRadonRetrievalReceipt) {
+                        options.onVerifyRadonRetrievalReceipt(receipt);
+                    }
+                });
+            });
+            return hash;
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"WitOracleRadonRegistry.js","sourceRoot":"","sources":["../../../../src/lib/wrappers/WitOracleRadonRegistry.ts"],"names":[],"mappings":"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","sourcesContent":["import { utils, Witnet } from \"@witnet/sdk\"\nimport type { ContractTransactionReceipt, JsonRpcSigner, Result } from \"ethers\"\nimport { abiEncodeRadonAsset } from \"../utils.js\"\nimport { WitArtifact } from \"./WitArtifact.js\"\n\n/**\n * Wrapper class for the Wit/Oracle Radon Registry core contract as deployed in some supported EVM network.\n * It allows formal verification of Radon Requests and Witnet-compliant data sources into such network,\n * as to be securely referred on both Wit/Oracle queries pulled from within smart contracts,\n * or Wit/Oracle query results pushed into smart contracts from offchain workflows.\n */\nexport class WitOracleRadonRegistry extends WitArtifact {\n\tconstructor(signer: JsonRpcSigner, network: string) {\n\t\tsuper(signer, network, \"WitOracleRadonRegistry\")\n\t}\n\n\t/// ===========================================================================================================\n\t/// --- IWitOracleRadonRegistry -------------------------------------------------------------------------------\n\n\t/**\n\t * Determines the unique hash that would identify the given Radon Retrieval, if it was\n\t * formally verified into the connected EVM network.\n\t * @param retrieval Instance of a Radon Retrieval object.\n\t */\n\tpublic async determineRadonRetrievalHash(\n\t\tretrieval: Witnet.Radon.RadonRetrieval,\n\t): Promise<string> {\n\t\treturn this.contract\n\t\t\t.getFunction(\n\t\t\t\t\"verifyRadonRetrieval(uint8,string,string,string[2][],bytes)\",\n\t\t\t)\n\t\t\t.staticCall(...abiEncodeRadonAsset(retrieval))\n\t\t\t.then((hash) => {\n\t\t\t\treturn hash.slice(2)\n\t\t\t})\n\t}\n\n\t/**\n\t * Returns information related to some previously verified Radon Request, on the connected EVM network.\n\t * @param radHash The RAD hash that uniquely identifies the Radon Request.\n\t */\n\tpublic async lookupRadonRequest(\n\t\tradHash: string,\n\t): Promise<Witnet.Radon.RadonRequest> {\n\t\treturn this.contract\n\t\t\t.getFunction(\"lookupRadonRequestBytecode(bytes32)\")\n\t\t\t.staticCall(`0x${radHash}`)\n\t\t\t.then((bytecode) => Witnet.Radon.RadonRequest.fromBytecode(bytecode))\n\t}\n\n\t/**\n\t * Returns the bytecode of some previously verified Radon Request, on the connected EVM network.\n\t * @param radHash The RAD hash that uniquely identifies the Radon Request.\n\t */\n\tpublic async lookupRadonRequestBytecode(\n\t\tradHash: string,\n\t): Promise<Witnet.HexString> {\n\t\treturn this.contract\n\t\t\t.getFunction(\"lookupRadonRequestBytecode(bytes32)\")\n\t\t\t.staticCall(`${radHash.startsWith(\"0x\") ? radHash : `0x${radHash}`}`)\n\t}\n\n\t/**\n\t * Returns information about some previously verified Radon Retrieval on the connected EVM network.\n\t * This information includes retrieval the method, URL, body, headers and the Radon script in charge\n\t * to transform data before delivery, on the connected EVM network.\n\t * @param radHash The RAD hash that uniquely identifies the Radon Request.\n\t */\n\tpublic async lookupRadonRetrieval(\n\t\thash: string,\n\t): Promise<Witnet.Radon.RadonRetrieval> {\n\t\treturn this.contract\n\t\t\t.getFunction(\"lookupRadonRetrieval(bytes32)\")\n\t\t\t.staticCall(`0x${hash}`)\n\t\t\t.then((result: Result) => {\n\t\t\t\treturn new Witnet.Radon.RadonRetrieval({\n\t\t\t\t\tmethod: result[1],\n\t\t\t\t\turl: result[3],\n\t\t\t\t\tbody: result[4],\n\t\t\t\t\theaders: Object.fromEntries(result[5]),\n\t\t\t\t\tscript: utils.parseRadonScript(result[6]),\n\t\t\t\t})\n\t\t\t})\n\t}\n\n\t/**\n\t * Formally verify the given Radon Request object into the connected EVM network.\n\t * It also verifies all the Radon Retrieval scripts (i.e. data source) the Request\n\t * relies on, if not yet done before.\n\t *\n\t * Verifying Radon assets modifies the EVM storage and therefore requires\n\t * spending gas in proportion to the number and complexity of the data sources,\n\t * and whether these had been previously verified before or not.\n\t *\n\t * If the given Radon Request happened to be already verified, no gas would be actually consumed.\n\t *\n\t * @param request Instance of a Radon Request object.\n\t * @param options Async EVM transaction handlers.\n\t * @returns The RAD hash of the Radon Request, as verified on the connected EVM network.\n\t */\n\tpublic async verifyRadonRequest(\n\t\trequest: Witnet.Radon.RadonRequest,\n\t\toptions?: {\n\t\t\t/**\n\t\t\t * Number of block confirmations to wait for after verifying transaction gets mined (defaults to 1).\n\t\t\t */\n\t\t\tconfirmations?: number\n\t\t\t/**\n\t\t\t * Callback handler called just in case a `verifyRadonRequest` transaction is ultimately required.\n\t\t\t */\n\t\t\tonVerifyRadonRequest: (radHash: string) => any\n\t\t\t/**\n\t\t\t * Callback handler called once the `verifyRadonRequest` transaction gets confirmed.\n\t\t\t * @param receipt The `verifyRadonRequest` transaction receipt.\n\t\t\t */\n\t\t\tonVerifyRadonRequestReceipt?: (\n\t\t\t\treceipt: ContractTransactionReceipt | null,\n\t\t\t) => any\n\t\t\t/**\n\t\t\t * Callback handler called for every involved `verifyRadonRetrieval` transaction.\n\t\t\t */\n\t\t\tonVerifyRadonRetrieval?: (hash: string) => any\n\t\t\t/**\n\t\t\t * Callback handler called after every involved `verifyRadonRetrieval` transaction gets confirmed.\n\t\t\t * @param receipt The `verifyRadonRetrieval` transaction receipt.\n\t\t\t */\n\t\t\tonVerifyRadonRetrievalReceipt?: (\n\t\t\t\treceipt: ContractTransactionReceipt | null,\n\t\t\t) => any\n\t\t},\n\t): Promise<string> {\n\t\tconst radHash = request.radHash\n\t\tawait this.lookupRadonRequest(radHash).catch(async () => {\n\t\t\tconst hashes: Array<string> = []\n\t\t\tfor (const index in request.sources) {\n\t\t\t\tconst retrieval = request.sources[index]\n\t\t\t\thashes.push(`0x${await this.verifyRadonRetrieval(retrieval, options)}`)\n\t\t\t}\n\t\t\tconst aggregate = abiEncodeRadonAsset(request.sourcesReducer)\n\t\t\tconst tally = abiEncodeRadonAsset(request.witnessReducer)\n\t\t\tif (options?.onVerifyRadonRequest) {\n\t\t\t\toptions.onVerifyRadonRequest(radHash)\n\t\t\t}\n\t\t\tawait this.contract\n\t\t\t\t.getFunction(\n\t\t\t\t\t\"verifyRadonRequest(bytes32[],(uint8,(uint8,bytes)[]),(uint8,(uint8,bytes)[]))\",\n\t\t\t\t)\n\t\t\t\t.send(hashes, aggregate, tally)\n\t\t\t\t.then(async (tx) => {\n\t\t\t\t\tconst receipt = await tx.wait(options?.confirmations || 1)\n\t\t\t\t\tif (options?.onVerifyRadonRequestReceipt) {\n\t\t\t\t\t\toptions.onVerifyRadonRequestReceipt(receipt)\n\t\t\t\t\t}\n\t\t\t\t})\n\t\t})\n\t\treturn radHash\n\t}\n\n\t/**\n\t * Formally verify the given Radon Retrieval script (i.e. data source), into the connected EVM network.\n\t *\n\t * Verifying Radon assets modifies the EVM storage and therefore requires\n\t * spending gas in proportion to the size of the data source parameters (e.g. URL, body, headers, or Radon script).\n\t *\n\t * If the given Radon Retrieval object happened to be already verified, no EVM gas would be actually consumed.\n\t *\n\t * @param request Instance of a Radon Retrieval object.\n\t * @param options Async EVM transaction handlers.\n\t * @returns The unique hash of the Radon Retrieval object, as verified on the connected EVM network.\n\t */\n\tpublic async verifyRadonRetrieval(\n\t\tretrieval: Witnet.Radon.RadonRetrieval,\n\t\toptions?: {\n\t\t\t/**\n\t\t\t * Number of block confirmations to wait for after verifying transaction gets mined (defaults to 1).\n\t\t\t */\n\t\t\tconfirmations?: number\n\t\t\t/**\n\t\t\t * Callback handler called just in case a `verifyRadonRequest` transaction is ultimately required.\n\t\t\t */\n\t\t\tonVerifyRadonRetrieval?: (hash: string) => any\n\t\t\t/**\n\t\t\t * Callback handler called once the `verifyRadonRetrieval` transaction gets confirmed.\n\t\t\t * @param receipt The `verifyRadonRetrieval` transaction receipt.\n\t\t\t */\n\t\t\tonVerifyRadonRetrievalReceipt?: (\n\t\t\t\treceipt: ContractTransactionReceipt | null,\n\t\t\t) => any\n\t\t},\n\t): Promise<string> {\n\t\treturn this.determineRadonRetrievalHash(retrieval).then(async (hash) => {\n\t\t\tawait this.lookupRadonRetrieval(hash).catch(async () => {\n\t\t\t\tif (options?.onVerifyRadonRetrieval) {\n\t\t\t\t\toptions.onVerifyRadonRetrieval(hash)\n\t\t\t\t}\n\t\t\t\tawait this.contract\n\t\t\t\t\t.getFunction(\n\t\t\t\t\t\t\"verifyRadonRetrieval(uint8,string,string,string[2][],bytes)\",\n\t\t\t\t\t)\n\t\t\t\t\t.send(...abiEncodeRadonAsset(retrieval))\n\t\t\t\t\t.then(async (tx) => {\n\t\t\t\t\t\tconst receipt = await tx.wait(options?.confirmations || 1)\n\t\t\t\t\t\tif (options?.onVerifyRadonRetrievalReceipt) {\n\t\t\t\t\t\t\toptions.onVerifyRadonRetrievalReceipt(receipt)\n\t\t\t\t\t\t}\n\t\t\t\t\t})\n\t\t\t})\n\t\t\treturn hash\n\t\t})\n\t}\n}\n"]}

package/dist/src/lib/wrappers/WitOracleRadonRequestFactory.d.ts

@@ -0,0 +1,81 @@
+import { Witnet } from "@witnet/sdk";
+import type { ContractTransactionReceipt } from "ethers";
+import type { WitOracleResultDataTypes } from "../types.js";
+import { WitAppliance } from "./WitAppliance.js";
+import type { WitOracle } from "./WitOracle.js";
+import type { WitOracleRadonRegistry } from "./WitOracleRadonRegistry.js";
+export declare class WitOracleRadonRequestFactory extends WitAppliance {
+    readonly registry: WitOracleRadonRegistry;
+    protected constructor(witOracle: WitOracle, registry: WitOracleRadonRegistry, at?: string);
+    static deployed(witOracle: WitOracle, registry: WitOracleRadonRegistry): Promise<WitOracleRadonRequestFactory>;
+    deployRadonRequestTemplate(template: Witnet.Radon.RadonTemplate, options?: {
+        confirmations?: number;
+        onDeployRadonRequestTemplate?: (address: string) => any;
+        onDeployRadonRequestTemplateReceipt?: (receipt: ContractTransactionReceipt | null) => any;
+        /**
+         * Callback handler called just in case a `verifyRadonRetrieval` transaction is ultimately required.
+         */
+        onVerifyRadonRetrieval?: (hash: string) => any;
+        /**
+         * Callback handler called once the `verifyRadonRetrieval` transaction gets confirmed.
+         * @param receipt The `verifyRadonRetrieval` transaction receipt.
+         * @param hash The unique hash of the Radon Retrieval, as verified on the connected network.
+         */
+        onVerifyRadonRetrievalReceipt?: (receipt: ContractTransactionReceipt | null) => any;
+    }): Promise<WitOracleRadonRequestTemplate>;
+    deployRadonRequestModal(modal: Witnet.Radon.RadonModal, options?: {
+        confirmations?: number;
+        onDeployRadonRequestModal?: (address: string) => any;
+        onDeployRadonRequestModalReceipt?: (receipt: ContractTransactionReceipt | null) => any;
+        /**
+         * Callback handler called just in case a `verifyRadonRetrieval` transaction is ultimately required.
+         */
+        onVerifyRadonRetrieval?: (hash: string) => any;
+        /**
+         * Callback handler called once the `verifyRadonRetrieval` transaction gets confirmed.
+         * @param receipt The `verifyRadonRetrieval` transaction receipt.
+         * @param hash The unique hash of the Radon Retrieval, as verified on the connected network.
+         */
+        onVerifyRadonRetrievalReceipt?: (receipt: ContractTransactionReceipt | null) => any;
+    }): Promise<WitOracleRadonRequestModal>;
+    verifyRadonRequest(request: Witnet.Radon.RadonRequest, _options?: {
+        confirmations?: number;
+        onVerifyRadonRequest?: (address: string) => any;
+        onVerifyRadonRequestReceipt?: (receipt: ContractTransactionReceipt | null) => any;
+        /**
+         * Callback handler called just in case a `verifyRadonRetrieval` transaction is ultimately required.
+         */
+        onVerifyRadonRetrieval?: (hash: string) => any;
+        /**
+         * Callback handler called once the `verifyRadonRetrieval` transaction gets confirmed.
+         * @param receipt The `verifyRadonRetrieval` transaction receipt.
+         * @param hash The unique hash of the Radon Retrieval, as verified on the connected network.
+         */
+        onVerifyRadonRetrievalReceipt?: (receipt: ContractTransactionReceipt | null) => any;
+    }): Promise<Witnet.Hash>;
+}
+export declare class WitOracleRadonRequestModal extends WitAppliance {
+    protected constructor(witOracle: WitOracle, at: string);
+    static at(witOracle: WitOracle, target: string): Promise<WitOracleRadonRequestModal>;
+    getDataResultType(): Promise<WitOracleResultDataTypes>;
+    getDataSourcesArgsCount(): Promise<number>;
+    getRadonModalRetrieval(): Promise<Witnet.Radon.RadonRetrieval>;
+    verifyRadonRequest(dataProviders: string[], commonRetrievalArgs?: string[], options?: {
+        confirmations?: number;
+        onVerifyRadonRequest: (radHash: string) => any;
+        onVerifyRadonRequestReceipt: (receipt: ContractTransactionReceipt | null) => any;
+    }): Promise<Witnet.Hash>;
+}
+export declare class WitOracleRadonRequestTemplate extends WitAppliance {
+    protected constructor(witOracle: WitOracle, at: string);
+    static at(witOracle: WitOracle, target: string): Promise<WitOracleRadonRequestTemplate>;
+    getDataResultType(): Promise<WitOracleResultDataTypes>;
+    getDataSources(): Promise<Array<Witnet.Radon.RadonRetrieval>>;
+    getDataSourcesArgsCount(): Promise<Array<number>>;
+    verifyRadonRequest(args: string | string[] | Array<string[]>, options?: {
+        confirmations?: number;
+        onVerifyRadonRequest: (radHash: string) => any;
+        onVerifyRadonRequestReceipt: (receipt: ContractTransactionReceipt | null) => any;
+    }): Promise<Witnet.HexString>;
+}
+//# sourceMappingURL=WitOracleRadonRequestFactory.d.ts.map

package/dist/src/lib/wrappers/WitOracleRadonRequestFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WitOracleRadonRequestFactory.d.ts","sourceRoot":"","sources":["../../../../src/lib/wrappers/WitOracleRadonRequestFactory.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/wrappers/WitOracleRadonRequestFactory.js

@@ -0,0 +1,257 @@
+import { Witnet } from "@witnet/sdk";
+import { abiEncodeRadonAsset, parseRadonScript } from "../utils.js";
+import { WitAppliance } from "./WitAppliance.js";
+export class WitOracleRadonRequestFactory extends WitAppliance {
+    registry;
+    constructor(witOracle, registry, at) {
+        super(witOracle, "WitOracleRadonRequestFactory", at);
+        this.registry = registry;
+    }
+    static async deployed(witOracle, registry) {
+        const deployer = new WitOracleRadonRequestFactory(witOracle, registry);
+        const witOracleRegistryAddress = await witOracle.contract.registry.staticCall();
+        if (registry.address !== witOracleRegistryAddress) {
+            throw new Error(`${WitOracleRadonRequestFactory.constructor.name} at ${deployer.address}: uncompliant WitOracleRadonRegistry at ${registry.address})`);
+        }
+        return deployer;
+    }
+    async deployRadonRequestTemplate(template, options) {
+        const hashes = [];
+        for (const index in template.sources) {
+            const retrieval = template.sources[index];
+            const hash = `0x${await this.registry.determineRadonRetrievalHash(retrieval)}`;
+            await this.registry.verifyRadonRetrieval(retrieval, options);
+            hashes.push(hash);
+        }
+        const aggregator = abiEncodeRadonAsset(template.sourcesReducer);
+        const tally = abiEncodeRadonAsset(template.witnessReducer);
+        const target = await this.contract
+            .getFunction("buildRadonRequestTemplate(bytes32[],(uint8,(uint8,bytes)[]),(uint8,(uint8,bytes)[]))")
+            .staticCall(hashes, aggregator, tally);
+        if (options?.onDeployRadonRequestTemplate)
+            options.onDeployRadonRequestTemplate(target);
+        await this.contract
+            .getFunction("buildRadonRequestTemplate(bytes32[],(uint8,(uint8,bytes)[]),(uint8,(uint8,bytes)[]))")
+            .send(hashes, aggregator, tally)
+            .then(async (tx) => {
+            const receipt = await tx.wait(options?.confirmations || 1);
+            if (options?.onDeployRadonRequestTemplateReceipt) {
+                options.onDeployRadonRequestTemplateReceipt(receipt);
+            }
+        });
+        return await WitOracleRadonRequestTemplate.at(this.witOracle, target);
+    }
+    async deployRadonRequestModal(modal, options) {
+        const retrieval = [
+            modal.sources[0].method,
+            modal.sources[0].body || "",
+            modal.sources[0]?.headers ? Object.entries(modal.sources[0].headers) : [],
+            modal.sources[0].script?.toBytecode() || "0x",
+        ];
+        const tally = abiEncodeRadonAsset(modal.witnessReducer);
+        const target = await this.contract.buildRadonRequestModal //getFunction("buildRadonRequestModal((uint8,string,string[2][],bytes),(uint8,(uint8,bytes)[]))")
+            .staticCall(retrieval, tally);
+        if (options?.onDeployRadonRequestModal)
+            options.onDeployRadonRequestModal(target);
+        await this.contract.buildRadonRequestModal
+            // .getFunction("buildRadonRequestModal((uint8,string,string[2][],bytes),(uint8,(uint8,bytes)[]))")
+            .send(retrieval, tally)
+            .then(async (tx) => {
+            const receipt = await tx.wait(options?.confirmations || 1);
+            if (options?.onDeployRadonRequestModalReceipt) {
+                options.onDeployRadonRequestModalReceipt(receipt);
+            }
+        });
+        return await WitOracleRadonRequestModal.at(this.witOracle, target);
+    }
+    async verifyRadonRequest(request, _options) {
+        // TODO:
+        //
+        return request.radHash;
+    }
+}
+export class WitOracleRadonRequestModal extends WitAppliance {
+    constructor(witOracle, at) {
+        super(witOracle, "WitOracleRadonRequestModal", at);
+    }
+    static async at(witOracle, target) {
+        const template = new WitOracleRadonRequestModal(witOracle, target);
+        const templateWitOracleAddr = await template.contract.witOracle.staticCall();
+        if (templateWitOracleAddr !== witOracle.address) {
+            throw new Error(`${WitOracleRadonRequestModal.constructor.name} at ${target}: mismatching Wit/Oracle address (${templateWitOracleAddr})`);
+        }
+        return template;
+    }
+    async getDataResultType() {
+        return this.contract
+            .getFunction("getDataResultType()")
+            .staticCall()
+            .then((result) => {
+            switch (Number(result)) {
+                case 1:
+                    return "array";
+                case 2:
+                    return "boolean";
+                case 3:
+                    return "bytes";
+                case 4:
+                    return "integer";
+                case 5:
+                    return "float";
+                case 6:
+                    return "map";
+                case 7:
+                    return "string";
+                default:
+                    return "any";
+            }
+        });
+    }
+    async getDataSourcesArgsCount() {
+        return this.contract
+            .getFunction("getDataSourcesArgsCount()")
+            .staticCall()
+            .then((argsCount) => Number(argsCount));
+    }
+    async getRadonModalRetrieval() {
+        return this.contract
+            .getFunction("getRadonModalRetrieval()")
+            .staticCall()
+            .then((result) => {
+            return new Witnet.Radon.RadonRetrieval({
+                method: result[1],
+                url: result[3],
+                body: result[4],
+                headers: Object.fromEntries(result[5]),
+                script: parseRadonScript(result[6]),
+            });
+        });
+    }
+    async verifyRadonRequest(dataProviders, commonRetrievalArgs, options) {
+        const argsCount = await this.getDataSourcesArgsCount();
+        if (argsCount !== 1 + (commonRetrievalArgs?.length || 0)) {
+            throw TypeError(`${this.constructor.name}@${this.address}: unmatching args count != ${argsCount - 1}.`);
+        }
+        const method = this.contract.getFunction("verifyRadonRequest(string[],string[])");
+        const radHash = (await method.staticCall(commonRetrievalArgs || [], dataProviders)).slice(2);
+        try {
+            await (await this.witOracle.getWitOracleRadonRegistry()).lookupRadonRequestBytecode(radHash);
+        }
+        catch {
+            if (options?.onVerifyRadonRequest)
+                options.onVerifyRadonRequest(radHash);
+            await method
+                .send(commonRetrievalArgs || [], dataProviders)
+                .then((tx) => tx.wait(options?.confirmations || 1))
+                .then((receipt) => {
+                if (options?.onVerifyRadonRequestReceipt) {
+                    options.onVerifyRadonRequestReceipt(receipt);
+                }
+                return radHash;
+            });
+        }
+        return radHash;
+    }
+}
+export class WitOracleRadonRequestTemplate extends WitAppliance {
+    constructor(witOracle, at) {
+        super(witOracle, "WitOracleRadonRequestTemplate", at);
+    }
+    static async at(witOracle, target) {
+        const template = new WitOracleRadonRequestTemplate(witOracle, target);
+        const templateWitOracleAddr = await template.contract.witOracle.staticCall();
+        if (templateWitOracleAddr !== witOracle.address) {
+            throw new Error(`${WitOracleRadonRequestTemplate.constructor.name} at ${target}: mismatching Wit/Oracle address (${templateWitOracleAddr})`);
+        }
+        return template;
+    }
+    async getDataResultType() {
+        return this.contract
+            .getFunction("getDataResultType()")
+            .staticCall()
+            .then((result) => {
+            switch (Number(result)) {
+                case 1:
+                    return "array";
+                case 2:
+                    return "boolean";
+                case 3:
+                    return "bytes";
+                case 4:
+                    return "integer";
+                case 5:
+                    return "float";
+                case 6:
+                    return "map";
+                case 7:
+                    return "string";
+                default:
+                    return "any";
+            }
+        });
+    }
+    async getDataSources() {
+        return this.contract
+            .getFunction("getDataSources()")
+            .staticCall()
+            .then((results) => {
+            return results.map((result) => new Witnet.Radon.RadonRetrieval({
+                method: result[1],
+                url: result[3],
+                body: result[4],
+                headers: Object.fromEntries(result[5]),
+                script: parseRadonScript(result[6]),
+            }));
+        });
+    }
+    async getDataSourcesArgsCount() {
+        return this.contract
+            .getFunction("getDataSourcesArgsCount()")
+            .staticCall()
+            .then((dims) => dims.map((dim) => Number(dim)));
+    }
+    async verifyRadonRequest(args, options) {
+        const argsCount = await this.getDataSourcesArgsCount();
+        let encodedArgs = [];
+        if (typeof args === "string") {
+            if (argsCount.length === 1 && argsCount[0] === 1) {
+                encodedArgs = [[args]];
+            }
+        }
+        else if (Array.isArray(args)) {
+            if (Array.isArray(args[0])) {
+                if (argsCount.length === args.length &&
+                    !args.find((subargs, index) => subargs.length !== argsCount[index])) {
+                    encodedArgs = args;
+                }
+            }
+            else if (args.length === argsCount[0] &&
+                !args.find((arg) => typeof arg !== "string")) {
+                encodedArgs = [args];
+            }
+        }
+        if (encodedArgs.length === 0) {
+            throw TypeError(`${this.constructor.name}@${this.address}: unmatching args count != [${argsCount}, ].`);
+        }
+        const method = this.contract.getFunction("verifyRadonRequest(string[][])");
+        const radHash = (await method.staticCall(encodedArgs)).slice(2);
+        try {
+            await (await this.witOracle.getWitOracleRadonRegistry()).lookupRadonRequestBytecode(radHash);
+        }
+        catch {
+            if (options?.onVerifyRadonRequest)
+                options.onVerifyRadonRequest(radHash);
+            await method
+                .send(encodedArgs)
+                .then((tx) => tx.wait(options?.confirmations || 1))
+                .then((receipt) => {
+                if (options?.onVerifyRadonRequestReceipt) {
+                    options.onVerifyRadonRequestReceipt(receipt);
+                }
+                return radHash;
+            });
+        }
+        return radHash;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"WitOracleRadonRequestFactory.js","sourceRoot":"","sources":["../../../../src/lib/wrappers/WitOracleRadonRequestFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import { Witnet } from \"@witnet/sdk\"\nimport type { ContractTransactionReceipt, Result } from \"ethers\"\nimport type { WitOracleResultDataTypes } from \"../types.js\"\nimport { abiEncodeRadonAsset, parseRadonScript } from \"../utils.js\"\nimport { WitAppliance } from \"./WitAppliance.js\"\nimport type { WitOracle } from \"./WitOracle.js\"\nimport type { WitOracleRadonRegistry } from \"./WitOracleRadonRegistry.js\"\n\nexport class WitOracleRadonRequestFactory extends WitAppliance {\n\tpublic readonly registry: WitOracleRadonRegistry\n\n\tprotected constructor(\n\t\twitOracle: WitOracle,\n\t\tregistry: WitOracleRadonRegistry,\n\t\tat?: string,\n\t) {\n\t\tsuper(witOracle, \"WitOracleRadonRequestFactory\", at)\n\t\tthis.registry = registry\n\t}\n\n\tstatic async deployed(\n\t\twitOracle: WitOracle,\n\t\tregistry: WitOracleRadonRegistry,\n\t): Promise<WitOracleRadonRequestFactory> {\n\t\tconst deployer = new WitOracleRadonRequestFactory(witOracle, registry)\n\t\tconst witOracleRegistryAddress =\n\t\t\tawait witOracle.contract.registry.staticCall()\n\t\tif (registry.address !== witOracleRegistryAddress) {\n\t\t\tthrow new Error(\n\t\t\t\t`${WitOracleRadonRequestFactory.constructor.name} at ${deployer.address}: uncompliant WitOracleRadonRegistry at ${registry.address})`,\n\t\t\t)\n\t\t}\n\t\treturn deployer\n\t}\n\n\tpublic async deployRadonRequestTemplate(\n\t\ttemplate: Witnet.Radon.RadonTemplate,\n\t\toptions?: {\n\t\t\tconfirmations?: number\n\t\t\tonDeployRadonRequestTemplate?: (address: string) => any\n\t\t\tonDeployRadonRequestTemplateReceipt?: (\n\t\t\t\treceipt: ContractTransactionReceipt | null,\n\t\t\t) => any\n\t\t\t/**\n\t\t\t * Callback handler called just in case a `verifyRadonRetrieval` transaction is ultimately required.\n\t\t\t */\n\t\t\tonVerifyRadonRetrieval?: (hash: string) => any\n\t\t\t/**\n\t\t\t * Callback handler called once the `verifyRadonRetrieval` transaction gets confirmed.\n\t\t\t * @param receipt The `verifyRadonRetrieval` transaction receipt.\n\t\t\t * @param hash The unique hash of the Radon Retrieval, as verified on the connected network.\n\t\t\t */\n\t\t\tonVerifyRadonRetrievalReceipt?: (\n\t\t\t\treceipt: ContractTransactionReceipt | null,\n\t\t\t) => any\n\t\t},\n\t): Promise<WitOracleRadonRequestTemplate> {\n\t\tconst hashes: Array<string> = []\n\t\tfor (const index in template.sources) {\n\t\t\tconst retrieval = template.sources[index]\n\t\t\tconst hash = `0x${await this.registry.determineRadonRetrievalHash(retrieval)}`\n\t\t\tawait this.registry.verifyRadonRetrieval(retrieval, options)\n\t\t\thashes.push(hash)\n\t\t}\n\n\t\tconst aggregator = abiEncodeRadonAsset(template.sourcesReducer)\n\t\tconst tally = abiEncodeRadonAsset(template.witnessReducer)\n\t\tconst target = await this.contract\n\t\t\t.getFunction(\n\t\t\t\t\"buildRadonRequestTemplate(bytes32[],(uint8,(uint8,bytes)[]),(uint8,(uint8,bytes)[]))\",\n\t\t\t)\n\t\t\t.staticCall(hashes, aggregator, tally)\n\n\t\tif (options?.onDeployRadonRequestTemplate)\n\t\t\toptions.onDeployRadonRequestTemplate(target)\n\t\tawait this.contract\n\t\t\t.getFunction(\n\t\t\t\t\"buildRadonRequestTemplate(bytes32[],(uint8,(uint8,bytes)[]),(uint8,(uint8,bytes)[]))\",\n\t\t\t)\n\t\t\t.send(hashes, aggregator, tally)\n\t\t\t.then(async (tx) => {\n\t\t\t\tconst receipt = await tx.wait(options?.confirmations || 1)\n\t\t\t\tif (options?.onDeployRadonRequestTemplateReceipt) {\n\t\t\t\t\toptions.onDeployRadonRequestTemplateReceipt(receipt)\n\t\t\t\t}\n\t\t\t})\n\n\t\treturn await WitOracleRadonRequestTemplate.at(this.witOracle, target)\n\t}\n\n\tpublic async deployRadonRequestModal(\n\t\tmodal: Witnet.Radon.RadonModal,\n\t\toptions?: {\n\t\t\tconfirmations?: number\n\t\t\tonDeployRadonRequestModal?: (address: string) => any\n\t\t\tonDeployRadonRequestModalReceipt?: (\n\t\t\t\treceipt: ContractTransactionReceipt | null,\n\t\t\t) => any\n\t\t\t/**\n\t\t\t * Callback handler called just in case a `verifyRadonRetrieval` transaction is ultimately required.\n\t\t\t */\n\t\t\tonVerifyRadonRetrieval?: (hash: string) => any\n\t\t\t/**\n\t\t\t * Callback handler called once the `verifyRadonRetrieval` transaction gets confirmed.\n\t\t\t * @param receipt The `verifyRadonRetrieval` transaction receipt.\n\t\t\t * @param hash The unique hash of the Radon Retrieval, as verified on the connected network.\n\t\t\t */\n\t\t\tonVerifyRadonRetrievalReceipt?: (\n\t\t\t\treceipt: ContractTransactionReceipt | null,\n\t\t\t) => any\n\t\t},\n\t): Promise<WitOracleRadonRequestModal> {\n\t\tconst retrieval = [\n\t\t\tmodal.sources[0].method,\n\t\t\tmodal.sources[0].body || \"\",\n\t\t\tmodal.sources[0]?.headers ? Object.entries(modal.sources[0].headers) : [],\n\t\t\tmodal.sources[0].script?.toBytecode() || \"0x\",\n\t\t]\n\t\tconst tally = abiEncodeRadonAsset(modal.witnessReducer)\n\t\tconst target = await this.contract.buildRadonRequestModal //getFunction(\"buildRadonRequestModal((uint8,string,string[2][],bytes),(uint8,(uint8,bytes)[]))\")\n\t\t\t.staticCall(retrieval, tally)\n\n\t\tif (options?.onDeployRadonRequestModal)\n\t\t\toptions.onDeployRadonRequestModal(target)\n\t\tawait this.contract.buildRadonRequestModal\n\t\t\t// .getFunction(\"buildRadonRequestModal((uint8,string,string[2][],bytes),(uint8,(uint8,bytes)[]))\")\n\t\t\t.send(retrieval, tally)\n\t\t\t.then(async (tx) => {\n\t\t\t\tconst receipt = await tx.wait(options?.confirmations || 1)\n\t\t\t\tif (options?.onDeployRadonRequestModalReceipt) {\n\t\t\t\t\toptions.onDeployRadonRequestModalReceipt(receipt)\n\t\t\t\t}\n\t\t\t})\n\n\t\treturn await WitOracleRadonRequestModal.at(this.witOracle, target)\n\t}\n\n\tpublic async verifyRadonRequest(\n\t\trequest: Witnet.Radon.RadonRequest,\n\t\t_options?: {\n\t\t\tconfirmations?: number\n\t\t\tonVerifyRadonRequest?: (address: string) => any\n\t\t\tonVerifyRadonRequestReceipt?: (\n\t\t\t\treceipt: ContractTransactionReceipt | null,\n\t\t\t) => any\n\t\t\t/**\n\t\t\t * Callback handler called just in case a `verifyRadonRetrieval` transaction is ultimately required.\n\t\t\t */\n\t\t\tonVerifyRadonRetrieval?: (hash: string) => any\n\t\t\t/**\n\t\t\t * Callback handler called once the `verifyRadonRetrieval` transaction gets confirmed.\n\t\t\t * @param receipt The `verifyRadonRetrieval` transaction receipt.\n\t\t\t * @param hash The unique hash of the Radon Retrieval, as verified on the connected network.\n\t\t\t */\n\t\t\tonVerifyRadonRetrievalReceipt?: (\n\t\t\t\treceipt: ContractTransactionReceipt | null,\n\t\t\t) => any\n\t\t},\n\t): Promise<Witnet.Hash> {\n\t\t// TODO:\n\t\t//\n\t\treturn request.radHash\n\t}\n}\n\nexport class WitOracleRadonRequestModal extends WitAppliance {\n\tprotected constructor(witOracle: WitOracle, at: string) {\n\t\tsuper(witOracle, \"WitOracleRadonRequestModal\", at)\n\t}\n\n\tstatic async at(\n\t\twitOracle: WitOracle,\n\t\ttarget: string,\n\t): Promise<WitOracleRadonRequestModal> {\n\t\tconst template = new WitOracleRadonRequestModal(witOracle, target)\n\t\tconst templateWitOracleAddr = await template.contract.witOracle.staticCall()\n\t\tif (templateWitOracleAddr !== witOracle.address) {\n\t\t\tthrow new Error(\n\t\t\t\t`${WitOracleRadonRequestModal.constructor.name} at ${target}: mismatching Wit/Oracle address (${templateWitOracleAddr})`,\n\t\t\t)\n\t\t}\n\t\treturn template\n\t}\n\n\tpublic async getDataResultType(): Promise<WitOracleResultDataTypes> {\n\t\treturn this.contract\n\t\t\t.getFunction(\"getDataResultType()\")\n\t\t\t.staticCall()\n\t\t\t.then((result: number) => {\n\t\t\t\tswitch (Number(result)) {\n\t\t\t\t\tcase 1:\n\t\t\t\t\t\treturn \"array\"\n\t\t\t\t\tcase 2:\n\t\t\t\t\t\treturn \"boolean\"\n\t\t\t\t\tcase 3:\n\t\t\t\t\t\treturn \"bytes\"\n\t\t\t\t\tcase 4:\n\t\t\t\t\t\treturn \"integer\"\n\t\t\t\t\tcase 5:\n\t\t\t\t\t\treturn \"float\"\n\t\t\t\t\tcase 6:\n\t\t\t\t\t\treturn \"map\"\n\t\t\t\t\tcase 7:\n\t\t\t\t\t\treturn \"string\"\n\t\t\t\t\tdefault:\n\t\t\t\t\t\treturn \"any\"\n\t\t\t\t}\n\t\t\t})\n\t}\n\n\tpublic async getDataSourcesArgsCount(): Promise<number> {\n\t\treturn this.contract\n\t\t\t.getFunction(\"getDataSourcesArgsCount()\")\n\t\t\t.staticCall()\n\t\t\t.then((argsCount: bigint) => Number(argsCount))\n\t}\n\n\tpublic async getRadonModalRetrieval(): Promise<Witnet.Radon.RadonRetrieval> {\n\t\treturn this.contract\n\t\t\t.getFunction(\"getRadonModalRetrieval()\")\n\t\t\t.staticCall()\n\t\t\t.then((result: Result) => {\n\t\t\t\treturn new Witnet.Radon.RadonRetrieval({\n\t\t\t\t\tmethod: result[1],\n\t\t\t\t\turl: result[3],\n\t\t\t\t\tbody: result[4],\n\t\t\t\t\theaders: Object.fromEntries(result[5]),\n\t\t\t\t\tscript: parseRadonScript(result[6]),\n\t\t\t\t})\n\t\t\t})\n\t}\n\n\tpublic async verifyRadonRequest(\n\t\tdataProviders: string[],\n\t\tcommonRetrievalArgs?: string[],\n\t\toptions?: {\n\t\t\tconfirmations?: number\n\t\t\tonVerifyRadonRequest: (radHash: string) => any\n\t\t\tonVerifyRadonRequestReceipt: (\n\t\t\t\treceipt: ContractTransactionReceipt | null,\n\t\t\t) => any\n\t\t},\n\t): Promise<Witnet.Hash> {\n\t\tconst argsCount = await this.getDataSourcesArgsCount()\n\t\tif (argsCount !== 1 + (commonRetrievalArgs?.length || 0)) {\n\t\t\tthrow TypeError(\n\t\t\t\t`${this.constructor.name}@${this.address}: unmatching args count != ${argsCount - 1}.`,\n\t\t\t)\n\t\t}\n\t\tconst method = this.contract.getFunction(\n\t\t\t\"verifyRadonRequest(string[],string[])\",\n\t\t)\n\t\tconst radHash = (\n\t\t\tawait method.staticCall(commonRetrievalArgs || [], dataProviders)\n\t\t).slice(2)\n\t\ttry {\n\t\t\tawait (\n\t\t\t\tawait this.witOracle.getWitOracleRadonRegistry()\n\t\t\t).lookupRadonRequestBytecode(radHash)\n\t\t} catch {\n\t\t\tif (options?.onVerifyRadonRequest) options.onVerifyRadonRequest(radHash)\n\t\t\tawait method\n\t\t\t\t.send(commonRetrievalArgs || [], dataProviders)\n\t\t\t\t.then((tx) => tx.wait(options?.confirmations || 1))\n\t\t\t\t.then((receipt) => {\n\t\t\t\t\tif (options?.onVerifyRadonRequestReceipt) {\n\t\t\t\t\t\toptions.onVerifyRadonRequestReceipt(receipt)\n\t\t\t\t\t}\n\t\t\t\t\treturn radHash\n\t\t\t\t})\n\t\t}\n\t\treturn radHash\n\t}\n}\n\nexport class WitOracleRadonRequestTemplate extends WitAppliance {\n\tprotected constructor(witOracle: WitOracle, at: string) {\n\t\tsuper(witOracle, \"WitOracleRadonRequestTemplate\", at)\n\t}\n\n\tstatic async at(\n\t\twitOracle: WitOracle,\n\t\ttarget: string,\n\t): Promise<WitOracleRadonRequestTemplate> {\n\t\tconst template = new WitOracleRadonRequestTemplate(witOracle, target)\n\t\tconst templateWitOracleAddr = await template.contract.witOracle.staticCall()\n\t\tif (templateWitOracleAddr !== witOracle.address) {\n\t\t\tthrow new Error(\n\t\t\t\t`${WitOracleRadonRequestTemplate.constructor.name} at ${target}: mismatching Wit/Oracle address (${templateWitOracleAddr})`,\n\t\t\t)\n\t\t}\n\t\treturn template\n\t}\n\n\tpublic async getDataResultType(): Promise<WitOracleResultDataTypes> {\n\t\treturn this.contract\n\t\t\t.getFunction(\"getDataResultType()\")\n\t\t\t.staticCall()\n\t\t\t.then((result: number) => {\n\t\t\t\tswitch (Number(result)) {\n\t\t\t\t\tcase 1:\n\t\t\t\t\t\treturn \"array\"\n\t\t\t\t\tcase 2:\n\t\t\t\t\t\treturn \"boolean\"\n\t\t\t\t\tcase 3:\n\t\t\t\t\t\treturn \"bytes\"\n\t\t\t\t\tcase 4:\n\t\t\t\t\t\treturn \"integer\"\n\t\t\t\t\tcase 5:\n\t\t\t\t\t\treturn \"float\"\n\t\t\t\t\tcase 6:\n\t\t\t\t\t\treturn \"map\"\n\t\t\t\t\tcase 7:\n\t\t\t\t\t\treturn \"string\"\n\t\t\t\t\tdefault:\n\t\t\t\t\t\treturn \"any\"\n\t\t\t\t}\n\t\t\t})\n\t}\n\n\tpublic async getDataSources(): Promise<Array<Witnet.Radon.RadonRetrieval>> {\n\t\treturn this.contract\n\t\t\t.getFunction(\"getDataSources()\")\n\t\t\t.staticCall()\n\t\t\t.then((results: Array<Result>) => {\n\t\t\t\treturn results.map(\n\t\t\t\t\t(result) =>\n\t\t\t\t\t\tnew Witnet.Radon.RadonRetrieval({\n\t\t\t\t\t\t\tmethod: result[1],\n\t\t\t\t\t\t\turl: result[3],\n\t\t\t\t\t\t\tbody: result[4],\n\t\t\t\t\t\t\theaders: Object.fromEntries(result[5]),\n\t\t\t\t\t\t\tscript: parseRadonScript(result[6]),\n\t\t\t\t\t\t}),\n\t\t\t\t)\n\t\t\t})\n\t}\n\n\tpublic async getDataSourcesArgsCount(): Promise<Array<number>> {\n\t\treturn this.contract\n\t\t\t.getFunction(\"getDataSourcesArgsCount()\")\n\t\t\t.staticCall()\n\t\t\t.then((dims: Array<bigint>) => dims.map((dim) => Number(dim)))\n\t}\n\n\tpublic async verifyRadonRequest(\n\t\targs: string | string[] | Array<string[]>,\n\t\toptions?: {\n\t\t\tconfirmations?: number\n\t\t\tonVerifyRadonRequest: (radHash: string) => any\n\t\t\tonVerifyRadonRequestReceipt: (\n\t\t\t\treceipt: ContractTransactionReceipt | null,\n\t\t\t) => any\n\t\t},\n\t): Promise<Witnet.HexString> {\n\t\tconst argsCount = await this.getDataSourcesArgsCount()\n\t\tlet encodedArgs: Array<string[]> = []\n\t\tif (typeof args === \"string\") {\n\t\t\tif (argsCount.length === 1 && argsCount[0] === 1) {\n\t\t\t\tencodedArgs = [[args as string]]\n\t\t\t}\n\t\t} else if (Array.isArray(args)) {\n\t\t\tif (Array.isArray(args[0])) {\n\t\t\t\tif (\n\t\t\t\t\targsCount.length === args.length &&\n\t\t\t\t\t!args.find((subargs, index) => subargs.length !== argsCount[index])\n\t\t\t\t) {\n\t\t\t\t\tencodedArgs = args as Array<string[]>\n\t\t\t\t}\n\t\t\t} else if (\n\t\t\t\targs.length === argsCount[0] &&\n\t\t\t\t!args.find((arg) => typeof arg !== \"string\")\n\t\t\t) {\n\t\t\t\tencodedArgs = [args as string[]]\n\t\t\t}\n\t\t}\n\t\tif (encodedArgs.length === 0) {\n\t\t\tthrow TypeError(\n\t\t\t\t`${this.constructor.name}@${this.address}: unmatching args count != [${argsCount}, ].`,\n\t\t\t)\n\t\t}\n\t\tconst method = this.contract.getFunction(\"verifyRadonRequest(string[][])\")\n\t\tconst radHash = (await method.staticCall(encodedArgs)).slice(2)\n\t\ttry {\n\t\t\tawait (\n\t\t\t\tawait this.witOracle.getWitOracleRadonRegistry()\n\t\t\t).lookupRadonRequestBytecode(radHash)\n\t\t} catch {\n\t\t\tif (options?.onVerifyRadonRequest) options.onVerifyRadonRequest(radHash)\n\t\t\tawait method\n\t\t\t\t.send(encodedArgs)\n\t\t\t\t.then((tx) => tx.wait(options?.confirmations || 1))\n\t\t\t\t.then((receipt) => {\n\t\t\t\t\tif (options?.onVerifyRadonRequestReceipt) {\n\t\t\t\t\t\toptions.onVerifyRadonRequestReceipt(receipt)\n\t\t\t\t\t}\n\t\t\t\t\treturn radHash\n\t\t\t\t})\n\t\t}\n\t\treturn radHash\n\t}\n}\n"]}