@pipedream/coincatch 0.0.1 → 0.1.0

package/actions/get-candle-data/get-candle-data.mjs

@@ -0,0 +1,74 @@
+import coincatch from "../../coincatch.app.mjs";
+import constants from "../../common/constants.mjs";
+
+export default {
+  key: "coincatch-get-candle-data",
+  name: "Get Candle Data",
+  description: "Gets candle data. [See the documentation](https://coincatch.github.io/github.io/en/mix/#get-candle-data)",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  props: {
+    coincatch,
+    productType: {
+      propDefinition: [
+        coincatch,
+        "productType",
+      ],
+    },
+    symbol: {
+      propDefinition: [
+        coincatch,
+        "symbol",
+        ({ productType }) => ({
+          productType,
+        }),
+      ],
+    },
+    granularity: {
+      type: "string",
+      label: "Granularity",
+      description: "The type of candlestick interval",
+      options: constants.GRANULARITIES,
+    },
+    startTime: {
+      propDefinition: [
+        coincatch,
+        "startTime",
+      ],
+    },
+    endTime: {
+      propDefinition: [
+        coincatch,
+        "endTime",
+      ],
+    },
+    limit: {
+      type: "integer",
+      label: "Limit",
+      description: "The maximum number of candlesticks to return",
+      optional: true,
+      min: 1,
+      default: 100,
+      max: 1000,
+    },
+  },
+  async run({ $ }) {
+    const response = await this.coincatch.getCandleData({
+      $,
+      params: {
+        symbol: this.symbol,
+        granularity: this.granularity,
+        startTime: new Date(this.startTime).getTime(),
+        endTime: new Date(this.endTime).getTime(),
+        limit: this.limit,
+      },
+    });
+    $.export("$summary", `Successfully retrieved ${response?.length} candle data points for \`${this.symbol}\``);
+    return response;
+  },
+};

package/actions/get-depth/get-depth.mjs

@@ -0,0 +1,54 @@
+import coincatch from "../../coincatch.app.mjs";
+import constants from "../../common/constants.mjs";
+
+export default {
+  key: "coincatch-get-depth",
+  name: "Get Depth",
+  description: "Gets depth data. [See the documentation](https://coincatch.github.io/github.io/en/mix/#get-depth)",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  props: {
+    coincatch,
+    productType: {
+      propDefinition: [
+        coincatch,
+        "productType",
+      ],
+    },
+    symbol: {
+      propDefinition: [
+        coincatch,
+        "symbol",
+        ({ productType }) => ({
+          productType,
+        }),
+      ],
+    },
+    limit: {
+      type: "string",
+      label: "Limit",
+      description: "The maximum number of depth data to return. Default: `100`",
+      optional: true,
+      options: constants.MARKET_DEPTH_LIMITS,
+      default: "100",
+    },
+  },
+  async run({ $ }) {
+    const response = await this.coincatch.getDepth({
+      $,
+      params: {
+        symbol: this.symbol,
+        limit: this.limit
+          ? parseInt(this.limit)
+          : undefined,
+      },
+    });
+    $.export("$summary", `Successfully retrieved depth data for \`${this.symbol}\``);
+    return response;
+  },
+};

package/actions/get-history-funding-rate/get-history-funding-rate.mjs

