@chainlink/external-adapter-framework 0.0.15 → 0.0.17

package/examples/bank-frick/accounts.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountsRestEndpoint = exports.BankFrickAccountsTransport = void 0;
+const axios_1 = __importDefault(require("axios"));
+const util_1 = require("./util");
+const util_2 = require("../../util");
+const error_1 = require("../../validation/error");
+const adapter_1 = require("../../adapter");
+const logger = (0, util_2.makeLogger)('BankFrickTransport');
+// Note: this is a shallow pattern that only checks for a country code since IBANs in the sandbox are invalid
+const ibanPattern = /^[A-Z]{2}[A-Z\d]{14,30}$/;
+const inputParameters = {
+    ibanIDs: {
+        description: 'The list of account ids included in the sum of balances',
+        required: true,
+        type: 'array',
+    },
+    signingAlgorithm: {
+        description: 'What signing algorithm is used to sign and verify authorization data, one of rsa-sha256, rsa-sha384, or rsa-sha512',
+        required: false,
+        type: 'string',
+        default: 'rsa-sha512',
+        options: ['rsa-sha256', 'rsa-sha384', 'rsa-sha512'],
+    },
+};
+// See here for all expected error returned by the API: https://developers.bankfrick.li/docs#errors
+const AuthErrors = {
+    401: 'No JWT token provided or token is invalid',
+    403: 'API key is invalid or any other condition is hindering the login', // Unclear if this is fatal or not
+};
+const FatalErrors = {
+    400: "Invalid parameters passed to Bank Frick's API",
+    423: "Authorization is valid, but the user's account is locked",
+};
+/**
+ * RestTransport implementation for Bank Frick, which has unusually complex requirements for an EA
+ * The RestTransport is generally built to make a single request and return a single response.
+ * This transport instead is used to fetch and process pages of data, and also requires a JWT to run
+ *
+ * This transport does all the heavy lifting in setup(), which is where the paging happens, and it
+ * also has complex retry logic that will attempt to refresh the JWT when certain HTTP errors occur
+ */
+class BankFrickAccountsTransport {
+    async initialize(dependencies) {
+        this.cache = dependencies.cache;
+    }
+    async hasBeenSetUp() {
+        return false; // Return false since we aren't coalescing requests
+    }
+    /**
+     * Creates an AxiosRequestConfig object for fetching a page of accounts from the Bank Frick API
+     */
+    prepareRequest(firstPosition, inputParams, config) {
+        const { API_ENDPOINT, BASE_URL, PAGE_SIZE } = config;
+        return {
+            baseURL: API_ENDPOINT + BASE_URL,
+            url: 'accounts',
+            method: 'GET',
+            params: {
+                firstPosition,
+                maxResults: PAGE_SIZE,
+            },
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+            },
+        };
+    }
+    /**
+     * Request with retry logic for Bank Frick's API. In addition to standard retry logic, this function
+     * compares errors against expected errors from the Bank Frick API, and will throw without retries
+     * on a known fatal error, or try to refresh the JWT on a known auth error
+     **/
+    async makeRequest(axiosRequest, config, signingAlgorithm) {
+        let retryNumber = 0;
+        let response = await axios_1.default.request(axiosRequest);
+        while (response.status !== 200) {
+            retryNumber++;
+            logger.warn('Encountered error when fetching accounts from Bank Frick:', response.status, response.statusText);
+            // Evaluate whether the error was fatal, auth, or transient and whether we've exceeded the max number of retries.
+            // Throw on fatal, refresh token on auth error, pass on transient until we've exhausted our retries
+            if (FatalErrors[response.status]) {
+                throw new error_1.AdapterError({
+                    statusCode: response.status,
+                    message: response.statusText,
+                });
+            }
+            else if (AuthErrors[response.status]) {
+                // We've encountered a known auth error, so try to refresh the token before making another request
+                logger.info('Auth error received from the Bank Frick API, attempting to refresh the token');
+                this.token = await (0, util_1.generateJWT)(config, signingAlgorithm);
+            }
+            else if (retryNumber === config.REST_TRANSPORT_MAX_RATE_LIMIT_RETRIES) {
+                throw new error_1.AdapterError({
+                    statusCode: 504,
+                    message: `Bank Frick transport hit the max number of retries (${config.REST_TRANSPORT_MAX_RATE_LIMIT_RETRIES} retries) and aborted`,
+                });
+            }
+            logger.debug(`Sleeping for ${config.REST_TRANSPORT_MS_BETWEEN_RATE_LIMIT_RETRIES}ms before retrying`);
+            await (0, util_2.sleep)(config.REST_TRANSPORT_MS_BETWEEN_RATE_LIMIT_RETRIES);
+            response = await axios_1.default.request(axiosRequest);
+        }
+        return response;
+    }
+    validateInputParams(params) {
+        const encounteredIds = {};
+        const errors = [];
+        const { ibanIDs } = params;
+        ibanIDs.forEach((v) => {
+            if (!v.match(ibanPattern)) {
+                errors.push(`Invalid IBAN: ${v}`);
+            }
+            encounteredIds[v] += 1;
+            if (encounteredIds[v] > 1) {
+                errors.push(`The following IBAN appears more than once in the input parameters: ${v}`);
+            }
+        });
+        return errors;
+    }
+    /**
+     * Fetches pages of data from the Bank Frick API, scans for accounts by IBAN, and returns the balance
+     * of all found accounts. Returns a 404 if any IBAN isn't found.
+     */
+    async setup(req, config) {
+        const { ibanIDs, signingAlgorithm } = req.requestContext.data;
+        const { PAGE_SIZE = 500 } = config;
+        logger.debug(`Validating input: ${JSON.stringify(req.requestContext.data)}`);
+        // Scan ibanIDs for duplicates and invalid IBANs
+        const validationErrors = this.validateInputParams(req.requestContext.data);
+        if (validationErrors.length > 0) {
+            throw new error_1.AdapterError({
+                statusCode: 420,
+                message: `Received the following errors when validating inputParameters:\n ${validationErrors.join('\n')}`,
+            });
+        }
+        // Refresh the token if it isn't set
+        if (!this.token) {
+            this.token = await (0, util_1.generateJWT)(config, signingAlgorithm);
+        }
+        let sum = 0;
+        let position = 0;
+        const keys = ibanIDs;
+        logger.info("Fetching accounts from Bank Frick's API...");
+        while (keys.length > 0) {
+            // TODO Fetching and processing pages can be run concurrently
+            const axiosRequest = this.prepareRequest(position, req.requestContext.data, config);
+            const response = await this.makeRequest(axiosRequest, config, signingAlgorithm);
+            logger.debug(`Evaluating accounts from page ${position / PAGE_SIZE}`);
+            response.data.accounts.forEach((v) => {
+                logger.trace(`Evaluating ${v.account} (iban: ${v.iban}, type: ${v.type})`);
+                const index = ibanIDs.indexOf(v.iban);
+                if (index > -1) {
+                    keys.splice(index, 1);
+                    sum += v.balance;
+                    logger.trace(`Found account: ${v.account} (iban: ${v.iban}) with balance of ${v.balance}`);
+                    logger.trace(`Running sum: ${sum}, number of ibans left to find: ${keys.length}/${ibanIDs.length}`);
+                }
+            });
+            if (!response.data.moreResults) {
+                logger.debug('No more results, breaking out of account query loop');
+                break;
+            }
+            position += PAGE_SIZE || 0;
+        }
+        // 404 if one or more accounts were not found
+        if (keys.length > 0) {
+            logger.error(`Could not find all accounts, returning 404: ${keys.join(', ')}`);
+            const res = {
+                data: 0,
+                statusCode: 404,
+                result: 0,
+            };
+            await this.cache.set(req.requestContext.cacheKey, res, config.CACHE_MAX_AGE);
+        }
+        logger.debug('Was able to find all accounts, returning balance across all accounts: ', sum);
+        const res = {
+            data: sum,
+            statusCode: 200,
+            result: sum,
+        };
+        await this.cache.set(req.requestContext.cacheKey, res, config.CACHE_MAX_AGE);
+        return res;
+    }
+}
+exports.BankFrickAccountsTransport = BankFrickAccountsTransport;
+exports.accountsRestEndpoint = new adapter_1.AdapterEndpoint({
+    name: 'accounts',
+    transport: new BankFrickAccountsTransport(),
+    inputParameters,
+});

