@chainlink/external-adapter-framework 0.0.15 → 0.0.17

package/examples/coingecko/src/cryptoUtils.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructEntry = exports.buildBatchedRequestBody = void 0;
+const config_1 = require("./config");
+const logger_1 = require("../../../util/logger");
+const buildBatchedRequestBody = (params, config) => {
+    return {
+        baseURL: config.API_KEY ? config_1.PRO_API_ENDPOINT : config_1.DEFAULT_API_ENDPOINT,
+        url: '/simple/price',
+        method: 'GET',
+        params: {
+            ids: [...new Set(params.map((p) => p.coinid ?? p.base))].join(','),
+            vs_currencies: [...new Set(params.map((p) => p.quote))].join(','),
+            x_cg_pro_api_key: config.API_KEY,
+        },
+    };
+};
+exports.buildBatchedRequestBody = buildBatchedRequestBody;
+const logger = (0, logger_1.makeLogger)('CoinGecko Crypto Batched');
+const constructEntry = (res, requestPayload, resultPath) => {
+    const coinId = requestPayload.coinid ?? requestPayload.base;
+    const dataForCoin = res.data[coinId];
+    const dataForQuote = dataForCoin ? dataForCoin[resultPath] : undefined;
+    if (!dataForQuote) {
+        logger.warn(`Data for "${requestPayload.quote}" not found for token "${coinId}".`);
+        return;
+    }
+    const entry = {
+        params: requestPayload,
+        value: dataForQuote,
+    };
+    if (requestPayload.coinid) {
+        entry.params.coinid = requestPayload.coinid;
+    }
+    else {
+        entry.params.base = requestPayload.base;
+    }
+    delete entry.params.overrides;
+    return entry;
+};
+exports.constructEntry = constructEntry;

package/examples/coingecko/src/endpoint/coins.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endpoint = exports.inputParameters = void 0;
+const transports_1 = require("../../../../../src/transports");
+const config_1 = require("../config");
+exports.inputParameters = {};
+const restEndpointTransport = new transports_1.RestTransport({
+    prepareRequest: (_, config) => {
+        const baseURL = config.API_KEY ? config_1.PRO_API_ENDPOINT : config_1.DEFAULT_API_ENDPOINT;
+        const params = config.API_KEY ? { x_cg_pro_api_key: config.API_KEY } : undefined;
+        return {
+            baseURL,
+            url: '/coins/list',
+            method: 'GET',
+            params,
+        };
+    },
+    parseResponse: (req, res) => {
+        return {
+            data: res.data,
+            statusCode: 200,
+            result: res.data,
+        };
+    },
+    options: {
+        coalescing: true,
+    },
+});
+exports.endpoint = {
+    name: 'coins',
+    transport: restEndpointTransport,
+    inputParameters: exports.inputParameters,
+};

package/examples/coingecko/src/endpoint/crypto-marketcap.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endpoint = exports.inputParameters = void 0;
+const batch_warming_1 = require("../../../../transports/batch-warming");
+const input_params_1 = require("../../../../validation/input-params");
+const cryptoUtils_1 = require("../cryptoUtils");
+exports.inputParameters = {
+    overrides: input_params_1.baseInputParameters['overrides'],
+    coinid: {
+        description: 'The CoinGecko id or to query',
+        required: false,
+    },
+    base: {
+        aliases: ['from', 'coin'],
+        description: 'The symbol of symbols of the currency to query',
+        required: false,
+    },
+    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) => {
+        const requestBody = (0, cryptoUtils_1.buildBatchedRequestBody)(params, context.adapterConfig);
+        requestBody.params.include_market_cap = true;
+        return requestBody;
+    },
+    parseResponse: (params, res) => {
+        const entries = [];
+        for (const requestPayload of params) {
+            const entry = (0, cryptoUtils_1.constructEntry)(res, requestPayload, `${requestPayload.quote.toLowerCase()}_market_cap`);
+            if (entry) {
+                entries.push(entry);
+            }
+        }
+        return entries;
+    },
+});
+exports.endpoint = {
+    name: 'marketcap',
+    aliases: ['crypto-marketcap'],
+    transport: batchEndpointTransport,
+    inputParameters: exports.inputParameters,
+};