@@ -0,0 +1,57 @@
+import coincatch from "../../coincatch.app.mjs";
+
+export default {
+  key: "coincatch-get-history-funding-rate",
+  name: "Get History Funding Rate",
+  description: "Get history funding rate. [See the documentation](https://coincatch.github.io/github.io/en/mix/#get-history-funding-rate)",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  props: {
+    coincatch,
+    productType: {
+      propDefinition: [
+        coincatch,
+        "productType",
+      ],
+    },
+    symbol: {
+      propDefinition: [
+        coincatch,
+        "symbol",
+        ({ productType }) => ({
+          productType,
+        }),
+      ],
+    },
+    pageSize: {
+      propDefinition: [
+        coincatch,
+        "pageSize",
+      ],
+    },
+    pageNumber: {
+      propDefinition: [
+        coincatch,
+        "pageNumber",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.coincatch.getHistoryFundingRate({
+      $,
+      params: {
+        productType: this.productType,
+        symbol: this.symbol,
+        pageSize: this.pageSize,
+        pageNo: this.pageNumber,
+      },
+    });
+    $.export("$summary", `Successfully retrieved history funding rate for ${this.symbol}`);
+    return response;
+  },
+};

package/actions/get-history-orders/get-history-orders.mjs

@@ -0,0 +1,70 @@
+import coincatch from "../../coincatch.app.mjs";
+
+export default {
+  key: "coincatch-get-history-orders",
+  name: "Get History Orders",
+  description: "Gets history orders. [See the documentation](https://coincatch.github.io/github.io/en/mix/#get-history-orders)",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  props: {
+    coincatch,
+    productType: {
+      propDefinition: [
+        coincatch,
+        "productType",
+      ],
+    },
+    symbol: {
+      propDefinition: [
+        coincatch,
+        "symbol",
+        ({ productType }) => ({
+          productType,
+        }),
+      ],
+    },
+    startTime: {
+      propDefinition: [
+        coincatch,
+        "startTime",
+      ],
+    },
+    endTime: {
+      propDefinition: [
+        coincatch,
+        "endTime",
+      ],
+    },
+    pageSize: {
+      propDefinition: [
+        coincatch,
+        "pageSize",
+      ],
+    },
+    lastEndId: {
+      type: "string",
+      label: "Last End ID",
+      description: "last end ID of last query. This is used to paginate the results.",
+      optional: true,
+    },
+  },
+  async run({ $ }) {
+    const response = await this.coincatch.getHistoryOrders({
+      $,
+      params: {
+        symbol: this.symbol,
+        startTime: new Date(this.startTime).getTime(),
+        endTime: new Date(this.endTime).getTime(),
+        pageSize: this.pageSize,
+        lastEndId: this.lastEndId,
+      },
+    });
+    $.export("$summary", `Successfully retrieved history orders for \`${this.symbol}\``);
+    return response;
+  },
+};

package/actions/get-open-orders/get-open-orders.mjs

@@ -0,0 +1,46 @@
+import coincatch from "../../coincatch.app.mjs";
+
+export default {
+  key: "coincatch-get-open-orders",
+  name: "Get Open Orders",
+  description: "Get pending order list on one symbol. [See the documentation](https://coincatch.github.io/github.io/en/mix/#get-open-order)",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  props: {
+    coincatch,
+    productType: {
+      propDefinition: [
+        coincatch,
+        "productType",
+      ],
+    },
+    symbol: {
+      propDefinition: [
+        coincatch,
+        "symbol",
+        ({ productType }) => ({
+          productType,
+        }),
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.coincatch.getOpenOrders({
+      $,
+      params: {
+        symbol: this.symbol,
+      },
+    });
+    if (response.data?.orderList?.length) {
+      $.export("$summary", `Successfully retrieved ${response.data.orderList.length} pending orders for ${this.symbol}`);
+    } else {
+      $.export("$summary", "No pending orders found");
+    }
+    return response;
+  },
+};

package/actions/get-position-tier/get-position-tier.mjs

@@ -0,0 +1,43 @@
+import coincatch from "../../coincatch.app.mjs";
+
+export default {
+  key: "coincatch-get-position-tier",
+  name: "Get Position Tier",
+  description: "Gets position tier. [See the documentation](https://coincatch.github.io/github.io/en/mix/#get-position-tier)",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  props: {
+    coincatch,
+    productType: {
+      propDefinition: [
+        coincatch,
+        "productType",
+      ],
+    },
+    symbol: {
+      propDefinition: [
+        coincatch,
+        "symbol",
+        ({ productType }) => ({
+          productType,
+        }),
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.coincatch.getPositionTier({
+      $,
+      params: {
+        symbol: this.symbol,
+        productType: this.productType,
+      },
+    });
+    $.export("$summary", `Successfully retrieved position tier for \`${this.symbol}\``);
+    return response;
+  },
+};

package/actions/get-single-account/get-single-account.mjs

@@ -0,0 +1,52 @@
+import coincatch from "../../coincatch.app.mjs";
+
+export default {
+  key: "coincatch-get-single-account",
+  name: "Get Single Account",
+  description: "Gets a single account. [See the documentation](https://coincatch.github.io/github.io/en/mix/#get-single-account)",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  props: {
+    coincatch,
+    productType: {
+      propDefinition: [
+        coincatch,
+        "productType",
+      ],
+    },
+    symbol: {
+      propDefinition: [
+        coincatch,
+        "symbol",
+        ({ productType }) => ({
+          productType,
+        }),
+      ],
+    },
+    marginCoin: {
+      propDefinition: [
+        coincatch,
+        "marginCoin",
+        ({ productType }) => ({
+          productType,
+        }),
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.coincatch.getSingleAccount({
+      $,
+      params: {
+        symbol: this.symbol,
+        marginCoin: this.marginCoin,
+      },
+    });
+    $.export("$summary", "Successfully retrieved account details");
+    return response;
+  },
+};

package/actions/get-single-symbol-ticker/get-single-symbol-ticker.mjs

@@ -0,0 +1,42 @@
+import coincatch from "../../coincatch.app.mjs";
+
+export default {
+  key: "coincatch-get-single-symbol-ticker",
+  name: "Get Single Symbol Ticker",
+  description: "Gets single symbol ticker. [See the documentation](https://coincatch.github.io/github.io/en/mix/#get-single-symbol-ticker)",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  props: {
+    coincatch,
+    productType: {
+      propDefinition: [
+        coincatch,
+        "productType",
+      ],
+    },
+    symbol: {
+      propDefinition: [
+        coincatch,
+        "symbol",
+        ({ productType }) => ({
+          productType,
+        }),
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.coincatch.getSingleSymbolTicker({
+      $,
+      params: {
+        symbol: this.symbol,
+      },
+    });
+    $.export("$summary", `Successfully retrieved single symbol ticker for \`${this.symbol}\``);
+    return response;
+  },
+};

package/actions/get-symbol-mark-price/get-symbol-mark-price.mjs

@@ -0,0 +1,42 @@
+import coincatch from "../../coincatch.app.mjs";
+
+export default {
+  key: "coincatch-get-symbol-mark-price",
+  name: "Get Symbol Mark Price",
+  description: "Get symbol mark price. [See the documentation](https://coincatch.github.io/github.io/en/mix/#get-symbol-mark-price)",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  props: {
+    coincatch,
+    productType: {
+      propDefinition: [
+        coincatch,
+        "productType",
+      ],
+    },
+    symbol: {
+      propDefinition: [
+        coincatch,
+        "symbol",
+        ({ productType }) => ({
+          productType,
+        }),
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.coincatch.getSymbolMarkPrice({
+      $,
+      params: {
+        symbol: this.symbol,
+      },
+    });
+    $.export("$summary", `Successfully retrieved symbol mark price for ${this.symbol}`);
+    return response;
+  },
+};

package/actions/list-symbols/list-symbols.mjs

@@ -0,0 +1,33 @@
+import coincatch from "../../coincatch.app.mjs";
+
+export default {
+  key: "coincatch-list-symbols",
+  name: "List Symbols",
+  description: "List all symbols. [See the documentation](https://coincatch.github.io/github.io/en/mix/#get-all-symbols)",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  props: {
+    coincatch,
+    productType: {
+      propDefinition: [
+        coincatch,
+        "productType",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const response = await this.coincatch.listSymbols({
+      $,
+      params: {
+        productType: this.productType,
+      },
+    });
+    $.export("$summary", `Successfully retrieved ${response?.data?.length} symbols`);
+    return response;
+  },
+};

package/coincatch.app.mjs

@@ -1,11 +1,220 @@
+import { axios } from "@pipedream/platform";
+import crypto from "crypto";
+import constants from "./common/constants.mjs";
+
 export default {
   type: "app",
   app: "coincatch",
-  propDefinitions: {},
+  propDefinitions: {
+    productType: {
+      type: "string",
+      label: "Product Type",
+      description: "Product type",
+      options: constants.PRODUCT_TYPES,
+    },
+    marginCoin: {
+      type: "string",
+      label: "Margin Coin",
+      description: "Margin coin",
+      async options({ productType }) {
+        const { data } = await this.listAccounts({
+          params: {
+            productType,
+          },
+        });
+        return data.map(({ marginCoin }) => marginCoin);
+      },
+    },
+    symbol: {
+      type: "string",
+      label: "Symbol",
+      description: "Symbol (Must be capitalized)",
+      async options({ productType }) {
+        const { data } = await this.listSymbols({
+          params: {
+            productType,
+          },
+        });
+        return data.map(({ symbol }) => symbol);
+      },
+    },
+    pageSize: {
+      type: "integer",
+      label: "Page Size",
+      description: "Page size",
+      default: 100,
+      min: 1,
+      max: 100,
+    },
+    pageNumber: {
+      type: "integer",
+      label: "Page Number",
+      description: "Page number",
+      default: 1,
+    },
+    startTime: {
+      type: "string",
+      label: "Start Time",
+      description: "The start time to use. Example: `2025-01-01T00:00:00Z`",
+    },
+    endTime: {
+      type: "string",
+      label: "End Time",
+      description: "The end time to use. Example: `2025-01-01T00:00:00Z`",
+    },
+  },
   methods: {
-    // this.$auth contains connected account data
-    authKeys() {
-      console.log(Object.keys(this.$auth));
+    createSignedHeaders({
+      method,
+      requestPath,
+      queryString = "",
+      body = "",
+    }) {
+      const accessKey = this.$auth.access_key;
+      const secretKey = this.$auth.secret_key;
+      const passphrase = this.$auth.passphrase;
+      const timestamp = Date.now().toString();
+      const upperMethod = method.toUpperCase();
+
+      // Build content to sign
+      let contentToSign = timestamp + upperMethod + requestPath;
+      if (queryString) {
+        contentToSign += "?" + queryString;
+      }
+      if (body) {
+        contentToSign += body;
+      }
+
+      // Generate signature
+      const hmac = crypto.createHmac("sha256", secretKey);
+      hmac.update(contentToSign);
+      const signature = hmac.digest("base64");
+
+      return {
+        timestamp,
+        method: upperMethod,
+        requestPath,
+        queryString,
+        body,
+        contentToSign,
+        signature,
+        headers: {
+          "ACCESS-KEY": accessKey,
+          "ACCESS-SIGN": signature,
+          "ACCESS-TIMESTAMP": timestamp,
+          "ACCESS-PASSPHRASE": passphrase,
+        },
+      };
+    },
+    cleanObject(o) {
+      for (const k in o || {}) {
+        if (typeof o[k] === "undefined") {
+          delete o[k];
+        }
+      }
+    },
+    makeRequest({
+      $ = this, method = "GET", path, params, data,
+    }) {
+      if (params) {
+        this.cleanObject(params);
+      }
+      if (data) {
+        this.cleanObject(data);
+      }
+      const resp = this.createSignedHeaders({
+        method,
+        requestPath: path,
+        queryString: params
+          ? new URLSearchParams(params).toString()
+          : undefined,
+        body: data
+          ? JSON.stringify(data)
+          : undefined,
+      });
+
+      const url = `https://api.coincatch.com${resp.requestPath}${resp.queryString
+        ? "?" + resp.queryString
+        : ""
+      }`;
+
+      if (data) {
+        resp.headers["Content-Type"] = "application/json";
+      }
+
+      // Make the API request
+      return axios($, {
+        method: resp.method,
+        url,
+        headers: resp.headers,
+        data: resp.body || undefined,
+      });
+    },
+    listAccounts(opts = {}) {
+      return this.makeRequest({
+        path: "/api/mix/v1/account/accounts",
+        ...opts,
+      });
+    },
+    listSymbols(opts = {}) {
+      return this.makeRequest({
+        path: "/api/mix/v1/market/contracts",
+        ...opts,
+      });
+    },
+    getSingleAccount(opts = {}) {
+      return this.makeRequest({
+        path: "/api/mix/v1/account/account",
+        ...opts,
+      });
+    },
+    getHistoryFundingRate(opts = {}) {
+      return this.makeRequest({
+        path: "/api/mix/v1/market/history-fundRate",
+        ...opts,
+      });
+    },
+    getSymbolMarkPrice(opts = {}) {
+      return this.makeRequest({
+        path: "/api/mix/v1/market/mark-price",
+        ...opts,
+      });
+    },
+    getOpenOrders(opts = {}) {
+      return this.makeRequest({
+        path: "/api/mix/v1/order/current",
+        ...opts,
+      });
+    },
+    getCandleData(opts = {}) {
+      return this.makeRequest({
+        path: "/api/mix/v1/market/candles",
+        ...opts,
+      });
+    },
+    getDepth(opts = {}) {
+      return this.makeRequest({
+        path: "/api/mix/v1/market/depth",
+        ...opts,
+      });
+    },
+    getHistoryOrders(opts = {}) {
+      return this.makeRequest({
+        path: "/api/mix/v1/order/history",
+        ...opts,
+      });
+    },
+    getPositionTier(opts = {}) {
+      return this.makeRequest({
+        path: "/api/mix/v1/market/queryPositionLever",
+        ...opts,
+      });
+    },
+    getSingleSymbolTicker(opts = {}) {
+      return this.makeRequest({
+        path: "/api/mix/v1/market/ticker",
+        ...opts,
+      });
     },
   },
-};
+};

package/common/constants.mjs

@@ -0,0 +1,106 @@
+const PRODUCT_TYPES = [
+  {
+    value: "UMCBL",
+    label: "USDT perpetual contract",
+  },
+  {
+    value: "DMCBL",
+    label: "Universal margin perpetual contract",
+  },
+];
+
+const GRANULARITIES = [
+  {
+    value: "1m",
+    label: "1 minute",
+  },
+  {
+    value: "3m",
+    label: "3 minutes",
+  },
+  {
+    value: "5m",
+    label: "5 minutes",
+  },
+  {
+    value: "15m",
+    label: "15 minutes",
+  },
+  {
+    value: "30m",
+    label: "30 minutes",
+  },
+  {
+    value: "1H",
+    label: "1 hour",
+  },
+  {
+    value: "2H",
+    label: "2 hours",
+  },
+  {
+    value: "4H",
+    label: "4 hours",
+  },
+  {
+    value: "6H",
+    label: "6 hours",
+  },
+  {
+    value: "12H",
+    label: "12 hours",
+  },
+  {
+    value: "1D",
+    label: "1 day",
+  },
+  {
+    value: "3D",
+    label: "3 days",
+  },
+  {
+    value: "1W",
+    label: "1 week",
+  },
+  {
+    value: "1M",
+    label: "1 month",
+  },
+  {
+    value: "6Hutc",
+    label: "6 hours UTC",
+  },
+  {
+    value: "12Hutc",
+    label: "12 hours UTC",
+  },
+  {
+    value: "1Dutc",
+    label: "1 day UTC",
+  },
+  {
+    value: "3Dutc",
+    label: "3 days UTC",
+  },
+  {
+    value: "1Wutc",
+    label: "1 week UTC",
+  },
+  {
+    value: "1Mutc",
+    label: "1 month UTC",
+  },
+];
+
+const MARKET_DEPTH_LIMITS = [
+  "5",
+  "15",
+  "50",
+  "100",
+];
+
+export default {
+  PRODUCT_TYPES,
+  GRANULARITIES,
+  MARKET_DEPTH_LIMITS,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/coincatch",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Pipedream CoinCatch Components",
   "main": "coincatch.app.mjs",
   "keywords": [
@@ -11,5 +11,8 @@
   "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@pipedream/platform": "^3.1.1"
   }
 }