package/examples/bank-frick/config/index.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customSettings = exports.signingAlgorithms = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const util_1 = require("../../../util");
+const logger = (0, util_1.makeLogger)('BankFrickConfig');
+// Used for enum options and validation
+exports.signingAlgorithms = ['rsa-sha256', 'rsa-sha384', 'rsa-sha512'];
+const MAX_PAGE_SIZE = 500;
+exports.customSettings = {
+    PAGE_SIZE: {
+        description: 'The number of accounts to fetch per call to /accounts. Must be >= 1 and <= 500.',
+        type: 'number',
+        required: false,
+        default: MAX_PAGE_SIZE,
+        validate: (value) => {
+            if (!value) {
+                return '';
+            }
+            else if (value < 1) {
+                return `PAGE_SIZE must be at least >= 1, was ${value}`;
+            }
+            else if (value > MAX_PAGE_SIZE) {
+                return `PAGE_SIZE must be <= 500, was ${value}`;
+            }
+        },
+    },
+    PRIVATE_KEY: {
+        description: '',
+        type: 'string',
+        required: true,
+        validate: (value) => {
+            const failedAlgos = [];
+            for (const algorithm of exports.signingAlgorithms) {
+                const body = { example: 123 };
+                try {
+                    crypto_1.default.sign(algorithm, Buffer.from(JSON.stringify(body)), value);
+                    logger.trace("Successfully tested PRIVATE_KEY by signing with algorithm '%s'", algorithm);
+                }
+                catch {
+                    logger.trace("PRIVATE_KEY failed to sign message with algorithm '%s'", algorithm);
+                    failedAlgos.push(algorithm);
+                }
+            }
+            if (failedAlgos.length > 0) {
+                return `Failed to sign a dummy body using $PRIVATE_KEY with the following algorithms ${failedAlgos.join(',')}`;
+            }
+            logger.debug('$PRIVATE_KEY successfully signed a dummy body with all supported algorithms');
+        },
+    },
+};

