• Talinn, Estonia
  • support@lnsolutions.ee

Bitcoin Trading Bot Development on Discord Trading Signals and LN Markets - Part 2

admin English

Integrating Machine Learning and Python AI Agents

 

In the first part of this series (or here for non subscribers), we built a Bitcoin trading bot that listens to trading signals (for example from a Discord channel) and executes trades on LN Markets. The core pieces were:

  • Signal ingestion from Discord (or any other alert source).
  • Order execution via the LN Markets REST API.
  • Persistence of trades into a local SQLite database to avoid duplicate executions.

In this second part, we’ll evolve that architecture into something more intelligent: a bot that keeps your existing trading strategy logic, but delegates parts of your strategy to a Python-based machine learning (ML) agent.

This is a pattern you can reuse:

  • Keep your entry strategy and core trading logic in Node.js.
  • Let a separate Python agent learn from your historical trades.
  • Have the agent produce data-driven parameters your bot can consume at runtime.

1. From Static Rules to Data‑Driven Parameters

In a typical first version of a trading bot, some parameters are hard-coded or stored in a config file:

  • Fixed protective distances per timeframe.
  • One-size-fits-all trailing behavior.
  • Limited awareness of how different indicators or regimes behave.

This is easy to implement but has clear limitations:

  • It doesn’t adapt when the market regime changes.
  • It can’t tell that some indicator/timeframe combinations consistently behave better or worse.
  • You end up tuning numbers manually, often with incomplete feedback.

The architecture we’ll discuss keeps your discretionary or rule-based strategy intact, but adds a feedback loop:

  1. Log trades and price behavior into a database.
  2. Train a Python ML model over those trades.
  3. Write out a compact JSON file with regime-specific parameter guidance.
  4. Have the Node.js bot read that JSON and adjust parameters accordingly.

The result is a bot that is still your strategy, but with a data-informed parameter layer wrapping it.

2. High-Level Architecture

Let’s zoom out. The evolved system has four main components:

  • Signal source: Discord messages, TradingView webhooks, or any alerting mechanism that produces structured signals.
  • Node.js trading bot (execution engine)
 Parses incoming signals.
Decides whether a new trade should be opened or an existing one closed.
Calls LN Markets via ln-markets/api.
Persists trade metadata into trades.db.
  • SQLite database (trades.db)
Stores each trade along with metadata such as indicator, timeframe, trade type, and price information.
Accumulates realized statistics about how trades behave once they are opened.
Python parameter ML agent
Runs periodically (e.g., hourly) in its own virtual environment.
Loads historical trades from trades.db.
Engineers features and trains an ML model.
Writes out a JSON file (e.g., params.json) containing per‑regime parameters.
The Node bot reloads this JSON and uses it as an overlay on top of your existing config.

Conceptually, the pipeline looks like this:

Signals → Node Bot → LN Markets & trades.db
trades.db → Python ML Agent → params.json → Node Bot (param overlay)

3. Instrumenting Your Bot: Logging the Right Data

Before bringing ML into the picture, your bot needs to produce the raw material the agent will learn from.

In the Node.js side you already have:

  • A trade creation path that:
  • Receives a signal from Discord or another source.
  • Decides whether to open a long or short.
  • Sends the order to LN Markets (for example with futuresNewTrade).
  • Writes the trade to trades.db (ID, timestamps, prices, indicator, timeframe, trade type).

To support ML-driven parameter management, add or ensure:

  • Regime identifiers
    For each trade, log fields such as:
  • Indicator name (e.g., “MACD” or similar).
  • Timeframe (e.g., 15m, 1h, 4h).
  • Trade type (e.g., long/short).
  • A simple market regime flag (e.g., “downtrend” vs “not downtrend”).
  • Price behavior after entry
    Your bot can run a frequent cron (e.g., every 30 seconds) that:
Fetches open trades from LN Markets.
Tracks the min and max price each trade sees while it is open.
Persists these “extreme” prices back into the database as simple summary statistics.

This is enough for a Python agent to reconstruct:

  • How much adverse movement trades typically experience after entry.
  • How much favorable movement is common by regime.
  • How different regimes (indicator + timeframe + trend flag) differ in realized behavior.

4. The Python Parameter ML Agent

 

The Python agent‘s responsibilities are:

  1. Read historical trades from SQLite
  • Connect to trades.db 
  • Query trades with the fields logged earlier:
  • Indicator, timeframe, trade type.
  • Regime flag(s).
  • Entry and protective prices.
  • Optionally, stored min/max excursion prices.

def main():
    """Main execution function."""
    print("=" * 60)
    print("AI Trading Bot Parameter Generator")
    print("=" * 60)
    
    # Resolve paths
    db_path = Path(__file__).parent / DB_PATH
    output_path = Path(__file__).parent / OUTPUT_PATH
    
    if not db_path.exists():
        print(f"ERROR: Database not found at {db_path}")
        return 1
    
    # Ensure output directory exists
    output_path.parent.mkdir(parents=True, exist_ok=True)
    
    # Load data
    df = load_trade_data(str(db_path))

 

2. Engineer features: Typical features include:

  • Categorical / one‑hot:
Indicator.
Timeframe.
Trade type (long vs short).
  • Numerical:
Regime flags (e.g., a boolean for trending vs ranging).
Distance to a moving average at entry.
Whether the entry was near a recent local high/low.
Simple time-of-day or day-of-week information.
def engineer_features(df):
    """Engineer features for ML model."""
    # Create derived features
    df['ma_distance'] = np.where(
        df['movingAverage'].notna() & (df['entryprice'] != 0),
        (df['entryprice'] - df['movingAverage']) / df['entryprice'],
        0
    )
    
    df['local_bottom_distance'] = np.where(
        df['localBottom'].notna() & (df['entryprice'] != 0),
        (df['entryprice'] - df['localBottom']) / df['entryprice'],
        0
    )
    
    df['local_top_distance'] = np.where(
        df['localTop'].notna() & (df['entryprice'] != 0),
        (df['localTop'] - df['entryprice']) / df['entryprice'],
        0
    )
    
    print(f"Engineered features for {len(df)} trades")
    return df

 

3. Train an ML model: The agent can use a tree-based regressor such as XGBoost (or any library in your stack) to learn a mapping from:

  • (indicator, timeframe, regime, trade type, features)
    → recommended parameters (you decide the exact definition).
