Cryptocurrency dollar cost averaging using YepCode

# Crypto DCA on Kraken

This is a YepCode process to implement [dollar cost averaging (DCA)](https://en.wikipedia.org/wiki/Dollar_cost_averaging) investment with cryptocurrencies on [Kraken](https://www.kraken.com/) exchange using its [REST API](https://docs.kraken.com/rest/). 

In orther to use this YepCode process, you have to be customer of Kraken, and you have to create one pair of API keys.

## Kraken API keys creation

You can do this with the following steps:

* Login to your Kraken account.
* Visit *Security / API* under user menu.
* Press *Add key* and set the following permissions:
  * Funds:
    * Query Funds
  * Order & Trades:
    * Query Open Orders & Trades
    * Query Closed Orders & Trades
    * Create & Modify Orders
    * Cancel/Close Orders
* Press *Generate Key* and backup your new API keys

More info in [Kraken help](https://support.kraken.com/hc/en-us/articles/360000919966-How-to-generate-an-API-key-pair-)

{
  "type": "object",
  "title": "DCA orders configuration",
  "properties": {
    "cashCurrencyCode": {
      "title": "The cash currency code with available amount on Kraken account",
      "description": "Valid values: USD, EUR, CAD, JPY, GBP, CHF, AUD",
      "type": "string"
    },
    "cryptoCurrencyCode": {
      "title": "The crypto currency to buy",
      "description": "Valid values: BTC, ETH, ADA, BNB, SOL, DOT,...",
      "type": "string"
    },
    "closeOpenOrdersForThisCrypto": {
      "title": "Close open orders for this currency pair?",
      "type": "boolean"
    },
    "marketOrderQuantity": {
      "title": "Amount of cashCurrencyCode to invest at current price",
      "description": "If some quantity is set, a market price order will be created",
      "type": "number",
      "default": 0
    },
    "ordersBelowCurrentPrice": {
      "title": "Other orders for lower price",
      "description": "Process allow to create orders for a reduced market price (in percentage)",
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "pricePercentage": {
            "title": "The percentage (0.01-0.99) of the current price to place this order",
            "description": "If you set 0.85, and current price is 300, the order would be created for 255",
            "type": "number",
            "default": 0,
            "min": 0.01,
            "max": 0.99
          },
          "quantity": {
            "title": "Amount of cashCurrencyCode to invest at this percentage",
            "type": "number",
            "default": 0
          }
        }
      }
    }
  },
  "required": [
    "cashCurrencyCode",
    "cryptoCurrencyCode"
  ]
} 

// JS module copied, with some minor changes, from:
// https://github.com/nothingisdead/npm-kraken-api/blob/master/kraken.js

const { post } = require("axios");
const { createHash, createHmac } = require("crypto");
const { stringify } = require("query-string");

// Public/Private method names
const methods = {
    public: [
        "Time",
        "Assets",
        "AssetPairs",
        "Ticker",
        "Depth",
        "Trades",
        "Spread",
        "OHLC",
    ],
    private: [
        "Balance",
        "TradeBalance",
        "OpenOrders",
        "ClosedOrders",
        "QueryOrders",
        "TradesHistory",
        "QueryTrades",
        "OpenPositions",
        "Ledgers",
        "QueryLedgers",
        "TradeVolume",
        "AddOrder",
        "CancelOrder",
        "DepositMethods",
        "DepositAddresses",
        "DepositStatus",
        "WithdrawInfo",
        "Withdraw",
        "WithdrawStatus",
        "WithdrawCancel",
        "GetWebSocketsToken",
    ],
};

// Default options
const defaults = {
    url: "https://api.kraken.com",
    version: 0,
    timeout: 5000,
};

// Create a signature for a request
const getMessageSignature = (path, request, secret, nonce) => {
    const message = stringify(request);
    const secret_buffer = new Buffer.from(secret, "base64");
    const hash = new createHash("sha256");
    const hmac = new createHmac("sha512", secret_buffer);
    const hash_digest = hash.update(nonce + message).digest("binary");
    const hmac_digest = hmac
        .update(path + hash_digest, "binary")
        .digest("base64");

    return hmac_digest;
};