package/examples/coingecko/src/endpoint/crypto-volume.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endpoint = exports.inputParameters = void 0;
+const batch_warming_1 = require("../../../../transports/batch-warming");
+const input_params_1 = require("../../../../validation/input-params");
+const cryptoUtils_1 = require("../cryptoUtils");
+exports.inputParameters = {
+    overrides: input_params_1.baseInputParameters['overrides'],
+    coinid: {
+        description: 'The CoinGecko id or to query',
+        required: false,
+    },
+    base: {
+        aliases: ['from', 'coin'],
+        description: 'The symbol of symbols of the currency to query',
+        required: false,
+    },
+    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) => {
+        const requestBody = (0, cryptoUtils_1.buildBatchedRequestBody)(params, context.adapterConfig);
+        requestBody.params.include_24hr_vol = true;
+        return requestBody;
+    },
+    parseResponse: (params, res) => {
+        const entries = [];
+        for (const requestPayload of params) {
+            const entry = (0, cryptoUtils_1.constructEntry)(res, requestPayload, `${requestPayload.quote.toLowerCase()}_24h_vol`);
+            if (entry) {
+                entries.push(entry);
+            }
+        }
+        return entries;
+    },
+});
+exports.endpoint = {
+    name: 'volume',
+    aliases: ['crypto-volume'],
+    transport: batchEndpointTransport,
+    inputParameters: exports.inputParameters,
+};

package/examples/coingecko/src/endpoint/crypto.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endpoint = exports.inputParameters = void 0;
+const batch_warming_1 = require("../../../../transports/batch-warming");
+const input_params_1 = require("../../../../validation/input-params");
+const cryptoUtils_1 = require("../cryptoUtils");
+exports.inputParameters = {
+    overrides: input_params_1.baseInputParameters['overrides'],
+    coinid: {
+        description: 'The CoinGecko id or to query',
+        required: false,
+    },
+    base: {
+        aliases: ['from', 'coin'],
+        description: 'The symbol of symbols of the currency to query',
+        required: false,
+    },
+    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 (0, cryptoUtils_1.buildBatchedRequestBody)(params, context.adapterConfig);
+    },
+    parseResponse: (params, res) => {
+        const entries = [];
+        for (const requestPayload of params) {
+            const entry = (0, cryptoUtils_1.constructEntry)(res, requestPayload, requestPayload.quote.toLowerCase());
+            // NOTE: the `entries` array is going to be shorter than the `params` array if one of the params has a bad token.
+            // Is that okay?  I did this to avoid caching an invalid value for transient DP issues.  Just want to make
+            // sure this works within the core framework
+            if (entry) {
+                entries.push(entry);
+            }
+        }
+        return entries;
+    },
+});
+exports.endpoint = {
+    name: 'crypto',
+    aliases: ['crypto-batched', 'batched', 'batch'],
+    transport: batchEndpointTransport,
+    inputParameters: exports.inputParameters,
+};

package/examples/coingecko/src/endpoint/dominance.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endpoint = void 0;
+const batch_warming_1 = require("../../../../transports/batch-warming");
+const globalUtils_1 = require("../globalUtils");
+const batchEndpointTransport = new batch_warming_1.BatchWarmingTransport({
+    prepareRequest: (params, context) => {
+        return (0, globalUtils_1.buildGlobalRequestBody)(context.adapterConfig);
+    },
+    parseResponse: (params, res) => {
+        const entries = [];
+        for (const requestPayload of params) {
+            const entry = (0, globalUtils_1.constructEntry)(res, requestPayload, 'market_cap_percentage');
+            if (entry) {
+                entries.push(entry);
+            }
+        }
+        return entries;
+    },
+});
+exports.endpoint = {
+    name: 'dominance',
+    aliases: ['market_cap_percentage'],
+    transport: batchEndpointTransport,
+    inputParameters: globalUtils_1.inputParameters,
+};

package/examples/coingecko/src/endpoint/global-marketcap.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endpoint = void 0;
+const batch_warming_1 = require("../../../../transports/batch-warming");
+const globalUtils_1 = require("../globalUtils");
+const batchEndpointTransport = new batch_warming_1.BatchWarmingTransport({
+    prepareRequest: (params, context) => {
+        return (0, globalUtils_1.buildGlobalRequestBody)(context.adapterConfig);
+    },
+    parseResponse: (params, res) => {
+        const entries = [];
+        for (const requestPayload of params) {
+            const entry = (0, globalUtils_1.constructEntry)(res, requestPayload, 'total_market_cap');
+            if (entry) {
+                entries.push(entry);
+            }
+        }
+        return entries;
+    },
+});
+exports.endpoint = {
+    name: 'globalmarketcap',
+    aliases: ['total_market_cap'],
+    transport: batchEndpointTransport,
+    inputParameters: globalUtils_1.inputParameters,
+};

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cryptoVolume = exports.dominance = exports.globalMarketcap = exports.cryptoMarketcap = exports.crypto = exports.coins = void 0;
+var coins_1 = require("./coins");
+Object.defineProperty(exports, "coins", { enumerable: true, get: function () { return coins_1.endpoint; } });
+var crypto_1 = require("./crypto");
+Object.defineProperty(exports, "crypto", { enumerable: true, get: function () { return crypto_1.endpoint; } });
+var crypto_marketcap_1 = require("./crypto-marketcap");
+Object.defineProperty(exports, "cryptoMarketcap", { enumerable: true, get: function () { return crypto_marketcap_1.endpoint; } });
+var global_marketcap_1 = require("./global-marketcap");
+Object.defineProperty(exports, "globalMarketcap", { enumerable: true, get: function () { return global_marketcap_1.endpoint; } });
+var dominance_1 = require("./dominance");
+Object.defineProperty(exports, "dominance", { enumerable: true, get: function () { return dominance_1.endpoint; } });
+var crypto_volume_1 = require("./crypto-volume");
+Object.defineProperty(exports, "cryptoVolume", { enumerable: true, get: function () { return crypto_volume_1.endpoint; } });