package/examples/bank-frick/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapter = void 0;
+const adapter_1 = require("../../adapter");
+const accounts_1 = require("./accounts");
+const config_1 = require("./config");
+exports.adapter = new adapter_1.Adapter({
+    name: 'bank-frick',
+    defaultEndpoint: 'accounts',
+    endpoints: [accounts_1.accountsRestEndpoint],
+    customSettings: config_1.customSettings,
+    envDefaultOverrides: {
+        API_ENDPOINT: 'https://olbsandbox.bankfrick.li/webapi/v2',
+    },
+});

package/examples/bank-frick/util.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateJWT = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const axios_1 = __importDefault(require("axios"));
+const util_1 = require("../../util");
+const logger = (0, util_1.makeLogger)('BankFrickUtil');
+// Used by all endpoints requiring authentication
+const generateJWT = async (config, signingAlgorithm = 'rsa-sha512') => {
+    logger.info("Generating a new JWT because we don't have one in config.token");
+    const { API_KEY, PRIVATE_KEY, API_ENDPOINT } = config;
+    // All of these are required, so validation should have failed prior to this line
+    if (!API_KEY || !PRIVATE_KEY) {
+        throw new Error('API_KEY, PRIVATE_KEY, and PASSWORD all must be defined to get a new token\n' +
+            'Received:  \n' +
+            `API_KEY: ${API_KEY}\n` +
+            `PRIVATE_KEY: ${PRIVATE_KEY}`);
+    }
+    const data = {
+        key: API_KEY,
+    };
+    const signature = crypto_1.default.sign(signingAlgorithm, Buffer.from(JSON.stringify(data)), PRIVATE_KEY);
+    const options = {
+        method: 'POST',
+        baseURL: API_ENDPOINT,
+        url: `authorize`,
+        headers: {
+            Signature: signature.toString('base64'),
+            algorithm: signingAlgorithm,
+        },
+        data,
+    };
+    const response = await axios_1.default.request(options);
+    return response.data.token;
+};
+exports.generateJWT = generateJWT;

