@api3/commons 0.4.1 → 0.6.0

package/README.md

@@ -43,12 +43,14 @@ import { createLogger } from '@api3/commons/logger';
 
 To release a new version follow these steps:
 
-1. `git checkout main` - Always publish from `main` branch. Also, ensure that the working directory is clean (has no
-   uncommitted changes).
+1. `git checkout main && git pull` - Always publish from up to date `main` branch. Also, ensure that the working
+   directory is clean (has no uncommitted changes).
 2. `pnpm version [major|minor|patch]` - Choose the right version bump. This will bump the version, create a git tag and
    commit it.
-3. `pnpm publish --access public` - Publish the new version to NPM.
-4. `git push --follow-tags` - Push the tagged commit upstream.
+3. `pnpm publish --access public` - Build the package and publish the new version to NPM.
+4. `git push --follow-tags` - Push the tagged commit upstream. If you don't have access to push directly to main branch,
+   create a separate branch and open a PR. This PR must be merged using the "Rebase and merge" strategy to preserve the
+   git tag.
 5. Create a new [release on GitHub](https://github.com/api3dao/commons/releases). Use the "Generate release notes"
    feature to generate the release notes from the PR titles.
 

package/dist/blockchain-utilities/derivation.d.ts

@@ -0,0 +1,78 @@
+import { ethers } from 'ethers';
+export declare const PROTOCOL_IDS: {
+    RRP: string;
+    PSP: string;
+    RELAYED_RRP: string;
+    RELAYED_PSP: string;
+    AIRSEEKER: string;
+};
+/**
+ * An interface that reflects the structure of a Template
+ */
+export interface Template {
+    airnode: string;
+    encodedParameters: string;
+    endpointId: string;
+}
+/**
+ * Derives a template ID from the input parameters
+ *
+ * @param airnode an Airnode address
+ * @param encodedParameters encoded parameters, see the airnode/abi package's encode function
+ * @param endpointId An endpointID (see deriveEndpointId)
+ */
+export declare const deriveTemplateId: ({ airnode, encodedParameters, endpointId }: Template) => string;
+/**
+ * Derives an endpoint ID
+ *
+ * @param oisTitle the OIS title
+ * @param endpointName the endpoint name
+ */
+export declare const deriveEndpointId: (oisTitle: string, endpointName: string) => string;
+/**
+ * Derives an airnode address's xpub, required for allowing signed data consumers to verify authenticity
+ *
+ * @param airnodeMnemonic the airnode's mnemonic
+ */
+export declare const deriveAirnodeXpub: (airnodeMnemonic: string) => string;
+/**
+ * Derives a wallet path from a sponsor address, used for calculating a sponsor wallet.
+ *
+ * @param sponsorAddress an EVM-compatible address
+ * @param protocolId an API application protocol ID
+ */
+export declare function deriveWalletPathFromSponsorAddress(sponsorAddress: string, protocolId: string): string;
+/**
+ * Encodes/formats a string as a hex-encoded bytes32 string.
+ *
+ * @param input the input string
+ */
+export declare const toBytes32String: (input: string) => string;
+/**
+ * Decodes a hex-encoded bytes32 string to a normal string.
+ *
+ * @param input the input hex string
+ */
+export declare const fromBytes32String: (input: string) => string;
+/**
+ * Derives a sponsor wallet, given a mnemonic and dapiName.
+ *
+ * @param sponsorWalletMnemonic the sponsor wallet mnemonic
+ * @param dapiName the dapi name
+ */
+export declare const deriveSponsorWallet: (sponsorWalletMnemonic: string, dapiName: string) => ethers.Wallet;
+/**
+ * Derives the ID of a single beacon
+ *
+ * @param airnodeAddress the airnode address of the provider that supplies the data used to update this beacon
+ * @param templateId the templateId of the template used to generate the data used to update this beacon
+ */
+export declare const deriveBeaconId: (airnodeAddress: string, templateId: string) => string;
+/**
+ * Derives the ID of a set of beacons.
+ * By convention beacon IDs are sorted alphabetically - the ordering impacts the resulting hash.
+ *
+ * @param beaconIds an ordered array of beacon ids
+ */
+export declare const deriveBeaconSetId: (beaconIds: string[]) => string;
+//# sourceMappingURL=derivation.d.ts.map

package/dist/blockchain-utilities/derivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivation.d.ts","sourceRoot":"","sources":["../../src/blockchain-utilities/derivation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIhC,eAAO,MAAM,YAAY;;;;;;CAMxB,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,+CAAgD,QAAQ,WACsB,CAAC;AAE5G;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,aAAc,MAAM,gBAAgB,MAAM,WACsC,CAAC;AAE9G;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,oBAAqB,MAAM,WAC0C,CAAC;AAEpG;;;;;GAKG;AACH,wBAAgB,kCAAkC,CAAC,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,UAU5F;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe,UAAW,MAAM,WAA4C,CAAC;AAE1F;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,UAAW,MAAM,WAA2C,CAAC;AAE3F;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,0BAA2B,MAAM,YAAY,MAAM,kBAWlF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,mBAAoB,MAAM,cAAc,MAAM,WACa,CAAC;AAEvF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,cAAe,MAAM,EAAE,WACoC,CAAC"}

package/dist/blockchain-utilities/derivation.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveBeaconSetId = exports.deriveBeaconId = exports.deriveSponsorWallet = exports.fromBytes32String = exports.toBytes32String = exports.deriveWalletPathFromSponsorAddress = exports.deriveAirnodeXpub = exports.deriveEndpointId = exports.deriveTemplateId = exports.PROTOCOL_IDS = void 0;
+const ethers_1 = require("ethers");
+const schema_1 = require("./schema");
+exports.PROTOCOL_IDS = {
+    RRP: '1',
+    PSP: '2',
+    RELAYED_RRP: '3',
+    RELAYED_PSP: '4',
+    AIRSEEKER: '5',
+};
+/**
+ * Derives a template ID from the input parameters
+ *
+ * @param airnode an Airnode address
+ * @param encodedParameters encoded parameters, see the airnode/abi package's encode function
+ * @param endpointId An endpointID (see deriveEndpointId)
+ */
+const deriveTemplateId = ({ airnode, encodedParameters, endpointId }) => ethers_1.ethers.utils.solidityKeccak256(['address', 'bytes32', 'bytes'], [airnode, endpointId, encodedParameters]);
+exports.deriveTemplateId = deriveTemplateId;
+/**
+ * Derives an endpoint ID
+ *
+ * @param oisTitle the OIS title
+ * @param endpointName the endpoint name
+ */
+const deriveEndpointId = (oisTitle, endpointName) => ethers_1.ethers.utils.keccak256(ethers_1.ethers.utils.defaultAbiCoder.encode(['string', 'string'], [oisTitle, endpointName]));
+exports.deriveEndpointId = deriveEndpointId;
+/**
+ * Derives an airnode address's xpub, required for allowing signed data consumers to verify authenticity
+ *
+ * @param airnodeMnemonic the airnode's mnemonic
+ */
+const deriveAirnodeXpub = (airnodeMnemonic) => ethers_1.ethers.utils.HDNode.fromMnemonic(airnodeMnemonic).derivePath("m/44'/60'/0'").neuter().extendedKey;
+exports.deriveAirnodeXpub = deriveAirnodeXpub;
+/**
+ * Derives a wallet path from a sponsor address, used for calculating a sponsor wallet.
+ *
+ * @param sponsorAddress an EVM-compatible address
+ * @param protocolId an API application protocol ID
+ */
+function deriveWalletPathFromSponsorAddress(sponsorAddress, protocolId) {
+    schema_1.addressSchema.parse(sponsorAddress);
+    const sponsorAddressBN = ethers_1.ethers.BigNumber.from(sponsorAddress);
+    const paths = [];
+    for (let i = 0; i < 6; i++) {
+        const shiftedSponsorAddressBN = sponsorAddressBN.shr(31 * i);
+        paths.push(shiftedSponsorAddressBN.mask(31).toString());
+    }
+    return `${protocolId}/${paths.join('/')}`;
+}
+exports.deriveWalletPathFromSponsorAddress = deriveWalletPathFromSponsorAddress;
+/**
+ * Encodes/formats a string as a hex-encoded bytes32 string.
+ *
+ * @param input the input string
+ */
+const toBytes32String = (input) => ethers_1.ethers.utils.formatBytes32String(input);
+exports.toBytes32String = toBytes32String;
+/**
+ * Decodes a hex-encoded bytes32 string to a normal string.
+ *
+ * @param input the input hex string
+ */
+const fromBytes32String = (input) => ethers_1.ethers.utils.parseBytes32String(input);
+exports.fromBytes32String = fromBytes32String;
+/**
+ * Derives a sponsor wallet, given a mnemonic and dapiName.
+ *
+ * @param sponsorWalletMnemonic the sponsor wallet mnemonic
+ * @param dapiName the dapi name
+ */
+const deriveSponsorWallet = (sponsorWalletMnemonic, dapiName) => {
+    // Take first 20 bytes of dapiName as sponsor address together with the "0x" prefix.
+    const sponsorAddress = ethers_1.ethers.utils.getAddress(dapiName.slice(0, 42));
+    const sponsorWallet = ethers_1.ethers.Wallet.fromMnemonic(sponsorWalletMnemonic, `m/44'/60'/0'/${(deriveWalletPathFromSponsorAddress(sponsorAddress, exports.PROTOCOL_IDS.AIRSEEKER), exports.PROTOCOL_IDS.AIRSEEKER)}`);
+    return sponsorWallet;
+};
+exports.deriveSponsorWallet = deriveSponsorWallet;
+/**
+ * Derives the ID of a single beacon
+ *
+ * @param airnodeAddress the airnode address of the provider that supplies the data used to update this beacon
+ * @param templateId the templateId of the template used to generate the data used to update this beacon
+ */
+const deriveBeaconId = (airnodeAddress, templateId) => ethers_1.ethers.utils.solidityKeccak256(['address', 'bytes32'], [airnodeAddress, templateId]);
+exports.deriveBeaconId = deriveBeaconId;
+/**
+ * Derives the ID of a set of beacons.
+ * By convention beacon IDs are sorted alphabetically - the ordering impacts the resulting hash.
+ *
+ * @param beaconIds an ordered array of beacon ids
+ */
+const deriveBeaconSetId = (beaconIds) => ethers_1.ethers.utils.keccak256(ethers_1.ethers.utils.defaultAbiCoder.encode(['bytes32[]'], [beaconIds]));
+exports.deriveBeaconSetId = deriveBeaconSetId;
+//# sourceMappingURL=derivation.js.map

package/dist/blockchain-utilities/derivation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivation.js","sourceRoot":"","sources":["../../src/blockchain-utilities/derivation.ts"],"names":[],"mappings":"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"}

package/dist/blockchain-utilities/schema.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+/**
+ * A Zod validation schema that represents an EVM-compatible address.
+ */
+export declare const addressSchema: z.ZodString;
+/**
+ * A Zod validation schema that represents an EVM-compatible hash, which includes beacon IDs and template IDs.
+ */
+export declare const idSchema: z.ZodString;
+export type Address = z.infer<typeof addressSchema>;
+export type Id = z.infer<typeof idSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/blockchain-utilities/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/blockchain-utilities/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,aAAa,aAAwE,CAAC;AAEnG;;GAEG;AACH,eAAO,MAAM,QAAQ,aAAqE,CAAC;AAE3F,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,MAAM,MAAM,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC"}

package/dist/blockchain-utilities/schema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.idSchema = exports.addressSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * A Zod validation schema that represents an EVM-compatible address.
+ */
+exports.addressSchema = zod_1.z.string().regex(/^0x[\dA-Fa-f]{40}$/, 'Must be a valid EVM address');
+/**
+ * A Zod validation schema that represents an EVM-compatible hash, which includes beacon IDs and template IDs.
+ */
+exports.idSchema = zod_1.z.string().regex(/^0x[\dA-Fa-f]{64}$/, 'Must be a valid EVM hash');
+//# sourceMappingURL=schema.js.map

package/dist/blockchain-utilities/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/blockchain-utilities/schema.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB;;GAEG;AACU,QAAA,aAAa,GAAG,OAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,oBAAoB,EAAE,6BAA6B,CAAC,CAAC;AAEnG;;GAEG;AACU,QAAA,QAAQ,GAAG,OAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,oBAAoB,EAAE,0BAA0B,CAAC,CAAC"}

package/dist/processing/processing.d.ts

@@ -1,39 +1,91 @@
 import { type Endpoint } from '@api3/ois';
 import { type GoAsyncOptions } from '@api3/promise-utils';
-import { type ApiCallParameters } from './schema';
+import { type EndpointParameters, type PreProcessingV2Response, type PostProcessingV2Response, type ProcessingSpecificationV2, type ProcessingSpecifications } from './schema';
 export declare const DEFAULT_PROCESSING_TIMEOUT_MS = 10000;
 /**
- * Removes reserved parameters from the parameters object.
- * @param parameters The API call parameters from which reserved parameters will be removed.
- * @returns The parameters object without reserved parameters.
+ * Removes reserved parameters from the endpoint parameters.
+ * @param parameters The endpoint parameters from which reserved parameters will be removed.
+ * @returns The endpoint parameters without reserved parameters.
  */
-export declare const removeReservedParameters: (parameters: ApiCallParameters) => ApiCallParameters;
+export declare const removeReservedParameters: (parameters: EndpointParameters) => EndpointParameters;
 /**
- * Re-inserts reserved parameters from the initial parameters object into the modified parameters object.
- * @param initialParameters The initial API call parameters that might contain reserved parameters.
- * @param modifiedParameters The modified API call parameters to which reserved parameters will be added.
- * @returns The modified parameters object with re-inserted reserved parameters.
+ * Re-inserts reserved parameters from the initial endpoint parameters into the modified endpoint parameters.
+ * @param initialParameters The initial endpoint parameters that might contain reserved parameters.
+ * @param modifiedParameters The modified endpoint parameters to which reserved parameters will be added.
+ * @returns The modified endpoint parameters with re-inserted reserved parameters.
  */
-export declare const addReservedParameters: (initialParameters: ApiCallParameters, modifiedParameters: ApiCallParameters) => ApiCallParameters;
+export declare const addReservedParameters: (initialParameters: EndpointParameters, modifiedParameters: EndpointParameters) => EndpointParameters;
 /**
- * Pre-processes API call parameters based on the provided endpoint's processing specifications.
+ * Pre-processes endpoint parameters based on the provided endpoint's processing specifications.
+ *
+ * @param preProcessingSpecifications The v1 pre-processing specifications.
+ * @param endpointParameters The parameters to be pre-processed.
+ * @param processingOptions Options to control the async processing behavior like retries and timeouts.
+ *
+ * @returns A promise that resolves to the pre-processed parameters.
+ */
+export declare const preProcessEndpointParametersV1: (preProcessingSpecifications: ProcessingSpecifications | undefined, endpointParameters: EndpointParameters, processingOptions?: GoAsyncOptions) => Promise<EndpointParameters>;
+/**
+ * Post-processes the response based on the provided endpoint's processing specifications. The response is usually the
+ * API call response, but this logic depends on how the processing is used by the target service. For example, Airnode
+ * allows skipping API calls in which case the response is the result of pre-processing.
+ *
+ * @param response The response to be post-processed.
+ * @param postProcessingSpecifications The v1 post-processing specifications.
+ * @param endpointParameters The endpoint parameters.
+ * @param processingOptions Options to control the async processing behavior like retries and timeouts.
+ *
+ * @returns A promise that resolves to the post-processed response.
+ */
+export declare const postProcessResponseV1: (response: unknown, postProcessingSpecifications: ProcessingSpecifications | undefined, endpointParameters: EndpointParameters, processingOptions?: GoAsyncOptions) => Promise<unknown>;
+/**
+ * Pre-processes endpoint parameters based on the provided endpoint's processing specifications.
+ *
+ * @param preProcessingSpecificationV2 The v2 pre-processing specification.
+ * @param endpointParameters The parameters to be pre-processed.
+ * @param processingOptions Options to control the async processing behavior like retries and timeouts.
+ *
+ * @returns A promise that resolves to the pre-processed parameters.
+ */
+export declare const preProcessEndpointParametersV2: (preProcessingSpecificationV2: ProcessingSpecificationV2 | undefined, endpointParameters: EndpointParameters, processingOptions?: GoAsyncOptions) => Promise<PreProcessingV2Response>;
+/**
+ * Post-processes the response based on the provided endpoint's processing specifications. The response is usually the
+ * API call response, but this logic depends on how the processing is used by the target service. For example, Airnode
+ * allows skipping API calls in which case the response is the result of pre-processing.
+ *
+ * @param response The response to be post-processed.
+ * @param postProcessingSpecificationV2 The v2 post-processing specification.
+ * @param endpointParameters The endpoint parameters.
+ * @param processingOptions Options to control the async processing behavior like retries and timeouts.
+ *
+ * @returns A promise that resolves to the post-processed response.
+ */
+export declare const postProcessResponseV2: (response: unknown, postProcessingSpecificationV2: ProcessingSpecificationV2 | undefined, endpointParameters: EndpointParameters, processingOptions?: GoAsyncOptions) => Promise<PostProcessingV2Response>;
+/**
+ * Pre-processes endpoint parameters based on the provided endpoint's processing specifications. Internally it
+ * determines what processing implementation should be used.
  *
  * @param endpoint The endpoint containing processing specifications.
- * @param apiCallParameters The parameters to be pre-processed.
+ * @param endpointParameters The parameters to be pre-processed.
  * @param processingOptions Options to control the async processing behavior like retries and timeouts.
  *
  * @returns A promise that resolves to the pre-processed parameters.
  */
-export declare const preProcessApiCallParameters: (endpoint: Endpoint, apiCallParameters: ApiCallParameters, processingOptions?: GoAsyncOptions) => Promise<ApiCallParameters>;
+export declare const preProcessEndpointParameters: (endpoint: Endpoint, endpointParameters: EndpointParameters, processingOptions?: GoAsyncOptions) => Promise<PreProcessingV2Response>;
 /**
- * Post-processes the API call response based on the provided endpoint's processing specifications.
+ * Post-processes the response based on the provided endpoint's processing specifications. The response is usually the
+ * API call response, but this logic depends on how the processing is used by the target service. For example, Airnode
+ * allows skipping API calls in which case the response is the result of pre-processing.
+ *
+ * This function determines what processing version should be used and provides a common interface. This is useful for
+ * services that want to use processing and don't care which processing version is used.
  *
- * @param apiCallResponse The raw response obtained from the API call.
+ * @param response The response to be post-processed.
  * @param endpoint The endpoint containing processing specifications.
- * @param apiCallParameters The parameters used in the API call.
+ * @param endpointParameters The endpoint parameters.
  * @param processingOptions Options to control the async processing behavior like retries and timeouts.
  *
- * @returns A promise that resolves to the post-processed API call response.
+ * @returns A promise that resolves to the post-processed response.
  */
-export declare const postProcessApiCallResponse: (apiCallResponse: unknown, endpoint: Endpoint, apiCallParameters: ApiCallParameters, processingOptions?: GoAsyncOptions) => Promise<unknown>;
+export declare const postProcessResponse: (response: unknown, endpoint: Endpoint, endpointParameters: EndpointParameters, processingOptions?: GoAsyncOptions) => Promise<PostProcessingV2Response>;
 //# sourceMappingURL=processing.d.ts.map

package/dist/processing/processing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"processing.d.ts","sourceRoot":"","sources":["../../src/processing/processing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAuB,MAAM,WAAW,CAAC;AAC/D,OAAO,EAAE,KAAK,cAAc,EAAM,MAAM,qBAAqB,CAAC;AAE9D,OAAO,EAAE,KAAK,iBAAiB,EAA6B,MAAM,UAAU,CAAC;AAG7E,eAAO,MAAM,6BAA6B,QAAS,CAAC;AAIpD;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,eAAgB,iBAAiB,KAAG,iBAUxE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,sBACb,iBAAiB,sBAChB,iBAAiB,KACpC,iBAQF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,aAC5B,QAAQ,qBACC,iBAAiB,sBACjB,cAAc,KAChC,QAAQ,iBAAiB,CA4C3B,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,0BAA0B,oBACpB,OAAO,YACd,QAAQ,qBACC,iBAAiB,sBACjB,cAAc,qBAwClC,CAAC"}
+{"version":3,"file":"processing.d.ts","sourceRoot":"","sources":["../../src/processing/processing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAuB,MAAM,WAAW,CAAC;AAC/D,OAAO,EAAE,KAAK,cAAc,EAAM,MAAM,qBAAqB,CAAC;AAE9D,OAAO,EACL,KAAK,kBAAkB,EAIvB,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC9B,MAAM,UAAU,CAAC;AAGlB,eAAO,MAAM,6BAA6B,QAAS,CAAC;AAIpD;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,eAAgB,kBAAkB,KAAG,kBAUzE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,sBACb,kBAAkB,sBACjB,kBAAkB,KACrC,kBAQF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B,gCACZ,wBAAwB,GAAG,SAAS,sBAC7C,kBAAkB,sBACnB,cAAc,KAChC,QAAQ,kBAAkB,CA4C5B,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,aACtB,OAAO,gCACa,wBAAwB,GAAG,SAAS,sBAC9C,kBAAkB,sBACnB,cAAc,qBAwClC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B,iCACX,yBAAyB,GAAG,SAAS,sBAC/C,kBAAkB,sBACnB,cAAc,KAChC,QAAQ,uBAAuB,CAqBjC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,aACtB,OAAO,iCACc,yBAAyB,GAAG,SAAS,sBAChD,kBAAkB,sBACnB,cAAc,KAChC,QAAQ,wBAAwB,CAoBlC,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B,aAC7B,QAAQ,sBACE,kBAAkB,sBACnB,cAAc,KAChC,QAAQ,uBAAuB,CAYjC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,aACpB,OAAO,YACP,QAAQ,sBACE,kBAAkB,sBACnB,cAAc,KAChC,QAAQ,wBAAwB,CAalC,CAAC"}

package/dist/processing/processing.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.postProcessApiCallResponse = exports.preProcessApiCallParameters = exports.addReservedParameters = exports.removeReservedParameters = exports.DEFAULT_PROCESSING_TIMEOUT_MS = void 0;
+exports.postProcessResponse = exports.preProcessEndpointParameters = exports.postProcessResponseV2 = exports.preProcessEndpointParametersV2 = exports.postProcessResponseV1 = exports.preProcessEndpointParametersV1 = exports.addReservedParameters = exports.removeReservedParameters = exports.DEFAULT_PROCESSING_TIMEOUT_MS = void 0;
 const ois_1 = require("@api3/ois");
 const promise_utils_1 = require("@api3/promise-utils");
 const schema_1 = require("./schema");
@@ -8,9 +8,9 @@ const unsafe_evaluate_1 = require("./unsafe-evaluate");
 exports.DEFAULT_PROCESSING_TIMEOUT_MS = 10_000;
 const reservedParameters = ois_1.RESERVED_PARAMETERS; // To avoid strict TS checks.
 /**
- * Removes reserved parameters from the parameters object.
- * @param parameters The API call parameters from which reserved parameters will be removed.
- * @returns The parameters object without reserved parameters.
+ * Removes reserved parameters from the endpoint parameters.
+ * @param parameters The endpoint parameters from which reserved parameters will be removed.
+ * @returns The endpoint parameters without reserved parameters.
  */
 const removeReservedParameters = (parameters) => {
     const result = {};
@@ -23,10 +23,10 @@ const removeReservedParameters = (parameters) => {
 };
 exports.removeReservedParameters = removeReservedParameters;
 /**
- * Re-inserts reserved parameters from the initial parameters object into the modified parameters object.
- * @param initialParameters The initial API call parameters that might contain reserved parameters.
- * @param modifiedParameters The modified API call parameters to which reserved parameters will be added.
- * @returns The modified parameters object with re-inserted reserved parameters.
+ * Re-inserts reserved parameters from the initial endpoint parameters into the modified endpoint parameters.
+ * @param initialParameters The initial endpoint parameters that might contain reserved parameters.
+ * @param modifiedParameters The modified endpoint parameters to which reserved parameters will be added.
+ * @returns The modified endpoint parameters with re-inserted reserved parameters.
  */
 const addReservedParameters = (initialParameters, modifiedParameters) => {
     for (const key in initialParameters) {
@@ -38,33 +38,33 @@ const addReservedParameters = (initialParameters, modifiedParameters) => {
 };
 exports.addReservedParameters = addReservedParameters;
 /**
- * Pre-processes API call parameters based on the provided endpoint's processing specifications.
+ * Pre-processes endpoint parameters based on the provided endpoint's processing specifications.
  *
- * @param endpoint The endpoint containing processing specifications.
- * @param apiCallParameters The parameters to be pre-processed.
+ * @param preProcessingSpecifications The v1 pre-processing specifications.
+ * @param endpointParameters The parameters to be pre-processed.
  * @param processingOptions Options to control the async processing behavior like retries and timeouts.
  *
  * @returns A promise that resolves to the pre-processed parameters.
  */
-const preProcessApiCallParameters = async (endpoint, apiCallParameters, processingOptions = { retries: 0, totalTimeoutMs: exports.DEFAULT_PROCESSING_TIMEOUT_MS }) => {
-    const { preProcessingSpecifications } = endpoint;
+const preProcessEndpointParametersV1 = async (preProcessingSpecifications, endpointParameters, processingOptions = { retries: 0, totalTimeoutMs: exports.DEFAULT_PROCESSING_TIMEOUT_MS }) => {
     if (!preProcessingSpecifications || preProcessingSpecifications.length === 0) {
-        return apiCallParameters;
+        return endpointParameters;
     }
-    // We only wrap the code through "go" utils because of the timeout and retry logic.
+    // We only wrap the code through "go" utils because of the timeout and retry logic. In case of error, the function
+    // just re-throws.
     const goProcessedParameters = await (0, promise_utils_1.go)(async () => {
-        let currentValue = (0, exports.removeReservedParameters)(apiCallParameters);
+        let currentValue = (0, exports.removeReservedParameters)(endpointParameters);
         for (const processing of preProcessingSpecifications) {
             // Provide endpoint parameters without reserved parameters immutably between steps. Recompute them for each
             // snippet independently because processing snippets can modify the parameters.
-            const endpointParameters = (0, exports.removeReservedParameters)(apiCallParameters);
+            const nonReservedEndpointParameters = (0, exports.removeReservedParameters)(endpointParameters);
             switch (processing.environment) {
                 case 'Node': {
-                    currentValue = await (0, unsafe_evaluate_1.unsafeEvaluate)(processing.value, { input: currentValue, endpointParameters }, processing.timeoutMs);
+                    currentValue = await (0, unsafe_evaluate_1.unsafeEvaluate)(processing.value, { input: currentValue, endpointParameters: nonReservedEndpointParameters }, processing.timeoutMs);
                     break;
                 }
                 case 'Node async': {
-                    currentValue = await (0, unsafe_evaluate_1.unsafeEvaluateAsync)(processing.value, { input: currentValue, endpointParameters }, processing.timeoutMs);
+                    currentValue = await (0, unsafe_evaluate_1.unsafeEvaluateAsync)(processing.value, { input: currentValue, endpointParameters: nonReservedEndpointParameters }, processing.timeoutMs);
                     break;
                 }
             }
@@ -74,40 +74,42 @@ const preProcessApiCallParameters = async (endpoint, apiCallParameters, processi
     if (!goProcessedParameters.success)
         throw goProcessedParameters.error;
     // Let this throw if the processed parameters are invalid.
-    const parsedParameters = (0, schema_1.validateApiCallParameters)(goProcessedParameters.data);
-    // Having removed reserved parameters for pre-processing, we need to re-insert them for the API call.
-    return (0, exports.addReservedParameters)(apiCallParameters, parsedParameters);
+    const parsedParameters = schema_1.endpointParametersSchema.parse(goProcessedParameters.data);
+    // Having removed reserved parameters for pre-processing, we need to re-insert them after pre-processing.
+    return (0, exports.addReservedParameters)(endpointParameters, parsedParameters);
 };
-exports.preProcessApiCallParameters = preProcessApiCallParameters;
+exports.preProcessEndpointParametersV1 = preProcessEndpointParametersV1;
 /**
- * Post-processes the API call response based on the provided endpoint's processing specifications.
+ * Post-processes the response based on the provided endpoint's processing specifications. The response is usually the
+ * API call response, but this logic depends on how the processing is used by the target service. For example, Airnode
+ * allows skipping API calls in which case the response is the result of pre-processing.
  *
- * @param apiCallResponse The raw response obtained from the API call.
- * @param endpoint The endpoint containing processing specifications.
- * @param apiCallParameters The parameters used in the API call.
+ * @param response The response to be post-processed.
+ * @param postProcessingSpecifications The v1 post-processing specifications.
+ * @param endpointParameters The endpoint parameters.
  * @param processingOptions Options to control the async processing behavior like retries and timeouts.
  *
- * @returns A promise that resolves to the post-processed API call response.
+ * @returns A promise that resolves to the post-processed response.
  */
-const postProcessApiCallResponse = async (apiCallResponse, endpoint, apiCallParameters, processingOptions = { retries: 0, totalTimeoutMs: exports.DEFAULT_PROCESSING_TIMEOUT_MS }) => {
-    const { postProcessingSpecifications } = endpoint;
+const postProcessResponseV1 = async (response, postProcessingSpecifications, endpointParameters, processingOptions = { retries: 0, totalTimeoutMs: exports.DEFAULT_PROCESSING_TIMEOUT_MS }) => {
     if (!postProcessingSpecifications || postProcessingSpecifications?.length === 0) {
-        return apiCallResponse;
+        return response;
     }
-    // We only wrap the code through "go" utils because of the timeout and retry logic.
+    // We only wrap the code through "go" utils because of the timeout and retry logic. In case of error, the function
+    // just re-throws.
     const goResult = await (0, promise_utils_1.go)(async () => {
-        let currentValue = apiCallResponse;
+        let currentValue = response;
         for (const processing of postProcessingSpecifications) {
             // Provide endpoint parameters without reserved parameters immutably between steps. Recompute them for each
             // snippet independently because processing snippets can modify the parameters.
-            const endpointParameters = (0, exports.removeReservedParameters)(apiCallParameters);
+            const nonReservedEndpointParameters = (0, exports.removeReservedParameters)(endpointParameters);
             switch (processing.environment) {
                 case 'Node': {
-                    currentValue = await (0, unsafe_evaluate_1.unsafeEvaluate)(processing.value, { input: currentValue, endpointParameters }, processing.timeoutMs);
+                    currentValue = await (0, unsafe_evaluate_1.unsafeEvaluate)(processing.value, { input: currentValue, endpointParameters: nonReservedEndpointParameters }, processing.timeoutMs);
                     break;
                 }
                 case 'Node async': {
-                    currentValue = await (0, unsafe_evaluate_1.unsafeEvaluateAsync)(processing.value, { input: currentValue, endpointParameters }, processing.timeoutMs);
+                    currentValue = await (0, unsafe_evaluate_1.unsafeEvaluateAsync)(processing.value, { input: currentValue, endpointParameters: nonReservedEndpointParameters }, processing.timeoutMs);
                     break;
                 }
             }
@@ -118,5 +120,111 @@ const postProcessApiCallResponse = async (apiCallResponse, endpoint, apiCallPara
         throw goResult.error;
     return goResult.data;
 };
-exports.postProcessApiCallResponse = postProcessApiCallResponse;
+exports.postProcessResponseV1 = postProcessResponseV1;
+/**
+ * Pre-processes endpoint parameters based on the provided endpoint's processing specifications.
+ *
+ * @param preProcessingSpecificationV2 The v2 pre-processing specification.
+ * @param endpointParameters The parameters to be pre-processed.
+ * @param processingOptions Options to control the async processing behavior like retries and timeouts.
+ *
+ * @returns A promise that resolves to the pre-processed parameters.
+ */
+const preProcessEndpointParametersV2 = async (preProcessingSpecificationV2, endpointParameters, processingOptions = { retries: 0, totalTimeoutMs: exports.DEFAULT_PROCESSING_TIMEOUT_MS }) => {
+    if (!preProcessingSpecificationV2)
+        return { endpointParameters };
+    // We only wrap the code through "go" utils because of the timeout and retry logic.  In case of error, the function
+    // just re-throws.
+    const goProcessedParameters = await (0, promise_utils_1.go)(async () => {
+        const { environment, timeoutMs, value } = preProcessingSpecificationV2;
+        switch (environment) {
+            case 'Node': {
+                return (0, unsafe_evaluate_1.unsafeEvaluateV2)(value, { endpointParameters: (0, exports.removeReservedParameters)(endpointParameters) }, timeoutMs);
+            }
+        }
+    }, processingOptions);
+    if (!goProcessedParameters.success)
+        throw goProcessedParameters.error;
+    // Let this throw if the processed parameters are invalid.
+    const preProcessingResponse = schema_1.preProcessingV2ResponseSchema.parse(goProcessedParameters.data);
+    // Having removed reserved parameters for pre-processing, we need to re-insert them after pre-processing.
+    return { endpointParameters: (0, exports.addReservedParameters)(endpointParameters, preProcessingResponse.endpointParameters) };
+};
+exports.preProcessEndpointParametersV2 = preProcessEndpointParametersV2;
+/**
+ * Post-processes the response based on the provided endpoint's processing specifications. The response is usually the
+ * API call response, but this logic depends on how the processing is used by the target service. For example, Airnode
+ * allows skipping API calls in which case the response is the result of pre-processing.
+ *
+ * @param response The response to be post-processed.
+ * @param postProcessingSpecificationV2 The v2 post-processing specification.
+ * @param endpointParameters The endpoint parameters.
+ * @param processingOptions Options to control the async processing behavior like retries and timeouts.
+ *
+ * @returns A promise that resolves to the post-processed response.
+ */
+const postProcessResponseV2 = async (response, postProcessingSpecificationV2, endpointParameters, processingOptions = { retries: 0, totalTimeoutMs: exports.DEFAULT_PROCESSING_TIMEOUT_MS }) => {
+    if (!postProcessingSpecificationV2)
+        return { response };
+    // We only wrap the code through "go" utils because of the timeout and retry logic. In case of error, the function
+    // just re-throws.
+    const goResult = await (0, promise_utils_1.go)(async () => {
+        const { environment, timeoutMs, value } = postProcessingSpecificationV2;
+        // Provide endpoint parameters without reserved parameters immutably between steps. Recompute them for each
+        // snippet independently because processing snippets can modify the parameters.
+        const nonReservedEndpointParameters = (0, exports.removeReservedParameters)(endpointParameters);
+        switch (environment) {
+            case 'Node': {
+                return (0, unsafe_evaluate_1.unsafeEvaluateV2)(value, { response, endpointParameters: nonReservedEndpointParameters }, timeoutMs);
+            }
+        }
+    }, processingOptions);
+    if (!goResult.success)
+        throw goResult.error;
+    return schema_1.postProcessingV2ResponseSchema.parse(goResult.data);
+};
+exports.postProcessResponseV2 = postProcessResponseV2;
+/**
+ * Pre-processes endpoint parameters based on the provided endpoint's processing specifications. Internally it
+ * determines what processing implementation should be used.
+ *
+ * @param endpoint The endpoint containing processing specifications.
+ * @param endpointParameters The parameters to be pre-processed.
+ * @param processingOptions Options to control the async processing behavior like retries and timeouts.
+ *
+ * @returns A promise that resolves to the pre-processed parameters.
+ */
+const preProcessEndpointParameters = async (endpoint, endpointParameters, processingOptions = { retries: 0, totalTimeoutMs: exports.DEFAULT_PROCESSING_TIMEOUT_MS }) => {
+    const { preProcessingSpecificationV2, preProcessingSpecifications } = endpoint;
+    if (preProcessingSpecificationV2) {
+        return (0, exports.preProcessEndpointParametersV2)(preProcessingSpecificationV2, endpointParameters);
+    }
+    const preProcessV1Response = await (0, exports.preProcessEndpointParametersV1)(preProcessingSpecifications, endpointParameters, processingOptions);
+    return { endpointParameters: preProcessV1Response };
+};
+exports.preProcessEndpointParameters = preProcessEndpointParameters;
+/**
+ * Post-processes the response based on the provided endpoint's processing specifications. The response is usually the
+ * API call response, but this logic depends on how the processing is used by the target service. For example, Airnode
+ * allows skipping API calls in which case the response is the result of pre-processing.
+ *
+ * This function determines what processing version should be used and provides a common interface. This is useful for
+ * services that want to use processing and don't care which processing version is used.
+ *
+ * @param response The response to be post-processed.
+ * @param endpoint The endpoint containing processing specifications.
+ * @param endpointParameters The endpoint parameters.
+ * @param processingOptions Options to control the async processing behavior like retries and timeouts.
+ *
+ * @returns A promise that resolves to the post-processed response.
+ */
+const postProcessResponse = async (response, endpoint, endpointParameters, processingOptions = { retries: 0, totalTimeoutMs: exports.DEFAULT_PROCESSING_TIMEOUT_MS }) => {
+    const { postProcessingSpecificationV2, postProcessingSpecifications } = endpoint;
+    if (postProcessingSpecificationV2) {
+        return (0, exports.postProcessResponseV2)(response, postProcessingSpecificationV2, endpointParameters);
+    }
+    const postProcessV1Response = await (0, exports.postProcessResponseV1)(response, postProcessingSpecifications, endpointParameters, processingOptions);
+    return { response: postProcessV1Response };
+};
+exports.postProcessResponse = postProcessResponse;
 //# sourceMappingURL=processing.js.map