package/examples/coingecko/src/globalUtils.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructEntry = exports.buildGlobalRequestBody = exports.inputParameters = void 0;
+const config_1 = require("./config");
+const logger_1 = require("../../../util/logger");
+const logger = (0, logger_1.makeLogger)('CoinGecko Global Batched');
+exports.inputParameters = {
+    market: {
+        aliases: ['to', 'quote'],
+        description: 'The ticker of the coin to query',
+        required: true,
+    },
+};
+const buildGlobalRequestBody = (config) => {
+    const apiKey = {
+        x_cg_pro_api_key: config.API_KEY,
+    };
+    return {
+        baseURL: config.API_KEY ? config_1.PRO_API_ENDPOINT : config_1.DEFAULT_API_ENDPOINT,
+        url: '/global',
+        method: 'GET',
+        params: apiKey,
+    };
+};
+exports.buildGlobalRequestBody = buildGlobalRequestBody;
+const constructEntry = (res, requestPayload, resultPath) => {
+    const resultData = res.data.data;
+    if (!resultData) {
+        logger.warn(`Data not found".`);
+        return;
+    }
+    const totalMarketcapData = resultData[resultPath];
+    if (!totalMarketcapData) {
+        logger.warn(`Data for "${resultPath}" not found".`);
+        return;
+    }
+    const result = totalMarketcapData[requestPayload.market.toLowerCase()];
+    if (!result) {
+        logger.warn(`Data for "${requestPayload.market}" not found".`);
+        return;
+    }
+    const entry = {
+        params: requestPayload,
+        value: result,
+    };
+    return entry;
+};
+exports.constructEntry = constructEntry;

package/examples/coingecko/src/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapter = void 0;
+const overrides_json_1 = __importDefault(require("./config/overrides.json"));
+const endpoint_1 = require("./endpoint");
+exports.adapter = {
+    defaultEndpoint: 'crypto',
+    name: 'coingecko',
+    endpoints: [endpoint_1.crypto, endpoint_1.coins, endpoint_1.cryptoMarketcap, endpoint_1.cryptoVolume, endpoint_1.dominance, endpoint_1.globalMarketcap],
+    overrides: overrides_json_1.default['coingecko'],
+};

package/examples/coingecko/test/e2e/adapter.test.js