package/examples/coingecko/batch-warming.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchEndpoint = void 0;
+const adapter_1 = require("../../adapter");
+const batch_warming_1 = require("../../transports/batch-warming");
+const DEFAULT_URL = 'https://pro-api.coingecko.com/api/v3';
+const inputParameters = {
+    coinid: {
+        description: 'The CoinGecko id or array of ids of the coin(s) to query (Note: because of current limitations to use a dummy base will need to be supplied)',
+        required: false,
+    },
+    base: {
+        aliases: ['from', 'coin'],
+        description: 'The symbol or array of symbols of the currency to query',
+        required: true,
+    },
+    quote: {
+        aliases: ['to', 'market'],
+        description: 'The symbol of the currency to convert to',
+        required: true,
+    },
+};
+const batchEndpointTransport = new batch_warming_1.BatchWarmingTransport({
+    prepareRequest: (params, context) => {
+        return {
+            baseURL: DEFAULT_URL,
+            url: '/simple/price',
+            method: 'GET',
+            params: {
+                ids: [...new Set(params.map((p) => p.base))].join(','),
+                vs_currencies: [...new Set(params.map((p) => p.quote))].join(','),
+                x_cg_pro_api_key: context.adapterConfig.API_KEY,
+            },
+        };
+    },
+    parseResponse: (res) => {
+        const entries = [];
+        for (const [base, entry] of Object.entries(res.data)) {
+            for (const [quote, price] of Object.entries(entry)) {
+                entries.push({
+                    params: { base, quote },
+                    value: price,
+                });
+            }
+        }
+        return entries;
+    },
+});
+exports.batchEndpoint = new adapter_1.AdapterEndpoint({
+    name: 'batch',
+    transport: batchEndpointTransport,
+    inputParameters,
+});

package/examples/coingecko/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapter = void 0;
+const adapter_1 = require("../../adapter");
+const batch_warming_1 = require("./batch-warming");
+const rest_1 = require("./rest");
+exports.adapter = new adapter_1.Adapter({
+    name: 'coingecko',
+    defaultEndpoint: 'batch',
+    endpoints: [rest_1.restEndpoint, batch_warming_1.batchEndpoint],
+});

package/examples/coingecko/rest.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restEndpoint = void 0;
+const adapter_1 = require("../../adapter");
+const transports_1 = require("../../transports");
+const DEFAULT_URL = 'https://api.coingecko.com/api/v3';
+const inputParameters = {
+    coinid: {
+        description: 'The CoinGecko id or array of ids of the coin(s) to query (Note: because of current limitations to use a dummy base will need to be supplied)',
+        required: false,
+    },
+    base: {
+        aliases: ['from', 'coin'],
+        description: 'The symbol or array of symbols of the currency to query',
+        required: true,
+    },
+    quote: {
+        aliases: ['to', 'market'],
+        description: 'The symbol of the currency to convert to',
+        required: true,
+    },
+};
+const restEndpointTransport = new transports_1.RestTransport({
+    prepareRequest: (req) => {
+        return {
+            baseURL: DEFAULT_URL,
+            url: '/simple/price',
+            method: 'GET',
+            params: {
+                ids: req.requestContext.data.base,
+                vs_currencies: req.requestContext.data.quote,
+            },
+        };
+    },
+    parseResponse: (req, res) => {
+        return {
+            data: res.data,
+            statusCode: 200,
+            result: res.data[req.requestContext.data.base]?.[req.requestContext.data.quote],
+        };
+    },
+    options: {
+        coalescing: true,
+    },
+});
+exports.restEndpoint = new adapter_1.AdapterEndpoint({
+    name: 'rest',
+    aliases: ['qwe'],
+    transport: restEndpointTransport,
+    inputParameters,
+});

package/examples/coingecko/src/config/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customSettings = exports.PRO_API_ENDPOINT = exports.DEFAULT_API_ENDPOINT = exports.DEFAULT_ENDPOINT = exports.NAME = void 0;
+exports.NAME = 'COINGECKO';
+exports.DEFAULT_ENDPOINT = 'crypto';
+exports.DEFAULT_API_ENDPOINT = 'https://api.coingecko.com/api/v3';
+exports.PRO_API_ENDPOINT = 'https://pro-api.coingecko.com/api/v3';
+exports.customSettings = {
+    API_KEY: {
+        description: 'API key for the CoinGecko API',
+        type: 'string',
+    },
+};