def train_model(df):
    """Train XGBoost model """
    print("Training XGBoost model...")
    
    # Define target and features
    target = 'sl_pct'
    exclude_cols = [
        target,
        'entryprice',
        'stoploss',
        'takeprofit',
        'profit',
        'movingAverage',
        'localBottom',
        'localTop',
        'features',
    ]
    
    feature_cols = [col for col in df.columns if col not in exclude_cols]
    
    X = df[feature_cols]
    y = df[target]
    
    # Split data
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42
    )
    
    # Train model
    model = XGBRegressor(
        n_estimators=100,
        max_depth=5,
        learning_rate=0.1,
        random_state=42,
        objective='reg:squarederror'
    )
    
    model.fit(X_train, y_train)
    
    # Evaluate
    y_pred = model.predict(X_test)
    mae = mean_absolute_error(y_test, y_pred)
    rmse = np.sqrt(mean_squared_error(y_test, y_pred))
    
    print(f"Model trained successfully!")
    print(f"  MAE: {mae:.4f}%")
    print(f"  RMSE: {rmse:.4f}%")
    print(f"  Feature importance (top 5):")
    
    feature_importance = sorted(
        zip(feature_cols, model.feature_importances_),
        key=lambda x: x[1],
        reverse=True
    )[:5]
    
    for feat, importance in feature_importance:
        print(f"    {feat}: {importance:.4f}")
    
    return model, feature_cols
  1. Importantly, this model is never called directly from the Node.js bot at runtime.
    Instead, the agent runs offline, finishes training, and then produces a static JSON artifact.

4. Aggregate by regime and write JSON: Rather than storing one prediction per trade, the agent:

  • Groups trades by (indicator, timeframe, regime flag, trade type).
  • Computes aggregates per group, such as:
  • How trades in that regime have historically behaved.
  • A recommended set of parameters for that regime.

The output is written to something like:

  • analysis/params.json

Structured as a nested object keyed by:

  • Indicator → timeframe → regime key → trade type.

Each leaf contains statistics and recommended parameters.
Again, this is your design: you decide what “parameter” means; the pattern here is only about how to export and consume it.

5. Calling the Python Agent from Node.js

 

On the Node.js side, you integrate the Python agent as a background job.

  1. Define a helper to run the agent: A helper function builds a command that:
  • Points to the Python interpreter inside the agent’s virtual environment.
  • Calls the training script.
  • Sets the working directory to the agent folder.
  • Captures and logs stdout / stderr.
  • Treats any non‑zero exit as a failure and logs it.

This keeps the ML agent separate from your trading loop. The trading bot only cares that a JSON file appears when training succeeds.

2. Schedule periodic retraining: Using a scheduler like node-cron, you can:

  • Run the agent hourly (or at any cadence you choose).
  • After each run:
Reload the params.json file into memory.
  1. If anything goes wrong (Python error, data problem, etc.), your bot can simply continue using the previous JSON or fall back to static config. That way the ML agent can fail safely without interrupting live trading.

6. Using ML Output Inside the Trading Bot

 

With params.json successfully loaded, the Node.js bot can expose a couple of helper functions that act as a thin translation layer between:

  • The ML agent’s JSON schema, and
  • The rest of your trading logic.

Typical patterns:

  • Lookup helper for parameters. A function that takes:
  • Indicator.
  • Timeframe.
  • Regime flag(s).
  • Trade type.

Then:

  • Attempts to find a matching entry in params.json.
  • If found, returns the recommended parameters for that regime.
  • If not found, returns your existing config-based defaults.

This ensures backwards compatibility: you can always turn off the ML overlay or let it “fill in” only for regimes with enough data.

  • The key point: the structure and decisions about your trading algo stay in Node.js;
    the numbers feeding into those decisions can be learned and updated automatically by the Python agent.

7. Safety, Monitoring, and Versioning

Whenever you plug ML into a live trading system, you need guardrails. Some important patterns:

  • Safe fallbacks
  • Never overwrite the previous JSON on failed training runs.
  • If loading JSON fails, keep running with the last known-good version or static config values.
  • Config switch
  • Add a feature flag (for example in your existing config file) to:
  • Enable or disable ML-derived parameters.
  • Allow quick rollback to pure config behavior.
  • Logging
  • For each trade, log:
  • Whether the parameters came from ML or from static config.
  • Which regime key was used.
  • The model version (if included in JSON metadata).
  • Model metadata
  • Store simple metadata inside the JSON:
  • Training end timestamp.
  • Number of samples used.
  • Model version identifier (for example a Git commit or semantic version).
  • Retraining policy
  • Decide how often to retrain (e.g. daily or weekly).
  • Optionally use a rolling window of recent trades (e.g. last few months) if you want the model to focus on current market conditions.

These patterns are generic and apply to any trading strategy, not just the one in this bot.

8. Conclusion

In Part 1 we focused on connecting a Node.js bot to LN Markets and executing trades from external signals. In this Part 2, we extended that architecture with a Python ML agent that learns from your historical trades and feeds the bot with regime-aware parameters via a simple JSON interface.

The critical design choices were:

  • Keep the trading engine and the ML agent loosely coupled.
  • Use trades.db as the shared source of truth.
  • Expose ML output only through a small, versioned JSON file.
  • Maintain fallbacks and observability at every step.

From here, you can extend the same pattern to:

  • Tune entry thresholds offline.
  • Introduce ML-assisted filters for trade quality.
  • Add dynamic position sizing based on regime performance.

All of this leverages machine learning and Python AI agents to make your trading bot more adaptive and data-driven.

XRechnung Addon for Alfresco

admin English

XRechnung Addon for Alfresco – Installation & Usage Guide

The XRechnung LNSolutions addon extends Alfresco with full support for German XRechnung electronic invoices. It automatically detects XRechnung XML documents, enriches them with metadata, and generates high-quality HTML and PDF renditions via a dedicated Transform Engine (T‑Engine).

1. Components & Download Links

The solution consists of three main components:

  1. License Module (mandatory)
    Provides license validation for all LNSolutions addons.
    Download:  lnsolutions-alfresco-license-1.0.0.jar
  2. XRechnung Platform Addon (mandatory)
    Alfresco Repository extension for XRechnung detection, metadata aspect xr:xrechnungMetadata, and integration with the T‑Engine.
    Download:  xrechnung-lnsolutions-platform-1.0.jar
  3. XRechnung T‑Engine (mandatory for HTML/PDF)
    Standalone Spring Boot microservice that transforms XRechnung XML to HTML and feeds Alfresco’s PDF pipeline.
    Download JAR:  xrechnung-tengine-1.0.jar
    or Docker Image:  xrechnung-tengine:latest