@@ -0,0 +1,262 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-nested-callbacks */
+const index_1 = require("../../src/index");
+const __1 = require("../../../..");
+const supertest_1 = __importDefault(require("supertest"));
+let adapterServer;
+function sleep(ms) {
+    // eslint-disable-next-line
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+describe('execute', () => {
+    const id = '1';
+    let req;
+    jest.setTimeout(10000);
+    const successfulRequests = {
+        crypto: {
+            id,
+            data: {
+                base: 'ETH',
+                quote: 'USD',
+            },
+        },
+        cryptoWithCoinid: {
+            id,
+            data: {
+                coinid: 'bitcoin',
+                quote: 'USD',
+            },
+        },
+        cryptoWithOverride: {
+            id,
+            data: {
+                base: 'BTC',
+                quote: 'EUR',
+                overrides: {
+                    coingecko: {
+                        BTC: 'solana',
+                    },
+                },
+            },
+        },
+        coins: {
+            id,
+            endpoint: 'coins',
+        },
+        marketcap: {
+            id,
+            endpoint: 'marketcap',
+            data: {
+                base: 'ETH',
+                quote: 'USD',
+            },
+        },
+        volume: {
+            id,
+            endpoint: 'volume',
+            data: {
+                base: 'ETH',
+                quote: 'USD',
+            },
+        },
+        globalmarketcap: {
+            id,
+            endpoint: 'globalmarketcap',
+            data: {
+                market: 'ETH',
+            },
+        },
+        dominance: {
+            id,
+            endpoint: 'dominance',
+            data: {
+                market: 'ETH',
+            },
+        },
+    };
+    const errorRequests = {
+        cryptoWithBadSymbol: {
+            id,
+            data: {
+                base: 'ZWXK',
+                quote: 'USD',
+            },
+        },
+        cryptoWithBadOverride: {
+            id,
+            data: {
+                base: 'LINK',
+                quote: 'USD',
+                overrides: {
+                    coingecko: {
+                        LINK: 'badtokenid',
+                    },
+                },
+            },
+        },
+        dominanceWithBadSymbol: {
+            id,
+            endpoint: 'dominance',
+            data: {
+                market: 'ZWXK',
+            },
+        },
+    };
+    beforeAll(async () => {
+        try {
+            adapterServer = await (0, __1.expose)(index_1.adapter);
+            req = (0, supertest_1.default)('localhost:8080');
+        }
+        catch {
+            throw new Error('Could not start server when running CoinGecko e2e tests');
+        }
+        if (!adapterServer) {
+            throw new Error('Could not start server when running CoinGecko e2e tests');
+        }
+        // Send inital requests to warm the cache
+        const pendingRequests = [];
+        for (const reqData of Object.values(successfulRequests)) {
+            pendingRequests.push(req.post('/').send(reqData));
+        }
+        for (const reqData of Object.values(errorRequests)) {
+            pendingRequests.push(req.post('/').send(reqData));
+        }
+        // Wait for all the pending requests to be complete
+        Promise.all(pendingRequests);
+        // Sleep while the cache is filled
+        await sleep(5000);
+    });
+    afterAll((done) => {
+        if (adapterServer) {
+            adapterServer.close(done());
+        }
+    });
+    describe('crypto api', () => {
+        it('should return success', async () => {
+            // Send inital request to warm cache
+            const response = await req
+                .post('/')
+                .send(successfulRequests.crypto)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect(200);
+            expect(response.body.result).toBeGreaterThan(0);
+        });
+        it('should return success with coinid', async () => {
+            const response = await req
+                .post('/')
+                .send(successfulRequests.cryptoWithCoinid)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect('Content-Type', /json/)
+                .expect(200);
+            expect(response.body.result).toBeGreaterThan(0);
+        });
+        it('should return error message for bad symbol', async () => {
+            await req
+                .post('/')
+                .send(errorRequests.cryptoWithBadSymbol)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect(504);
+        });
+        it('should return success with override', async () => {
+            const response = await req
+                .post('/')
+                .send(successfulRequests.cryptoWithOverride)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect('Content-Type', /json/)
+                .expect(200);
+            expect(response.body.result).toBeGreaterThan(0);
+        });
+        it('should return 504 for bad override', async () => {
+            const response = await req
+                .post('/')
+                .send(errorRequests.cryptoWithBadOverride)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect(504);
+            expect(typeof response.body.result === 'string');
+        });
+        it('should return 504 for bad symbol', async () => {
+            await req
+                .post('/')
+                .send(errorRequests.cryptoWithBadSymbol)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect(504);
+        });
+    });
+    describe('coins api', () => {
+        it('should return success', async () => {
+            await req
+                .post('/')
+                .send(successfulRequests.coins)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect('Content-Type', /json/)
+                .expect(200);
+        });
+    });
+    describe('volume api', () => {
+        it('should return success', async () => {
+            const response = await req
+                .post('/')
+                .send(successfulRequests.volume)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect('Content-Type', /json/)
+                .expect(200);
+            expect(response.body.result).toBeGreaterThan(0);
+        });
+    });
+    describe('marketcap api', () => {
+        it('should return success', async () => {
+            const response = await req
+                .post('/')
+                .send(successfulRequests.marketcap)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect('Content-Type', /json/)
+                .expect(200);
+            expect(response.body.result).toBeGreaterThan(0);
+        });
+    });
+    describe('globalmarketcap api', () => {
+        it('should return success', async () => {
+            const response = await req
+                .post('/')
+                .send(successfulRequests.globalmarketcap)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect('Content-Type', /json/)
+                .expect(200);
+            expect(response.body.result).toBeGreaterThan(0);
+        });
+    });
+    describe('dominance api', () => {
+        it('should return success', async () => {
+            const response = await req
+                .post('/')
+                .send(successfulRequests.dominance)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect('Content-Type', /json/)
+                .expect(200);
+            expect(response.body.result).toBeGreaterThan(0);
+        });
+        it('should return 504 for bad symbol', async () => {
+            await req
+                .post('/')
+                .send(errorRequests.dominanceWithBadSymbol)
+                .set('Accept', '*/*')
+                .set('Content-Type', 'application/json')
+                .expect(504);
+        });
+    });
+});