@pinata/sdk 1.2.0 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pinata/sdk",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Official SDK for the Pinata IPFS platform",
   "main": "lib/pinata-sdk.js",
   "types": "types/index.d.ts",

package/src/commands/data/getFilesByCount/getFilesByCount.js

@@ -1,14 +1,11 @@
-import { validateApiKeys } from '../../../util/validators';
 import pinList from '../pinList/pinList';
 
 export default function getFilesByCount(
-    pinataApiKey,
-    pinataSecretApiKey,
+    config,
 
     filters = {},
     maxCount = -1
 ) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
     if (maxCount === 0) {
         throw Error("Max count can't be 0");
     }
@@ -26,7 +23,7 @@ export default function getFilesByCount(
                     return new Promise((resolve, reject) => {
                         if (i === 0 || (i % pageLimit === 0 && keepLooping)) {
                             resolve(
-                                pinList(pinataApiKey, pinataSecretApiKey, {
+                                pinList(config, {
                                     filters,
                                     ...{ pageOffset, pageLimit }
                                 }).then((resp) => {

package/src/commands/data/pinList/pinList.js

@@ -1,6 +1,6 @@
 import axios from 'axios';
 import { baseUrl } from './../../../constants';
-import { validateApiKeys } from '../../../util/validators';
+import { createConfigForAxiosHeaders } from '../../../util/validators';
 import { handleError } from '../../../util/errorResponse';
 import queryBuilder from './queryBuilder';
 
@@ -11,9 +11,7 @@ import queryBuilder from './queryBuilder';
  * @param {any} filters
  * @returns {Promise<unknown>}
  */
-export default function pinList(pinataApiKey, pinataSecretApiKey, filters = {}) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
-
+export default function pinList(config, filters = {}) {
     filters = {...filters, ...{includeCount: 'false' }};
 
     const baseEndpoint = `${baseUrl}/data/pinList`;
@@ -22,13 +20,8 @@ export default function pinList(pinataApiKey, pinataSecretApiKey, filters = {})
     return new Promise((resolve, reject) => {
         axios.get(
             endpoint,
-            {
-                withCredentials: true,
-                headers: {
-                    'pinata_api_key': pinataApiKey,
-                    'pinata_secret_api_key': pinataSecretApiKey
-                }
-            }).then(function (result) {
+            {...createConfigForAxiosHeaders(config)})
+        .then(function (result) {
             if (result.status !== 200) {
                 reject(new Error(`unknown server response while attempting to retrieve user pin list: ${result}`));
             }

package/src/commands/data/testAuthentication.js

@@ -1,6 +1,6 @@
 import axios from 'axios';
 import { baseUrl } from './../../constants';
-import {validateApiKeys} from '../../util/validators';
+import {createConfigForAxiosHeaders} from '../../util/validators';
 import { handleError } from '../../util/errorResponse';
 
 /**
@@ -9,22 +9,15 @@ import { handleError } from '../../util/errorResponse';
  * @param {string} pinataSecretApiKey
  * @returns {Promise<unknown>}
  */
-export default function testAuthentication(pinataApiKey, pinataSecretApiKey) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
-
+export default function testAuthentication(config) {
     //  test authentication to make sure that the user's provided keys are legit
     const endpoint = `${baseUrl}/data/testAuthentication`;
 
     return new Promise((resolve, reject) => {
         axios.get(
             endpoint,
-            {
-                withCredentials: true,
-                headers: {
-                    'pinata_api_key': pinataApiKey,
-                    'pinata_secret_api_key': pinataSecretApiKey
-                }
-            }).then(function (result) {
+            {...createConfigForAxiosHeaders(config)})
+        .then(function (result) {
             if (result.status !== 200) {
                 reject(new Error(`unknown server response while authenticating: ${result}`));
             }

package/src/commands/data/userPinnedDataTotal.js

@@ -1,6 +1,6 @@
 import axios from 'axios';
 import { baseUrl } from './../../constants';
-import { validateApiKeys } from '../../util/validators';
+import { createConfigForAxiosHeaders } from '../../util/validators';
 import { handleError } from '../../util/errorResponse';
 
 /**
@@ -9,21 +9,14 @@ import { handleError } from '../../util/errorResponse';
  * @param {string} pinataSecretApiKey
  * @returns {Promise<unknown>}
  */
-export default function userPinnedDataTotal(pinataApiKey, pinataSecretApiKey) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
-
+export default function userPinnedDataTotal(config) {
     let endpoint = `${baseUrl}/data/userPinnedDataTotal`;
 
     return new Promise((resolve, reject) => {
         axios.get(
             endpoint,
-            {
-                withCredentials: true,
-                headers: {
-                    'pinata_api_key': pinataApiKey,
-                    'pinata_secret_api_key': pinataSecretApiKey
-                }
-            }).then(function (result) {
+            {...createConfigForAxiosHeaders(config)})
+        .then(function (result) {
             if (result.status !== 200) {
                 reject(new Error(`unknown server response while attempting to retrieve pinned data total: ${result}`));
             }

package/src/commands/pinning/hashMetadata.js

@@ -1,6 +1,6 @@
 import axios from 'axios';
 import { baseUrl } from './../../constants';
-import { validateApiKeys, validateMetadata } from '../../util/validators';
+import { createConfigForAxiosHeaders, validateMetadata } from '../../util/validators';
 import isIPFS from 'is-ipfs';
 import { handleError } from '../../util/errorResponse';
 
@@ -12,9 +12,7 @@ import { handleError } from '../../util/errorResponse';
  * @param {*} metadata
  * @returns {Promise<unknown>}
  */
-export default function hashMetadata(pinataApiKey, pinataSecretApiKey, ipfsPinHash, metadata) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
-
+export default function hashMetadata(config, ipfsPinHash, metadata) {
     if (!ipfsPinHash) {
         throw new Error('ipfsPinHash value is required for changing the pin policy of a pin');
     }
@@ -46,13 +44,8 @@ export default function hashMetadata(pinataApiKey, pinataSecretApiKey, ipfsPinHa
         axios.put(
             endpoint,
             body,
-            {
-                withCredentials: true,
-                headers: {
-                    'pinata_api_key': pinataApiKey,
-                    'pinata_secret_api_key': pinataSecretApiKey
-                }
-            }).then(function (result) {
+            {...createConfigForAxiosHeaders(config)})
+            .then(function (result) {
             if (result.status !== 200) {
                 reject(new Error(`unknown server response while changing metadata for hash: ${result}`));
             }

package/src/commands/pinning/hashPinPolicy.js

@@ -1,6 +1,6 @@
 import axios from 'axios';
 import { baseUrl } from './../../constants';
-import { validateApiKeys, validatePinPolicyStructure } from '../../util/validators';
+import { createConfigForAxiosHeaders, validatePinPolicyStructure } from '../../util/validators';
 import isIPFS from 'is-ipfs';
 import { handleError } from '../../util/errorResponse';
 
@@ -12,8 +12,7 @@ import { handleError } from '../../util/errorResponse';
  * @param {*} newPinPolicy
  * @returns {Promise<unknown>}
  */
-export default function hashPinPolicy(pinataApiKey, pinataSecretApiKey, ipfsPinHash, newPinPolicy) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
+export default function hashPinPolicy(config, ipfsPinHash, newPinPolicy) {
     validatePinPolicyStructure(newPinPolicy);
 
     if (!ipfsPinHash) {
@@ -38,13 +37,8 @@ export default function hashPinPolicy(pinataApiKey, pinataSecretApiKey, ipfsPinH
         axios.put(
             endpoint,
             body,
-            {
-                withCredentials: true,
-                headers: {
-                    'pinata_api_key': pinataApiKey,
-                    'pinata_secret_api_key': pinataSecretApiKey
-                }
-            }).then(function (result) {
+            {...createConfigForAxiosHeaders(config)})
+            .then(function (result) {
             if (result.status !== 200) {
                 reject(new Error(`unknown server response while changing pin policy for hash: ${result}`));
             }

package/src/commands/pinning/pinByHash.js

@@ -1,6 +1,6 @@
 import axios from 'axios';
 import { baseUrl } from './../../constants';
-import { validateApiKeys, validateMetadata } from '../../util/validators';
+import { createConfigForAxiosHeaders, validateMetadata } from '../../util/validators';
 import isIPFS from 'is-ipfs';
 import { handleError } from '../../util/errorResponse';
 
@@ -12,9 +12,7 @@ import { handleError } from '../../util/errorResponse';
  * @param {*} options
  * @returns {Promise<unknown>}
  */
-export default function pinByHash(pinataApiKey, pinataSecretApiKey, hashToPin, options) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
-
+export default function pinByHash(config, hashToPin, options) {
     if (!hashToPin) {
         throw new Error('hashToPin value is required for pinning by hash');
     }
@@ -42,13 +40,8 @@ export default function pinByHash(pinataApiKey, pinataSecretApiKey, hashToPin, o
         axios.post(
             endpoint,
             body,
-            {
-                withCredentials: true,
-                headers: {
-                    'pinata_api_key': pinataApiKey,
-                    'pinata_secret_api_key': pinataSecretApiKey
-                }
-            }).then(function (result) {
+            {...createConfigForAxiosHeaders(config)})
+        .then(function (result) {
             if (result.status !== 200) {
                 reject(new Error(`unknown server response while adding to pin queue: ${result}`));
             }

package/src/commands/pinning/pinFileToIPFS.js

@@ -2,7 +2,7 @@ import axios from 'axios';
 import { baseUrl } from './../../constants';
 import NodeFormData from 'form-data';
 import stream from 'stream';
-import {validateApiKeys, validateMetadata, validatePinataOptions} from '../../util/validators';
+import {createConfigForAxiosHeadersWithFormData, validateMetadata, validatePinataOptions} from '../../util/validators';
 import { handleError } from '../../util/errorResponse';
 
 /**
@@ -13,9 +13,7 @@ import { handleError } from '../../util/errorResponse';
  * @param {*} options
  * @returns {Promise<unknown>}
  */
-export default function pinFileToIPFS(pinataApiKey, pinataSecretApiKey, readStream, options) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
-
+export default function pinFileToIPFS(config, readStream, options) {
     return new Promise((resolve, reject) => {
 
         const data = new NodeFormData();
@@ -38,20 +36,11 @@ export default function pinFileToIPFS(pinataApiKey, pinataSecretApiKey, readStre
                 data.append('pinataOptions', JSON.stringify(options.pinataOptions));
             }
         }
-
-        axios.post(
+           axios.post(
             endpoint,
             readStream instanceof NodeFormData ? readStream : data,
-            {
-                withCredentials: true,
-                maxContentLength: 'Infinity', //this is needed to prevent axios from erroring out with large files
-                maxBodyLength: 'Infinity',
-                headers: {
-                    'Content-type': `multipart/form-data; boundary= ${data._boundary}`,
-                    'pinata_api_key': pinataApiKey,
-                    'pinata_secret_api_key': pinataSecretApiKey
-                }
-            }).then(function (result) {
+            createConfigForAxiosHeadersWithFormData(config, data._boundary)
+        ).then(function (result) {
             if (result.status !== 200) {
                 reject(new Error(`unknown server response while pinning File to IPFS: ${result}`));
             }

package/src/commands/pinning/pinFromFS.js

@@ -1,7 +1,7 @@
 import axios from 'axios';
 import { baseUrl } from './../../constants';
 import NodeFormData from 'form-data';
-import {validateApiKeys, validateMetadata, validatePinataOptions} from '../../util/validators';
+import {createConfigForAxiosHeadersWithFormData, validateMetadata, validatePinataOptions} from '../../util/validators';
 import basePathConverter from 'base-path-converter';
 import { handleError } from '../../util/errorResponse';
 const fs = require('fs');
@@ -15,8 +15,7 @@ const recursive = require('recursive-fs');
  * @param {*} options
  * @returns {Promise<unknown>}
  */
-export default function pinFromFS(pinataApiKey, pinataSecretApiKey, sourcePath, options) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
+export default function pinFromFS(config, sourcePath, options) {
 
     return new Promise((resolve, reject) => {
         const endpoint = `${baseUrl}/pinning/pinFileToIPFS`;
@@ -45,16 +44,8 @@ export default function pinFromFS(pinataApiKey, pinataSecretApiKey, sourcePath,
                 axios.post(
                     endpoint,
                     data,
-                    {
-                        withCredentials: true,
-                        maxContentLength: 'Infinity', //this is needed to prevent axios from erroring out with large directories
-                        maxBodyLength: 'Infinity',
-                        headers: {
-                            'Content-type': `multipart/form-data; boundary= ${data._boundary}`,
-                            'pinata_api_key': pinataApiKey,
-                            'pinata_secret_api_key': pinataSecretApiKey
-                        }
-                    }).then(function (result) {
+                    createConfigForAxiosHeadersWithFormData(config, data._boundary))
+                .then(function (result) {
                     if (result.status !== 200) {
                         reject(new Error(`unknown server response while pinning File to IPFS: ${result}`));
                     }
@@ -92,16 +83,8 @@ export default function pinFromFS(pinataApiKey, pinataSecretApiKey, sourcePath,
                     axios.post(
                         endpoint,
                         data,
-                        {
-                            withCredentials: true,
-                            maxContentLength: 'Infinity',
-                            maxBodyLength: 'Infinity', //this is needed to prevent axios from erroring out with large directories
-                            headers: {
-                                'Content-type': `multipart/form-data; boundary= ${data._boundary}`,
-                                'pinata_api_key': pinataApiKey,
-                                'pinata_secret_api_key': pinataSecretApiKey
-                            }
-                        }).then(function (result) {
+                        createConfigForAxiosHeadersWithFormData(config, data._boundary))
+                    .then(function (result) {
                         if (result.status !== 200) {
                             reject(new Error(`unknown server response while pinning File to IPFS: ${result}`));
                         }

package/src/commands/pinning/pinJSONToIPFS.js

@@ -1,6 +1,6 @@
 import axios from 'axios';
 import { baseUrl } from './../../constants';
-import { validateApiKeys, validateMetadata, validatePinataOptions } from '../../util/validators';
+import { createConfigForAxiosHeaders, validateMetadata, validatePinataOptions } from '../../util/validators';
 import { handleError } from '../../util/errorResponse';
 
 /**
@@ -11,8 +11,7 @@ import { handleError } from '../../util/errorResponse';
  * @param {*} options
  * @returns {Promise<unknown>}
  */
-export default function pinJSONToIPFS(pinataApiKey, pinataSecretApiKey, body, options) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
+export default function pinJSONToIPFS(config, body, options) {
 
     let requestBody = body;
 
@@ -40,13 +39,8 @@ export default function pinJSONToIPFS(pinataApiKey, pinataSecretApiKey, body, op
         axios.post(
             endpoint,
             requestBody,
-            {
-                withCredentials: true,
-                headers: {
-                    'pinata_api_key': pinataApiKey,
-                    'pinata_secret_api_key': pinataSecretApiKey
-                }
-            }).then(function (result) {
+            {...createConfigForAxiosHeaders(config)})
+        .then(function (result) {
             if (result.status !== 200) {
                 reject(new Error(`unknown server response while pinning JSON to IPFS: ${result}`));
             }

package/src/commands/pinning/pinJobs/pinJobs.js

@@ -1,6 +1,6 @@
 import axios from 'axios';
 import { baseUrl } from './../../../constants';
-import { validateApiKeys } from '../../../util/validators';
+import { createConfigForAxiosHeaders } from '../../../util/validators';
 import queryBuilder from './queryBuilder';
 import { handleError } from '../../../util/errorResponse';
 
@@ -11,8 +11,7 @@ import { handleError } from '../../../util/errorResponse';
  * @param {*} filters
  * @returns {Promise<unknown>}
  */
-export default function pinJobs(pinataApiKey, pinataSecretApiKey, filters) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
+export default function pinJobs(config, filters) {
 
     let endpoint = `${baseUrl}/pinning/pinJobs`;
 
@@ -23,13 +22,8 @@ export default function pinJobs(pinataApiKey, pinataSecretApiKey, filters) {
     return new Promise((resolve, reject) => {
         axios.get(
             endpoint,
-            {
-                withCredentials: true,
-                headers: {
-                    'pinata_api_key': pinataApiKey,
-                    'pinata_secret_api_key': pinataSecretApiKey
-                }
-            }).then(function (result) {
+            {...createConfigForAxiosHeaders(config)})
+        .then(function (result) {
             if (result.status !== 200) {
                 reject(new Error(`unknown server response while attempting to retrieve pin jobs: ${result}`));
             }

package/src/commands/pinning/unpin.js

@@ -1,6 +1,6 @@
 import axios from 'axios';
 import { baseUrl } from './../../constants';
-import { validateApiKeys } from '../../util/validators';
+import { createConfigForAxiosHeaders } from '../../util/validators';
 import isIPFS from 'is-ipfs';
 import { handleError } from '../../util/errorResponse';
 
@@ -11,9 +11,7 @@ import { handleError } from '../../util/errorResponse';
  * @param {string} hashToUnpin
  * @returns {Promise<unknown>}
  */
-export default function unpin(pinataApiKey, pinataSecretApiKey, hashToUnpin) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
-
+export default function unpin(config, hashToUnpin) {
     if (!hashToUnpin) {
         throw new Error('hashToUnpin value is required for removing a pin from Pinata');
     }
@@ -26,13 +24,8 @@ export default function unpin(pinataApiKey, pinataSecretApiKey, hashToUnpin) {
     return new Promise((resolve, reject) => {
         axios.delete(
             endpoint,
-            {
-                withCredentials: true,
-                headers: {
-                    'pinata_api_key': pinataApiKey,
-                    'pinata_secret_api_key': pinataSecretApiKey
-                }
-            }).then(function (result) {
+            {...createConfigForAxiosHeaders(config)})
+        .then(function (result) {
             if (result.status !== 200) {
                 reject(new Error(`unknown server response while removing pin from IPFS: ${result}`));
             }

package/src/commands/pinning/userPinPolicy.js

@@ -1,6 +1,6 @@
 import axios from 'axios';
 import { baseUrl } from './../../constants';
-import { validateApiKeys, validatePinPolicyStructure } from '../../util/validators';
+import { createConfigForAxiosHeaders, validatePinPolicyStructure } from '../../util/validators';
 import { handleError } from '../../util/errorResponse';
 
 /**
@@ -10,8 +10,7 @@ import { handleError } from '../../util/errorResponse';
  * @param {*} newPinPolicy
  * @returns {Promise<unknown>}
  */
-export default function userPinPolicy(pinataApiKey, pinataSecretApiKey, newPinPolicy) {
-    validateApiKeys(pinataApiKey, pinataSecretApiKey);
+export default function userPinPolicy(config, newPinPolicy) {
     validatePinPolicyStructure(newPinPolicy);
 
     if (!newPinPolicy) {
@@ -27,13 +26,8 @@ export default function userPinPolicy(pinataApiKey, pinataSecretApiKey, newPinPo
         axios.put(
             endpoint,
             body,
-            {
-                withCredentials: true,
-                headers: {
-                    'pinata_api_key': pinataApiKey,
-                    'pinata_secret_api_key': pinataSecretApiKey
-                }
-            }).then(function (result) {
+            {...createConfigForAxiosHeaders(config)})
+            .then(function (result) {
             if (result.status !== 200) {
                 reject(new Error(`unknown server response while changing pin policy for user: ${result}`));
             }

package/src/constants.js

@@ -1 +1,4 @@
 export const baseUrl = 'https://api.pinata.cloud';
+
+export const ERROR_NO_CREDENTIALS_PROVIDED =
+    'No credentials provided! Please provide your pinata api key and pinata secret api key or your pinata JWT key as an argument when you start this script';

package/src/index.js

@@ -199,8 +199,16 @@ import userPinnedDataTotal from './commands/data/userPinnedDataTotal';
  * @returns {Promise<number>}
  */
 
+/**
+ * @typedef {Object} PinataConfig
+ * @property {string} [pinataApiKey]
+ * @property {string} [pinataSecretApiKey]
+ * @property {string} [pinataJWTKey]
+ */
+
 /**
  * @typedef PinataClient
+ * @property {PinataConfig} config
  * @property {pinByHash} pinByHash
  * @property {hashMetadata} hashMetadata
  * @property {pinFileToIPFS} pinFileToIPFS
@@ -213,50 +221,87 @@ import userPinnedDataTotal from './commands/data/userPinnedDataTotal';
  * @property {userPinnedDataTotal} userPinnedDataTotal
  */
 
+function refactorConfig(pinataConfigParam) {
+    const config = {};
+    if (pinataConfigParam.pinataApiKey) {
+        config.pinataApiKey = pinataConfigParam.pinataApiKey;
+    }
+
+    if (pinataConfigParam.pinataSecretApiKey) {
+        config.pinataSecretApiKey = pinataConfigParam.pinataSecretApiKey;
+    }
+
+    if (pinataConfigParam.pinataJWTKey) {
+        config.pinataJWTKey = pinataConfigParam.pinataJWTKey;
+    }
+
+    return config;
+}
+function sanitizeConfig(pinataApiKey, pinataSecretApiKey) {
+    let config = {};
+
+    if (
+        typeof pinataApiKey === 'string' &&
+        typeof pinataSecretApiKey === 'string'
+    ) {
+        config.pinataApiKey = pinataApiKey;
+        config.pinataSecretApiKey = pinataSecretApiKey;
+    }
+
+    const isPinataConfigParam = typeof pinataApiKey === 'object';
+    if (isPinataConfigParam) {
+        config = refactorConfig(pinataApiKey);
+    }
+
+    return config;
+}
+
 /**
  * Pinata Client
  *
- * @param {string} pinataApiKey
- * @param {string} pinataSecretApiKey
+ * @param {string | PinataConfig} [pinataApiKey]
+ * @param {string} [pinataSecretApiKey]
  * @returns {PinataClient}
  */
 export default function pinataClient(pinataApiKey, pinataSecretApiKey) {
-    let client = {};
+    const client = {
+        config: sanitizeConfig(pinataApiKey, pinataSecretApiKey)
+    };
 
     //  setting up the actual calls you can make using this package
     client.pinByHash = function (hashToPin, options) {
-        return pinByHash(pinataApiKey, pinataSecretApiKey, hashToPin, options);
+        return pinByHash(client.config, hashToPin, options);
     };
     client.hashMetadata = function (ipfsPinHash, metadata) {
-        return hashMetadata(pinataApiKey, pinataSecretApiKey, ipfsPinHash, metadata);
+        return hashMetadata(client.config, ipfsPinHash, metadata);
     };
     client.pinFileToIPFS = function (readableStream, options) {
-        return pinFileToIPFS(pinataApiKey, pinataSecretApiKey, readableStream, options);
+        return pinFileToIPFS(client.config, readableStream, options);
     };
     client.pinFromFS = function (sourcePath, options) {
-        return pinFromFS(pinataApiKey, pinataSecretApiKey, sourcePath, options);
+        return pinFromFS(client.config, sourcePath, options);
     };
     client.pinJSONToIPFS = function (body, options) {
-        return pinJSONToIPFS(pinataApiKey, pinataSecretApiKey, body, options);
+        return pinJSONToIPFS(client.config, body, options);
     };
     client.pinJobs = function (filters) {
-        return pinJobs(pinataApiKey, pinataSecretApiKey, filters);
+        return pinJobs(client.config, filters);
     };
     client.unpin = function (hashToUnpin) {
-        return unpin(pinataApiKey, pinataSecretApiKey, hashToUnpin);
+        return unpin(client.config, hashToUnpin);
     };
     client.testAuthentication = function () {
-        return testAuthentication(pinataApiKey, pinataSecretApiKey);
+        return testAuthentication(client.config);
     };
     client.pinList = function (filters) {
-        return pinList(pinataApiKey, pinataSecretApiKey, filters);
+        return pinList(client.config, filters);
     };
 
-    client.getFilesByCount = function (filters, maxCount,) {
-        return getFilesByCount(pinataApiKey, pinataSecretApiKey, filters, maxCount);
+    client.getFilesByCount = function (filters, maxCount) {
+        return getFilesByCount(client.config, filters, maxCount);
     };
     client.userPinnedDataTotal = function () {
-        return userPinnedDataTotal(pinataApiKey, pinataSecretApiKey);
+        return userPinnedDataTotal(client.config);
     };
     return client;
 }