2. Prerequisites

  • Alfresco Content Services 7.x+ (Repository)
  • Java 11+ on the Alfresco side and T‑Engine side
  • Access to deploy JARs (Tomcat WEB-INF/lib or custom Docker image)
  • Valid LNSolutions license key (or trial license)

To request a trial license, use:
Request XRechnung trial license

3. Installing the License Module

  1. Stop Alfresco.
  2. Copy lnsolutions-alfresco-license-1.0.0.jar to:
    • <TOMCAT>/webapps/alfresco/WEB-INF/lib/ (non-Docker)
    • or bake it into your custom Alfresco Docker image.
  3. Start Alfresco and verify the license module is loaded (check logs).
  4. Install or upload your license key using the key xrechnung.license.public.key in your alfresco-global.properties file

4. Installing the XRechnung Platform Addon

  1. Stop Alfresco.
  2. Copy xrechnung-lnsolutions-platform-1.0-SNAPSHOT.jar to:
    • <TOMCAT>/webapps/alfresco/WEB-INF/lib/ (non-Docker)
    • or into your custom Alfresco Docker image.
  3. Ensure the license module is loaded before this module (the XRechnung module declares a dependency on lnsolutions-alfresco-license).
  4. Start Alfresco and check logs for XRechnung module initialization.

4.1. Alfresco Configuration

In alfresco-global.properties (or equivalent Docker environment), add the XRechnung T‑Engine URL:

# URL of the XRechnung Transform Engine
localTransform.xrechnung.url=http://xrechnung-tengine:8091