// Send an API request
const rawRequest = async (url, headers, data, timeout) => {
    // Set custom User-Agent string
    headers["User-Agent"] = "Kraken Javascript API Client";

    const options = { headers, timeout };

    const { data: response } = await post(
        url,
        stringify(data),
        options
    );

    if (response.error && response.error.length) {
        const error = response.error
            .filter((e) => e.startsWith("E"))
            .map((e) => e.substr(1));

        if (!error.length) {
            throw new Error("Kraken API returned an unknown error");
        }

        throw new Error(error.join(", "));
    }

    return response;
};

/**
 * KrakenClient connects to the Kraken.com API
 * @param {String}        key               API Key
 * @param {String}        secret            API Secret
 * @param {String|Object} [options={}]      Additional options. If a string is passed, will default to just setting `options.otp`.
 * @param {String}        [options.otp]     Two-factor password (optional) (also, doesn't work)
 * @param {Number}        [options.timeout] Maximum timeout (in milliseconds) for all API-calls (passed to `request`)
 */
class KrakenClient {
    constructor(key, secret, options) {
        // Allow passing the OTP as the third argument for backwards compatibility
        if (typeof options === "string") {
            options = { otp: options };
        }

        this.config = Object.assign({ key, secret }, defaults, options);
    }

    /**
     * This method makes a public or private API request.
     * @param  {String}   method   The API method (public or private)
     * @param  {Object}   params   Arguments to pass to the api call
     * @param  {Function} callback A callback function to be executed when the request is complete
     * @return {Object}            The request object
     */
    api(method, params, callback) {
        // Default params to empty object
        if (typeof params === "function") {
            callback = params;
            params = {};
        }

        if (methods.public.includes(method)) {
            return this.publicMethod(method, params, callback);
        } else if (methods.private.includes(method)) {
            return this.privateMethod(method, params, callback);
        } else {
            throw new Error(method + " is not a valid API method.");
        }
    }

    /**
     * This method makes a public API request.
     * @param  {String}   method   The API method (public or private)
     * @param  {Object}   params   Arguments to pass to the api call
     * @param  {Function} callback A callback function to be executed when the request is complete
     * @return {Object}            The request object
     */
    publicMethod(method, params, callback) {
        params = params || {};

        // Default params to empty object
        if (typeof params === "function") {
            callback = params;
            params = {};
        }

        const path = "/" + this.config.version + "/public/" + method;
        const url = this.config.url + path;
        const response = rawRequest(url, {}, params, this.config.timeout);

        if (typeof callback === "function") {
            response
                .then((result) => callback(null, result))
                .catch((error) => callback(error, null));
        }

        return response;
    }

    /**
     * This method makes a private API request.
     * @param  {String}   method   The API method (public or private)
     * @param  {Object}   params   Arguments to pass to the api call
     * @param  {Function} callback A callback function to be executed when the request is complete
     * @return {Object}            The request object
     */
    privateMethod(method, params, callback) {
        params = params || {};

        // Default params to empty object
        if (typeof params === "function") {
            callback = params;
            params = {};
        }

        const path = "/" + this.config.version + "/private/" + method;
        const url = this.config.url + path;

        if (!params.nonce) {
            params.nonce = new Date() * 1000; // spoof microsecond
        }

        if (this.config.otp !== undefined) {
            params.otp = this.config.otp;
        }

        const signature = getMessageSignature(
            path,
            params,
            this.config.secret,
            params.nonce
        );

        const headers = {
            "API-Key": this.config.key,
            "API-Sign": signature,
        };

        const response = rawRequest(url, headers, params, this.config.timeout);

        if (typeof callback === "function") {
            response
                .then((result) => callback(null, result))
                .catch((error) => callback(error, null));
        }

        return response;
    }
}