Adjust the host/port to your environment (e.g. http://localhost:8091 for standalone testing).

5. Deploying the XRechnung T‑Engine

5.1. Run as Docker Container (recommended)

  1. Load or build the Docker image: 
    docker run -d -p 8091:8091 --name xrechnung-tengine xrechnung-tengine:latest
  2. Verify the service is running: 
    curl http://localhost:8091/ready

5.2. Run as Standalone JAR

  1. Start the service: 
    java -jar xrechnung-tengine-1.0-SNAPSHOT.jar
  2. Verify readiness: 
    curl http://localhost:8091/ready

5.3. T‑Engine Configuration (License & Core Transform)

Configure the following environment variables for the T‑Engine (e.g. in a .env file or service configuration):

XRECHNUNG_TRANSFORM_CONFIG=/opt/xrechnung-tengine/config/xrechnung-transform-config.json
CORE_AIO_TRANSFORM_URL=http://transform-core-aio:8090/transform
LICENSE_VALIDATION_URL=http://<alfresco-host>:8080/alfresco/service/lnsolutions/admin/license-status

The T‑Engine calls LICENSE_VALIDATION_URL before each transform to enforce your license via Alfresco.

6. Using the XRechnung Addon

6.1. Automatic Detection & Metadata

  1. Log into Alfresco as an administrator or user.
  2. Upload an XRechnung XML invoice (UBL or CII) to any folder.
  3. The XRechnungDetectionBehavior inspects the content and, if valid, automatically applies the XRechnung Metadata aspect (xr:xrechnungMetadata).
  4. In the document properties, you will see XRechnung-specific fields such as: Digital Invoice Profile, Digital Invoice Profile Description (Short), and Is Digital Invoice.

6.2. HTML Preview

  1. Open the document details page in Alfresco.
  2. Use the built-in preview: Alfresco requests an HTML rendition from the XRechnung T‑Engine and displays a nicely formatted invoice.
  3. For technical testing, you can also call the web script: 
    http://<alfresco-host>:8080/alfresco/service/lnsolutions/node/xrechnung-html?id={nodeId}


6.3. PDF Renditions

The addon also supports a PDF pipeline: XRechnung XML → HTML (T‑Engine) → PDF (Alfresco pdfRenderer).

  1. Upload an XRechnung XML document.
  2. Wait for Alfresco to generate renditions.
  3. Download the PDF rendition from the document details page and verify layout and characters (e.g. umlauts) are correct.

7. XRechnung Indicator & Behavior

The XRechnung addon uses the XRechnung Metadata aspect (xr:xrechnungMetadata) as the technical indicator that a document is a valid XRechnung invoice.

  • Is Digital Invoice (xr:isDigitalInvoice): Boolean flag that is set when a document is detected as XRechnung.
  • Digital Invoice Profile (xr:digitalInvoiceProfile): Stores the detected digital invoice profile identifier.
  • Digital Invoice Profile Description (Short) (xr:digitalInvoiceProfileDescShort): Short, human‑readable label for the detected profile (e.g. displayed as “Digital Invoice Profile Description (Short)” in Alfresco).

The XRechnungDetectionBehavior listens to document creation and updates for cm:content nodes. When an uploaded XML file matches the XRechnung patterns (based on its content, metadata, or filename), the behavior automatically adds the xr:xrechnungMetadata aspect and sets xr:isDigitalInvoice = true.

Only documents that carry this XRechnung indicator (the xr:xrechnungMetadata aspect with xr:isDigitalInvoice=true) are treated as XRechnung by the HTML/PDF transformation pipeline. Generic XML files remain unaffected until they are positively identified as XRechnung.

8. Requesting a Trial License

If you want to evaluate the XRechnung addon before purchasing a full license, request a trial here:

Request XRechnung Trial License

Or contact us for a permanent license.

Managing Git Feature Branches and Resolving Merge Conflicts

admin English

Managing Git Feature Branches and Resolving Merge Conflicts

Read more on Medium

 

Git is a powerful version control system widely used by developers to manage source code repositories. One of the key features of Git is its support for branching, allowing developers to work on new features or experiments without affecting the main codebase. However, managing branches and resolving merge conflicts effectively are crucial skills for successful collaboration and code management. In this article, we’ll explore common Git branching tasks and how to handle merge conflicts gracefully for feature branches.

Understanding Git Branches

Git branches are independent lines of development within a Git repository. They allow developers to work on different features, bug fixes, or experiments without affecting the main codebase. Here are some essential concepts related to Git branches:

  1. Creating a Branch: To create a new branch, you can use the git checkout -b <branch-name> command. This creates a new branch and switches to it in one step.
  2. Switching Branches: You can switch between branches using the git checkout <branch-name> command. This allows you to work on different features or bug fixes seamlessly.
  3. Listing Branches: To view a list of branches in your repository, you can use the git branch command. The branch you are currently on will be highlighted.
  4. Deleting a Branch: To delete a local branch in Git, you can use the git branch -d <branch-name> command. Be cautious when deleting branches, especially if they contain unmerged changes.

Handling Merge Conflicts

Merge conflicts occur when Git cannot automatically merge changes from different branches due to conflicting changes in the same part of a file. Here’s how to handle merge conflicts effectively:

  1. Fetching Remote Changes: Before merging branches, it’s essential to fetch the latest changes from the remote repository using git pull origin <branch-name>.
  2. Merging Branches: To merge changes from one branch into another, you can use the git merge <branch-name> command. Git will attempt to automatically merge the changes. If there are conflicts, Git will pause the merge process.
  3. Resolving Conflicts: To resolve merge conflicts, open the conflicted files in a text editor and manually resolve the conflicting sections. Remove the conflict markers (<<<<<<<, =======, >>>>>>>) and keep the changes you want to retain.
  4. Committing Changes: After resolving conflicts, stage the changes using git add . and commit the merge using git commit. Git will create a merge commit to finalize the merge process.

Working on a feature branch

Example diagram for a workflow with a feature branch

In this example we start with main and then create a new local branch and switch to it

Read more on Medium

Bitcoin Trading Bot Development on Discord Trading Signals and LN Markets

admin English

Bitcoin Trading Bot Development on Discord Trading Signals and LN Markets

 

Read on Medium

 

Photo by Alex Knight on Unsplash

Introduction

Discord has become a cornerstone platform for communication among gamers, communities, and teams worldwide. The extensibility of Discord through bots has unlocked a plethora of possibilities, enabling automation, moderation, and enhanced user experiences. In this guide, we’ll delve into Discord bot development, using LN Markets as trading platform.

Trading signals Discord channels and groups are online communities where traders come together to share valuable insights, trading signals, and analyses pertaining to the crypto market. These channels and groups are hosted on the Discord messaging platform, enabling seamless real-time communication and information exchange among members.

LN Markets is a platform that enables users to trade Bitcoin futures contracts using the Lightning Network, a second-layer solution for faster and cheaper Bitcoin transactions. LN Markets leverages the Lightning Network’s micro-payment capabilities to provide instant settlement and low transaction fees for trading activities.

Overall, LN Markets provides a unique trading experience for Bitcoin enthusiasts and traders looking to participate in the cryptocurrency markets using the Lightning Network’s innovative technology.

Getting Started with Discord Bot Development

  • Understanding Discord Bots: Bots are automated agents that can perform various tasks on Discord servers, ranging from moderation to information retrieval.
  • Setting Up Your Development Environment: Install Node.js and Discord.js library to begin building your bot.
  • Creating Your First Bot: Let’s create a simple bot that responds to commands and interacts with users.
// Import necessary modules
const Discord = require('discord.js');
const client = new Discord.Client();

// Define bot behavior
client.on('message', message => {
    if (message.content === '!hello') {
        message.reply('Hello, world!');
    }
});

// Log in to Discord with your bot token
client.login('YOUR_DISCORD_BOT_TOKEN');

Essential Bot Features and Functionality

  • Message Handling: Read and respond to messages from users, including commands and regular chat.
  • User Interaction: Engage with users through reactions, mentions, and interactive commands.
  • Server Management: Join servers, manage channels, and handle server events like member joins or leaves.
  • Role Management: Assign roles, manage permissions, and enforce server rules.

Here we will just focus on reading the last message from the trading channel

// Register event for when client receives a message.
client.on('message', message => {
console.log(message.content);
processSignal(message);
});

Parsing the text and trading on LN Markets

We need to install the ln-markets api for our project via this command:

 npm install @ln-markets/api

The next code snippet will open a connection to the LN Markets API.

import { createRestClient } from '@ln-markets/api';

const key = config.lnmarketsKey.trim();
const secret = config.lnmarketsSecret.trim();
const passphrase = config.lnmarketsPassphrase.trim();
const network = 'testnet';
const lnclient = createRestClient({ key, secret, passphrase });

Now we parse the text from the Discord message and trade accordingly. In this example the signal didn’t come in plain text, but it used some rich text features from Discord (message.embeds), so these fields had to be parsed and not only the message.text field.

async function processSignal(message) {
  if (message.embeds.length > 0 && message.embeds[0].title.includes('Buy Signal!')) {
    // Extract trade information
    let entryPrice = null;
    let stopLoss = null;
    let takeProfit = null;

    // Split message content by lines
    const createdTimestamp = message.createdTimestamp;
    const lines = message.embeds[0].fields;
    lines.forEach((line, index) => {
      if (line.name.includes('Entry Price')) {
        const priceLine = line.value.replace(/`/g, '');
        entryPrice = parseFloat(priceLine);
      } else if (line.name.includes('Stop Loss')) {
        const priceLine = line.value.replace(/`/g, '');
        stopLoss = Math.round(parseFloat(priceLine)) + 0.5;
      } else if (!line.value.includes('There will be a separate signal to take profit') && line.name.includes('Take Profit')) {
        const priceLine = line.value.replace(/`/g, '');
        takeProfit = Math.round(parseFloat(priceLine)) + 0.5;
      } else if (line.value.includes('There will be a separate signal to take profit that could be higher than this price.')) {
        const regex = /```(\d+(\.\d+)?)```/;
        // Extract the numeric value using the match method and regular expression
        const match = line.value.match(regex);
        if (match) {
          // Extract the numeric value from the matched string
          const priceLine = parseFloat(match[1]);
          takeProfit = Math.round(parseFloat(priceLine)) + 0.5;
        }
      }
    });

    if (entryPrice !== null && stopLoss !== null) {
      console.log(`Entry Price: ${entryPrice}`);
      console.log(`Stop Loss: ${stopLoss}`);
      if (takeProfit !== null) {
        console.log(`Take Profit: ${takeProfit}`);
      }

      await getBuyTrade(createdTimestamp, takeProfit, stopLoss, entryPrice);
    }
  } else if (message.embeds.length > 0 && message.embeds[0].title.includes('Sell Signal!')) {
    let sellPrice = null;

    const createdTimestamp = message.createdTimestamp;
    const lines = message.embeds[0].fields;
    lines.forEach((line, index) => {
      if (line.value.includes('position has been closed at:')) {
        const regex = /```(\d+(\.\d+)?)```/;
        // Extract the numeric value using the match method and regular expression
        const match = line.value.match(regex);
        if (match) {
          // Extract the numeric value from the matched string
          const priceLine = parseFloat(match[1]);
          sellPrice = parseFloat(priceLine);
        }
      }
    });

    if (sellPrice !== null) {
      console.log(`Sell Price: ${sellPrice}`);
      await getTradeByTimestamp(createdTimestamp, (err, rows) => {
        if (err) {
          console.error(err.message);
        } else {
          // Check if any rows were returned
          if (rows.length > 0) {
            // Assuming id is the first column in the result set
            const tradeId = rows[0].id;
            console.log('Trade ID in Sell:', tradeId);
          } else if (lastBuyTradeId != null) { // This is a new sell trade
            // Perform Sell Trade in LNMarkets
            const data = {
              id: lastBuyTradeId,
            };

            console.log(data);

            const trade = lnclient.futuresCloseTrade(lastBuyTradeId).then((response) => {
              saveToDatabase(response.id, createdTimestamp, 0.0, 0.0, sellPrice, response.pl, 'Sell');
            })
              .catch((err) => {
                // Handle error
                console.error(err.message);
              });

          }
        }
      });
    }
  }
}

async function getBuyTrade(createdTimestamp, takeProfit, stopLoss, entryPrice) {
  try {
      // Call getTradeByTimestamp and wait for it to complete
      const rows = await new Promise((resolve, reject) => {
          getTradeByTimestamp(createdTimestamp, (err, rows) => {
              if (err) {
                  reject(err);
              } else {
                  resolve(rows);
              }
          });
      });

      // Check if any rows were returned
      if (rows.length > 0) {
          const tradeId = rows[0].id;
          lastBuyTradeId = tradeId;
          console.log('Trade ID in Buy:', tradeId);
      } else {
          // Perform Trade in LNMarkets
          let data = {
              "type": 'm',
              "side": 'b',
              "leverage": LEVERAGE,
              "quantity": QUANTITY,
              "takeprofit": takeProfit,
              "stoploss": stopLoss
          };

          const trade = await lnclient.futuresNewTrade(data);
          saveToDatabase(trade.id, createdTimestamp, entryPrice, stopLoss, takeProfit, 0.0, 'Buy');
      }
  } catch (error) {
      console.error(error.message);
  }

In the previous code snippet, the function getBuyTrade uses getTradeByTimestamp, which queries a local sqlite database file to query if this trade was already done. The function saveToDatabase saves the trade to this database when the trade is new. This in order to execute each trade only once.

function saveToDatabase(lnMarketsId, createdTimestamp, entryPrice, stopLoss, takeProfit, profit, tradeType) {
  lastBuyTradeId = lnMarketsId;
  createTrade(lnMarketsId, createdTimestamp, entryPrice, stopLoss, takeProfit, profit, tradeType, err => {
    if (err) {
      console.error(err.message);
    } else {
      console.log(tradeType + " Trade created successfully!");
    }
  });
}

Finally we add some cleanup code for our database connection

// Clean up database connection when the application exits
process.on('exit', () => {
  closeConnection();
  console.log('Database connection closed');
});

// Handle Ctrl+C (SIGINT) signal
process.on('SIGINT', () => {
  closeConnection();
  console.log('Database connection closed');
  process.exit();
});

Conclusion

In this guide we saw an introduction on how to program a Bitcoin trading bot on LN Markets, based on trading signals sent to a specific Discord channel. By mastering the concepts and techniques outlined in this guide, you’ll be well-equipped to build bots that take signals on specific trading servers and automate your trading

References

 

https://discord.com/developers/docs/intro

https://docs.lnmarkets.com/api/

https://github.com/ln-markets/api-js/tree/master

 

Customization of ccGains for the generation of a yearly Crypto Report in jurisdictions where there is tax exemption for crypto holdings held for one year or more

admin English

Customization of ccGains for the generation of a yearly Crypto Report in jurisdictions where there is tax exemption for crypto holdings held for one year or more

Für Deutsch hier

Read on Medium

Image by fabrikasimf on Freepik

Introduction

In the dynamic world of cryptocurrency, where volatility and innovation intersect, the regulatory landscape is continuously evolving. One notable aspect of this evolution is the taxation of cryptocurrency gains. While many countries have implemented various tax regimes for cryptocurrencies, some offer favorable policies that exempt long-term holders from certain tax liabilities. One such policy gaining traction in several jurisdictions is the tax exemption for crypto holdings held for one year or more.

What is the One-Year Holding Policy?

The one-year holding policy, also known as long-term capital gains treatment, is a taxation framework that grants exemptions or reduced tax rates on profits generated from the sale or exchange of cryptocurrencies held for a minimum duration of one year. This policy aims to incentivize long-term investment in cryptocurrencies while encouraging stability in the market.

Countries with Tax-Free Crypto Gains Policy

Several countries have embraced the concept of tax-free crypto gains for long-term holders. Some of these nations include:

  1. Germany: Germany has emerged as one of the frontrunners in providing clarity on cryptocurrency taxation. In Germany, if you hold your cryptocurrencies for more than one year, any resulting gains are completely tax-free.
  2. Portugal: Portugal has gained attention for its tax-friendly policies towards cryptocurrencies. The country does not tax individuals on capital gains from the sale of cryptocurrencies if they have been held for more than one year.
  3. Singapore: Singapore is renowned for its pro-business environment and has adopted a similar approach to cryptocurrencies. Capital gains from long-term cryptocurrency holdings are not taxed in Singapore, provided certain conditions are met.
  4. Belarus: Belarus has implemented legislation that exempts individuals and businesses from taxes on cryptocurrency transactions, including capital gains, until 2023. This policy aims to attract investment and innovation in the country’s emerging tech sector.
  5. Switzerland: Switzerland, known for its favorable regulatory environment for finance and technology, treats cryptocurrencies as assets rather than currencies for tax purposes. Consequently, capital gains from long-term cryptocurrency holdings are typically tax-free for individuals.

What is ccGains?

The ccGains (cryptocurrency gains) package provides a python library for calculating capital gains made by trading cryptocurrencies or foreign currencies. It was created by Jürgen Probst and it is hosted in Github (link here). Some of its features are:

  • Calculates the capital gains using the first-in/first out (FIFO) principle, • creates capital gains reports as CSV, HTML or PDF (instantly ready to print out for the tax office),
  • Can create a more detailed capital gains report outlining the calculation and used bags,
  • Differs between short and long term gains (amounts held for less or more than a year),
  • Treats amounts held and traded on different exchanges separately,
  • Treats exchange fees and transaction fees directly resulting from trading properly as losses,
  • Provides methods to import your trading history from various exchanges,
  • Loads historic cryptocurrency prices from CSV files and/or
  • Loads historic prices from APIs provided by exchanges,
  • Caches historic price data on disk for quicker and offline retrieval and less traffic to exchanges,
  • For highest accuracy, uses the decimal data type for all amounts
  • Supports saving and loading the state of your portfolio as JSON file for use in ccGains calculations in following years

Installation

You’ll need Python (ccGains is tested under Python 2.7 and Python 3.x). Get it here: https://www.python.org/

ccGains can then easily be installed via the Python package manager pip:

  • Download the source code, e.g. by git clone https://github.com/probstj/ccgains.git
  • Inside the main ccGains directory run: pip install . (note the . at the end)
  • Alternatively, to install locally without admin rights: pip install --user .
  • And if you want to add changes to the source code and quickly want to try it without reinstalling, pip can install by linking to the source code folder: pip install -e .

Usage

Please have a look at examples/example.py and follow the comments to adapt it for your purposes.

Copy it to a new file for example taxReport2023.py.

1. Provide list of BTC historical prices in your native fiat currency

Hourly data for a lot of exchanges is available for download at:
https://api.bitcoincharts.com/v1/csv/
To understand which file to download, consult this list:
https://bitcoincharts.com/markets/list/

For EUR prices on Kraken, download: https://api.bitcoincharts.com/v1/csv/krakenEUR.csv.gz and place it in the ../data folder.

For CHF prices, download: https://api.bitcoincharts.com/v1/csv/anxhkCHF.csv.gz

For SGD prices, download: https://api.bitcoincharts.com/v1/csv/anxhkSGD.csv.gz

The file consists of three comma-separated columns: the unix timestamp, the price, and the volume (amount traded).

Create the HistoricData object by loading the mentioned file and
specifying the price unit, i.e. fiat/btc:

h1 = ccgains.HistoricDataCSV(
 '../data/bitcoin_de_EUR_abridged_as_example.csv.gz', 'EUR/BTC')

2. Provide source of historical BTC prices for all traded alt coins

For all coins that you possessed at some point, their historical price in your native fiat currency must be known, which can also be derived from their BTC price and the BTC/fiat price given above (or even from their price in any other alt-coin, whose price can be derived, in turn.)

This data can be provided from any website that serves this data through an API, or from a csv-file, like above. Note that currently, only the API from Poloniex.com is implemented.

Create HistoricData objects to fetch rates from Poloniex.com: (it is important to mention at least all traded coins here)

    h2 = ccgains.HistoricDataAPI('data', 'btc/xmr')
    h3 = ccgains.HistoricDataAPI('data', 'btc/eth')
    h4 = ccgains.HistoricDataAPI('data', 'btc/usdt')
    h5 = ccgains.HistoricDataAPI('data', 'btc/link')
    h6 = ccgains.HistoricDataAPI('data', 'btc/bat')
    h7 = ccgains.HistoricDataAPI('data', 'btc/zrx')
    h8 = ccgains.HistoricDataAPI('data', 'btc/cvc')
    h9 = ccgains.HistoricDataAPI('data', 'btc/dash')
    h10 = ccgains.HistoricDataAPI('data', 'btc/knc')
    h11 = ccgains.HistoricDataAPI('data', 'btc/mkr')
    h12 = ccgains.HistoricDataAPI('data', 'btc/matic')
    h13 = ccgains.HistoricDataAPI('data', 'btc/doge')
    h14 = ccgains.HistoricDataAPI('data', 'btc/bch')
    h15 = ccgains.HistoricDataAPI('data', 'btc/dot')
    h16 = ccgains.HistoricDataAPI('data', 'btc/qtum')
    h17 = ccgains.HistoricDataAPI('data', 'btc/ren')
    h18 = ccgains.HistoricDataAPI('data', 'btc/str')
    h19 = ccgains.HistoricDataAPI('data', 'btc/xtz')
    h20 = ccgains.HistoricDataAPI('data', 'btc/trx')
    h21 = ccgains.HistoricDataAPI('data', 'btc/zec')
    h22 = ccgains.HistoricDataAPI('data', 'btc/ltc')
    h23 = ccgains.HistoricDataAPI('data', 'btc/xrp')
    h24 = ccgains.HistoricDataAPI('data', 'btc/omg')
    h25 = ccgains.HistoricDataAPI('data', 'btc/etc')
    h26 = ccgains.HistoricDataAPI('data', 'btc/dot')
    h27 = ccgains.HistoricDataAPI('data', 'btc/dai')
    h28 = ccgains.HistoricDataAPI('data', 'btc/usdc')
    h29 = ccgains.HistoricDataAPICoinbase('data', 'cro/eur')
    h30 = ccgains.HistoricDataAPIBinance('data', 'btc/uni')
    h31 = ccgains.HistoricDataAPIBinance('data', 'avax/eur')
    h32 = ccgains.HistoricDataAPIBinance('data', 'btc/dydx')
    h33 = ccgains.HistoricDataAPIBinance('data', 'btc/iota')
    h34 = ccgains.HistoricDataAPIBinance('data', 'btc/axs')

In h2 to h28 I used the class HistoricDataAPI which uses the public Poloniex API: https://poloniex.com/public?command=returnTradeHistory, since this is the exchange that has these pairs traded in the year 2023 in this example.

In h29 I used the class HistoricDataAPICoinbase which uses the public Coinbase API: ‘https://api.pro.coinbase.com/products/:SYMBOL:/candles’.

In h30 to h34 I used the class HistoricDataAPIBinance which will transparently fetch data on request (get_price) from the public Binance API: https://api.binance.com/api/v1/klines

For faster loading times on future calls, a HDF5 file is created from the requested data and used transparently the next time a request for the same day and pair is made. These HDF5 files are saved in cache_folder. The unit must be a string in the form ‘currency_one/currency_two’, e.g. ‘NEO/BTC’. The data will be resampled by calculating the weighted price for interval steps specified by interval. See: http://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases for possible values.

prepare_request(dtime) Return a pandas DataFrame which contains the data for the requested datetime dtime.

3. Add all objects from above into a single ‘CurrencyRelation’ object

Create a CurrencyRelation object that puts all provided HistoricData currencies in relation in order to serve exchange rates for any pair of these currencies:

rel = ccgains.CurrencyRelation(h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11, h12, h13, h14, h15, h16, h17, h18, h19, h20, h21, h22, h23, h24, h25, h26,h27, h28, h29, h30, h31, h32, h33, h34)

4. Create the ‘BagQueue’, which calculates the capital gains

Create the BagQueue object that calculates taxable profit from trades using the first-in/first-out method:

(this needs to know your native fiat currency and the CurrencyRelation created above)

bf = ccgains.BagQueue('EUR', rel)

5. Create the object that will load all your trades

The TradeHistory object provides methods to load your trades from csv-files exported from various exchanges or apps.

 th = ccgains.TradeHistory()

6. Load all your trades from csv-files

Export your trades from exchanges or apps as comma-separated files and append them to the list of trades managed by the TradeHistory object. All trades will be sorted automatically.

To load from a supported exchange, use the methods named `append_<exchange_name>_csv` found in TradeHistory (see trades.py).

    th.append_poloniex_csv(
            './data/2020/poloniex_depositHistory_2023.csv',
            'deposits')
    th.append_poloniex_csv(
            './data/2020/poloniex_tradeHistory_2023.csv',
            'trades',
            condense_trades=True)
    th.append_poloniex_csv(
            './data/2020/poloniex_withdrawalHistory_2023.csv',
            'withdr')

    th.append_binance_csv(
            './data/2020/binance_depositHistory_2023.csv',
            'deposits')
    th.append_binance_csv(
            './data/2020/binance_tradeHistory_2023.csv',
            'deposits')
    th.append_binance_csv(
            './data/2020/binance_withdrawalHistory_2023.csv',
            'deposits')
    th.append_wirex_csv(
            './data/2020/wirex_btc_tradeHistory_2023.csv',
            'trades')
    th.append_cro_csv(
            './data/2021/cro_tradeHistory_2023.csv',
            'trades')

If your exchange is not supported yet, add a new method in trades.py. In this example the methods append_wirex_csv and append_cro_csv are not supported in the original GitHub project.

Next I will show how I did it with append_cro_csv (Crypto.com). First import TPLOC_CRO_TRADES, which is the library that knows how to read the CSV file from the Crypto.com exchange.

from .cro_util import (
    TPLOC_CRO_TRADES)
 def append_cro_csv(
            self, file_name, which_data='trades', delimiter=',',
            skiprows=1,  default_timezone=tz.tzutc()):
       
        wdata = which_data[:5].lower()
        if wdata not in ['trade']:
            raise ValueError(
                '`which_data` must be one of "trades"')
        
        plocs = TPLOC_CRO_TRADES
        self.append_csv(
            file_name=file_name,
            param_locs=plocs,
            delimiter=delimiter,
            skiprows=skiprows,
            default_timezone=default_timezone
        )

Now create the cro_util.py file

from decimal import Decimal

def kind_for(csv_line):
    if 'Withdraw' in (csv_line[1].strip('" \n\t')) or ('Transfer' in (csv_line[1].strip('" \n\t')) and 'App' in csv_line[1].strip('" \n\t').split("->")[0]):
         return 'Withdrawal'
    elif 'Deposit' in (csv_line[1].strip('" \n\t')) or 'Reward' in (csv_line[1].strip('" \n\t')) or ('Transfer' in (csv_line[1].strip('" \n\t')) and 'Exchange' in csv_line[1].strip('" \n\t').split("->")[0]):
        return 'Deposit'
    elif 'Buy' in (csv_line[1].strip('" \n\t')):
        return 'Buy'
    elif '->' in csv_line[1].strip('" \n\t'):
        return 'Sell'    
    else:
        return None

def get_buy_currency(csv_line):
    if not '->' in csv_line[1].strip('" \n\t') and (kind_for(csv_line) == 'Buy' or kind_for(csv_line) == 'Deposit' or 'App' in csv_line[1].strip('" \n\t').split("->")[0]):
        return csv_line[2].strip('" \n\t')
    elif '->' in csv_line[1].strip('" \n\t') and (kind_for(csv_line) == 'Buy' or kind_for(csv_line) == 'Deposit' or 'App' in csv_line[1].strip('" \n\t').split("->")[0]):
        return csv_line[2].strip('" \n\t')
    else:
        return csv_line[1].strip('" \n\t').split("->")[1]

def get_sell_currency(csv_line):
    if not '->' in csv_line[1].strip('" \n\t') and (kind_for(csv_line) == 'Sell' or kind_for(csv_line) == 'Withdrawal' or 'Exchange' in csv_line[1].strip('" \n\t').split("->")[0]):
        return csv_line[2].strip('" \n\t')
    elif '->' in csv_line[1].strip('" \n\t') and (kind_for(csv_line) == 'Sell' or kind_for(csv_line) == 'Withdrawal' or 'Exchange' in csv_line[1].strip('" \n\t').split("->")[0]): 
        return csv_line[2].strip('" \n\t')
    else:
        return csv_line[1].strip('" \n\t').split("->")[0]

#Trade parameters in csv from Crypto.com
TPLOC_CRO_TRADES = {
    'kind': lambda cols: kind_for(cols),
    'dtime': 0,
    'buy_currency': lambda cols: get_buy_currency(cols) if kind_for(cols) == 'Buy' or kind_for(cols) == 'Deposit' else cols[4] if cols[4].strip('" \n\t') != '' else '', 
    'buy_amount': lambda cols: abs(Decimal(cols[3])) if kind_for(cols) == 'Buy' or kind_for(cols) == 'Deposit' else abs(Decimal(cols[5])) if cols[5].strip('" \n\t') != '' else '',
    'sell_currency': lambda cols: get_sell_currency(cols) if kind_for(cols) == 'Sell' or kind_for(cols) == 'Withdrawal' else 'EUR', 
    'sell_amount': lambda cols: abs(Decimal(cols[3])) if kind_for(cols) == 'Sell' or kind_for(cols) == 'Withdrawal' else cols[7], 
    'fee_currency': -1,
    'fee_amount': -1,
    'exchange': 'Crypto.com', 'mark': -1, 
    'comment': lambda cols: cols[1]
}

7. Optionally, fix withdrawal fees

Some exchanges, like Poloniex, does not include withdrawal fees in their exported csv files. This will try to add these missing fees by comparing withdrawn amounts with amounts deposited on other exchanges shortly after withdrawal. Call this only after all transactions from every involved exchange and wallet were imported.

This uses a really simple algorithm, so it is not guaranteed to work in every case, especially if you made withdrawals in tight succession on different exchanges, so please check the output.

th.add_missing_transaction_fees(raise_on_error=False)

8. Optionally, rename currencies

Some currencies have changed ticker symbols since their first listing date (e.g., AntShares (ANS) -> Neo (NEO)). This can lead to situations where all historical pricing data lists the new ticker symbol, but transaction history still lists the old ticker.

This method allows for renaming symbols in the TradeHistory, if any occurrences of the old name/ticker are found.

th.update_ticker_names({'ANS': 'NEO'})

9. Optionally, export all trades for future reference

You can export all imported trades for future reference into a single file, optionally filtered by year.

…either as a comma-separated text file (can be imported into ccgains):

th.export_to_csv('transactions2023.csv', year=2023)

…or as html or pdf file, with the possibility to filter or rename column headers or contents:
(This is an example for a translation into German)

 my_column_names=[
        'Art', 'Datum', 'Kaufmenge', 'Verkaufsmenge', u'Gebühren', u'Börse']
    transdct = {'Buy': 'Anschaffung',
                'BUY': 'Anschaffung',
                'Sell': 'Tausch',
                'SELL': 'Tausch',
                'Purchase': 'Anschaffung',
                'Exchange': 'Tausch', 'Disbursement': 'Abhebung',
                'Deposit': 'Einzahlung', 
                'Withdrawal': 'Abhebung',
                'Received funds': 'Einzahlung',
                'Withdrawn from wallet': 'Abhebung',
                'Create offer fee: a5ed7482': u'Börsengebühr',
                'Buy BTC' : 'Anschaffung',
                'MultiSig deposit: a5ed7482': 'Abhebung',
                'MultiSig payout: a5ed7482' : 'Einzahlung'}
    th.export_to_pdf('Transactions2021.pdf',
          year=2021, drop_columns=['mark', 'comment'],
          font_size=12,
          caption=u"Handel mit digitalen Währungen %(year)s",
          intro=u"<h4>Auflistung aller Transaktionen zwischen "
                 "%(fromdate)s und %(todate)s:</h4>",
          locale="de_DE",
          custom_column_names=my_column_names,
          custom_formatters={
              'Art': lambda x: transdct[x] if x in transdct else x})

10. Now, finally, the calculation is ready to start

If the calculation run for previous years already, we can load the state of the bags here, no need to calculate everything again:

bf.load('./status2022.json')

Or, if the current calculation crashed (e.g. you forgot to add a traded currency in #2 above), the file ‘precrash.json’ will be created automatically. Load it here to continue:

bf.load('./precrash.json')

The following just looks where to start calculating trades, in case you already calculated some and restarted by loading ‘precrash.json’:

last_trade = 0
    while (last_trade < len(th.tlist)
           and th[last_trade].dtime <= bf._last_date):
        last_trade += 1
    if last_trade > 0:
        logger.info("continuing with trade #%i" % (last_trade + 1))

    # Now, the calculation. This goes through your imported list of trades:
    for i, trade in enumerate(th.tlist[last_trade:]):
        # Most of this is just the log output to the console and to the
        # file 'ccgains_<date-time>.log'
        # (check out this file for all gory calculation details!):
        logger.info('TRADE #%i', i + last_trade + 1)
        logger.info(trade)
        # This is the important part:
        bf.process_trade(trade)
        # more logging:
        log_bags(bf)
        logger.info("Totals: %s", str(bf.totals))
        logger.info("Gains (in %s): %s\n" % (bf.currency, str(bf.profit)))

11. Save the state of your holdings for the calculation due next year

bf.save('status2023.json')

12. Create your capital gains report for cryptocurrency trades

The default column names used in the report don’t look very nice: [‘kind’, ‘bag_spent’, ‘currency’, ‘bag_date’, ‘sell_date’, ‘exchange’, ‘short_term’, ‘spent_cost’, ‘proceeds’, ‘profit’], so we rename them:

my_column_names=[
'Type', 'Amount spent', u'Currency', 'Purchase date',
 'Sell date', u'Exchange', u'Short term', 'Purchase cost',
'Proceeds', 'Profit']

Here we create the report pdf for capital gains in 2023.

The date_precision=’D’ means we only mention the day of the trade, not the precise time. We also set combine=True, so multiple trades made on the same day and on the same exchange are combined into a single trade on the report:

 my_column_names=[
        'Art', 'Verkaufsmenge', u'Währung', 'Erwerbsdatum',
        'Verkaufsdatum', u'Börse', u'in\xa0Besitz',
        'Anschaffungskosten', u'Verkaufserlös', 'Gewinn']
    transdct = {'sale': u'Veräußerung',
                'withdrawal fee': u'Börsengebühr',
                'deposit fee': u'Börsengebühr',
                'exchange fee': u'Börsengebühr'}
    convert_short_term=[u'>\xa01\xa0Jahr', u'<\xa01\xa0Jahr']

    bf.report.export_report_to_pdf(
        'Report2021_de.pdf', year=2023,
        date_precision='D', combine=True,
        custom_column_names=my_column_names,
        custom_formatters={
            u'in\xa0Besitz': lambda b: convert_short_term[b],
            'Art': lambda x: transdct[x]},
        locale="de_DE",
        template_file='shortreport_de.html'
    )
    # If you rather want your report in a spreadsheet, you can export
    # to csv:
    bf.report.export_short_report_to_csv(
            'report_2023.csv', year=2023,
        date_precision='D', combine=False,
        convert_timezone=True, strip_timezone=True)

13. Optional: Create a detailed report outlining the calculation

The simple capital gains report created above is just a plain listing of all trades and the gains made, enough for the tax report.

A more detailed listing outlining the calculation is also available:

bf.report.export_extended_report_to_pdf(
        'Details_2023.pdf', year=2023,
        date_precision='S', combine=False,
        font_size=10, locale="en_US")

And again, let’s translate this report to German: (Using transdct from above again to translate the payment kind)

    bf.report.export_extended_report_to_pdf(
        'Details_2023_de.pdf', year=2023,
        date_precision='S', combine=False,
        font_size=10, locale="de_DE",
        template_file='fullreport_de.html',
        payment_kind_translation=transdct)

Now run

python taxReport2023.py

This should generate the pdf files Details_2023.pdf and Details_2023_de.pdf, which are the reports needed by the tax authorities.

For more information on crypto tax report generation or customization to your needs, contact us at lnsolutions.ee

References

GitHub - probstj/ccGains: Python package for calculating cryptocurrency trading profits and…

Python package for calculating cryptocurrency trading profits and creating capital gains reports - probstj/ccGains

github.com

https://readthedocs.org/projects/ccgains/downloads/pdf/latest/
 
  1. How to Install and Automatically Run a Node.js App with Systemd
  2. Sending Emails via AWS SES in Linux: A Step-by-Step Guide
  3. Resume Jorge Elizondo
  4. Building a Secure Spring Boot Application with Kotlin

Page 1 of 2

recent posts
  • Talinn, Estonia
  • support@lnsolutions.ee
About
We support your software projects and solutions. We specialize in Java Backend, Web development, BPM Workflow design and Bitcoin payment solutions.
Subscribe