module.exports = KrakenClient;

module.exports.getAltName = (cashCurrencyCode, cryptoCurrencyCode) => {
    return (cryptoCurrencyCode == 'BTC' ? 'XBT' : cryptoCurrencyCode) + cashCurrencyCode;
}

module.exports.getCurrencyAssetPairsByAltName = async (kraken) => {
    const query = await kraken.api("AssetPairs");
    const assetPairsByAltName = {};
    for (const tradingPair in query.result) {
        const altname = query.result[tradingPair].altname;
        assetPairsByAltName[altname] = {
            tradingPair,
            orderMin: parseFloat(query.result[tradingPair].ordermin),
        };
    }
    return assetPairsByAltName;
}

const cashCurrencyToAssetCode = (cashCurrencyCode) => {
    return "Z" + cashCurrencyCode;
};

module.exports.getBalance = async (kraken, cashCurrencyCode) => {
    const query = await kraken.api("Balance");
    return query.result[cashCurrencyToAssetCode(cashCurrencyCode)];
}

module.exports.getOpenOrders = async (kraken) => {
    const query = await kraken.api("OpenOrders");
    return query.result["open"];
}

module.exports.closeOrder = async (kraken, orderId) => {
    return kraken.api("CancelOrder", { txid: orderId });
}

module.exports.getCurrentPrice = async (kraken, pair) => {
    const query = await kraken.api("Ticker", { pair });
    return query.result[pair]["b"][0];
}

module.exports.addOrder = async (kraken, pair, price, volume) => {
    const newOrderParams = {
        pair,
        type: "buy",
        ordertype: "limit",
        price,
        volume,
    };
    //console.log(`New order params: ${JSON.stringify(newOrderParams)}`);
    return kraken.api("AddOrder", newOrderParams);
} 

const {
    context: { parameters },
} = yepcode;

const KrakenClient = yepcode.import('kraken-api-client');
const krakenHelper = yepcode.import('kraken-api-helper-methods');

const kraken = new KrakenClient(yepcode.env.KRAKEN_API_KEY, yepcode.env.KRAKEN_API_SECRET);

const validCashCurrencyCodes = ['USD', 'EUR', 'CAD', 'JPY', 'GBP', 'CHF', 'AUD'];

if (!validCashCurrencyCodes.includes(parameters.cashCurrencyCode)) {
    console.error(`Invalid cashCurrencyCode ${parameters.cashCurrencyCode}. Valid values are ${validCashCurrencyCodes}`);
    return;
}

const cashBalance = await krakenHelper.getBalance(kraken, parameters.cashCurrencyCode);
if (!cashBalance) {
    console.error(`No available balance in ${parameters.cashCurrencyCode}`);
    return;
}

console.log(`Current balance in ${parameters.cashCurrencyCode} is ${cashBalance}`);

const assetPairsByAltName = await krakenHelper.getCurrencyAssetPairsByAltName(kraken);
const altName = krakenHelper.getAltName(parameters.cashCurrencyCode, parameters.cryptoCurrencyCode);
const assetPair = assetPairsByAltName[altName];
if (!assetPair) {
    console.error(`No assetPair found for alt name ${altName}. Available values are ${JSON.stringify(assetPairsByAltName)}`);
    return;
}
const { tradingPair, orderMin } = assetPair;
console.log(`Trading pair to be used is ${tradingPair}`);
console.log(`Minimum order volume is ${orderMin}`);

let openOrdersRemovedAmount = 0;

if (parameters.closeOpenOrdersForThisCrypto) {
    const openOrdersById = await krakenHelper.getOpenOrders(kraken);
    console.log(`There already are ${Object.keys(openOrdersById).length} opened orders`);

    for (const orderId in openOrdersById) {
        const order = openOrdersById[orderId];
        if (order.descr.pair == tradingPair) {
            console.log(`Found order of pair ${tradingPair} to be closed: ${orderId}`);
            const queryCancel = await krakenHelper.closeOrder(kraken, orderId);
            console.log(`Order closed ${queryCancel}`);
            openOrdersRemovedAmount++;
        }
    }
}

const currentPrice = await krakenHelper.getCurrentPrice(kraken, tradingPair);
console.log(`Current price of ${parameters.cryptoCurrencyCode} is ${currentPrice}${parameters.cashCurrencyCode}`);

const currentPriceAmountOfDecimals = currentPrice.toString().split(".")[1].length || 0; 

let ordersToCreate = [];
if (parameters.marketOrderQuantity && parameters.marketOrderQuantity > 0) {
    ordersToCreate.push({
        pricePercentage: 1,
        quantity: parameters.marketOrderQuantity
    })
}
if (parameters.ordersBelowCurrentPrice) {
    ordersToCreate = ordersToCreate.concat(parameters.ordersBelowCurrentPrice);
}

const createdOrders = [];

console.log(`Creating ${ordersToCreate.length} orders`);
for (const [i, order] of ordersToCreate.entries()) {
    const { pricePercentage, quantity } = order;
    if (pricePercentage < 0.01 || pricePercentage > 1) {
        console.error(`Order ${i + 1} not created. Percentage must be in range 0.01 - 1`);
        continue;
    }

    const putBid = parseFloat((currentPrice * pricePercentage).toFixed(currentPriceAmountOfDecimals));
    const volume = quantity / putBid;

    if (volume < orderMin) {
        console.error(`Order ${i + 1} not created. Volume must be higher than ${orderMin} (attempt to use ${volume})`);
        continue;
    }

    const totalCost = volume * putBid;
    console.log(`Order ${i + 1} - Total cost ${totalCost}${parameters.cashCurrencyCode} / Price ${putBid}${parameters.cashCurrencyCode} / Amount ${volume}${parameters.cryptoCurrencyCode}`);
    const newOrder = await krakenHelper.addOrder(kraken, tradingPair, putBid, volume);
    const description = newOrder.result.descr.order;
    const transactionId = newOrder.result.txid;
    console.log(`New order created with id ${transactionId} (${description}))`);
    createdOrders.push({
        transactionId,
        totalCost,
        price: putBid,
        volume
    })
}

const mailHtmlContent = `
<p>Your Kraken balance in <strong>${parameters.cashCurrencyCode}</strong> is <strong>${cashBalance}</strong>.</p>

<p>Current price of <strong>${parameters.cryptoCurrencyCode}</strong> is <strong>${currentPrice}</strong>.</p>

${(openOrdersRemovedAmount > 0 ? `<p><strong>${openOrdersRemovedAmount}</strong> opened order for <strong>${tradingPair}</strong> already existed, and have been removed.</p>` : '')}

<p><strong>${ordersToCreate.length}</strong> new orders have been created:</p>

<table border="1" cellpadding="1" cellspacing="1" style="width:500px">
	<tbody>
		<tr>
			<td>Order id</td>
			<td>Total cost in <strong>${parameters.cashCurrencyCode}</strong></td>
			<td>Price in <strong>${parameters.cryptoCurrencyCode}</strong></td>
			<td>Amount in <strong>${parameters.cryptoCurrencyCode}</strong></td>
		</tr>
        ${createdOrders.map(({ transactionId, totalCost, price, volume }) => {
            return `<tr>
                <td>${transactionId}</td>
                <td>${totalCost}</td>
                <td>${price}</td>
                <td>${volume}</td>
            </tr>`;
        }).join('')}
    </tbody>
</table>
`

const mailClient = yepcode.integration.nodemailer('gmail-account')

await mailClient.sendMail({
    from: "YepCode ",
    to: "cryptobuyer@gmail.com",
    subject: `YepCode DCA Bot   - New orders for crypto ${parameters.cryptoCurrencyCode}`,
    html: mailHtmlContent
})
console.log("Report email sent");