Kiln Connect offers a unified interface to craft, sign and broadcast transactions for all supported protocols so that your engineering team does not have to deal with protocols specifics and focuses on integration and user experience.

Kiln Connect provides support 18 protocols please find the breakdown bellow.

It also enables you to retrieve staking rewards data on all validators (not just Kiln Validators) without having to run infrastructure yourself.

Protocol breakdown (18 supported)

• All of the following protocols offer support for :

  • • Except for MultiverseX (EGLD)

  • • Scope explains for which validator range reporting data is available

    • Search by explains how to query the Reporting API

    • Timeframes explains how granular the data is historically

    • History explains how far in the past data is available

Product Demo

It is currently available via a SDK available in TypeScript/JavaScript and Python. For more language support, feel free to contact our Support.

Kiln's JS SDK allow you to:

• Craft, sign and broadcast staking transactions using Fireblocks as a custody solution

• Get staking data about your stakes and their rewards

• Get network wide data

• Manage your Kiln accounts

Supported languages and protocols:

JS SDK:

https://github.com/kilnfi/sdk-js

https://www.npmjs.com/package/@kilnfi/sdk

All Kiln Connect protocols are supported in the SDK.

Find Kiln Connect documentation here:

https://docs.api.kiln.fi/docs/quickstart

1. Download Postman

Postman is a GUI you can use to run some API call examples and visualise the returned data.

You can use the community desktop version or the web version of Postman to import the demo.

2. Download the postman collection

1. In postman, select the Collections tab on the left menu

2. Press the import button and import the following collection:

https://api.postman.com/collections/25416551-d3d9299b-394e-4729-b042-506837f57154?access_key=PMAT-01H5GA3E52K8PSCAG4KKSMPDTK

3. Setup a testnet environment

1. Go to the Environments tab on the left menu and create a new TESTNET environment

2. Add a host variable with https://api.testnet.kiln.fi as INITIAL VALUE

3. Add a api_token variable with your Kiln API token (you can fetch it on the Applications section of your Kiln dashboard) as INITIAL VALUE

4. Go back to the Collections tab, select TESTNET on the top right menu

5. You are now setup to run API queries!

To integrate reporting in your platform or to stake programmatically, you need to generate an API Key for your team.

Prerequisites

• You need at least one user onboarded in your Organization on Kiln's Dashboard

  • If you don't yet have access please contact our support team.

Generating an API Key by creating a new application

Start by navigating to Kiln's Dashboard: https://dashboard.kiln.fi

Please note if you need API access for the test network, you will need to have access to the testnet version of this dashboard, contact our support team for more information.

Step 1. Click on "Applications" in the navigation sidebar to start managing your API keys

Step 2. Then click on "Create application" to initiate the API Key creation flow

Step 3. Create a new application by setting a name for your API Key so you can identify it later in the list, you can also add a description, like "for testing purposes" so another team member can know who is using this key.

After clicking "Create application" your API Key will be generated and displayed only once, make sure you copy it and securely share it internally ⚠️

Manage existing API Access

Hover one row of the table to see the quick action buttons on the right side of the line.

• In the case you need to rotate your API Key credentials, you can keep the same application name and credentials but regenerate the access token.

  • After clicking "Regenerate Token" your API Key will be generated and displayed only once, make sure you copy it and securely share it internally ⚠️

• Click on "Update" to modify the API Key name or description.

• You can revoke it from the dashboard by clicking on the "Delete" button after hovering on the specific line.

When staking on different protocols, you will need to find Kiln's validator addresses if you choose to stake with Kiln.

Addresses on all protocols can be found in this section

Solana memo instruction

A Solana transaction is composed of multiple instructions, executed one after the other. Here is an example of instructions you can define with the standard Solana @solana/web3.js package.

const memoProgram = 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr';
const memo = 'hello, world!';

const instructions = [
  // 1 - add memo to transaction
  new TransactionInstruction({
    keys: [
      {
        pubkey: staker,
        isSigner: true,
        isWritable: true,
      },
    ],
    programId: new PublicKey(memoProgram),
    data: Buffer.from(memo),
  }),
  // 2 - create stake account
  SystemProgram.createAccount({
    /** The account that will transfer lamports to the created account */
    fromPubkey: publicKey,
    /** Public key of the created account. Must be pre-calculated with PublicKey.createWithSeed() */
    newAccountPubkey: stakeKey.publicKey,
    /** Amount of lamports to transfer to the created account */
    lamports: solToLamports(parsedStakeAmount),
    /** Amount of space in bytes to allocate to the created account */
    space: 200,
    /** Public key of the program to assign as the owner of the created account */
    programId,
  }),
  // 3 - init stake account
  StakeProgram.initialize({
    stakePubkey: stakeKey.publicKey,
    authorized: {
       /** stake authority */
       staker: publicKey,
       /** withdraw authority */
       withdrawer: publicKey,
     },
     lockup: {
       /** Unix timestamp of lockup expiration */
       unixTimestamp: 0,
       /** Epoch of lockup expiration */
       epoch: 0,
       /** Lockup custodian authority */
        custodian: new PublicKey('11111111111111111111111111111111'),
      },
    }),
    // 4 - delegate stake account
    StakeProgram.delegate({
      stakePubkey: stakeKey.publicKey,
      authorizedPubkey: publicKey,
      votePubkey: new PublicKey(SOL_VOTE_ACCOUNT_ADDRESS),
    }),
];

tx.add(...instructions);

This transaction will be taggued with the hello, world! memo and will create, initialize and delegate a stake account.

What value should we use for the memo?

Kiln gives to each partner a fix value to include as memo in all the transactions they craft with the following format: kiln_{uuidv4}.

v3 changelog

Here is the high level changelog of the v3:

• The Kiln class now exposes a type safe HTTP client that exposes all Kiln Connect endpoints available. The client is generated from our OpenAPI specs. The OpenAPI typescript schema is also exposed so you can benefit from all type definitions. The schema and SDK will be updated frequently with newly added endpoints.

• The fireblocks raw signing feature is now under the fireblocks service exposed by the Kiln class. A sign method is available for all protocols we support.

Upgrade from 2.X to 3.X

Update your dependencies:

bun i @kilnfi/sdk@latest

Update calls to use the http client instead of specific protocol object.

2.X:

const k = new Kiln({
  testnet: true,
  apiToken: 'kiln_xxx',
});

const vault: Integration = {
  provider: 'fireblocks',
  fireblocksApiKey: 'YOUR_API_USER_KEY', // your fireblocks API user key
  fireblocksSecretKey: apiSecret, // your fireblocks private key (generated with your CSR file and your API user)
  vaultId: 7 // your fireblocks vault id
};

...
const tx = await k.near.craftStakeTx(
      'account_id',
      'wallet',
      'pool_id',
      0.1,
    );
const txSigned = await k.near.sign(vault, tx);

3.X:

const k = new Kiln({
  baseUrl: 'https://api.testnet.kiln.fi',
  apiToken: 'kiln_xxx',
});

const vault: Integration = {
  provider: 'fireblocks',
  fireblocksApiKey: 'YOUR_API_USER_KEY', // your fireblocks API user key
  fireblocksSecretKey: apiSecret, // your fireblocks private key (generated with your CSR file and your API user)
  vaultId: 7 // your fireblocks vault id
};

const tx = await k.client.POST(
      '/v1/near/transaction/stake',
      {
        body: {
          account_id: 'account_id',
          wallet: 'wallet',
          pool_id: 'pool_id',
          amount_yocto: '1000000000000000000000000',
        }
      }
    );

const signResponse = await k.fireblocks.signNearTx(vault, tx.data.data, "NEAR_TEST");

const broadcastedTx = await k.client.POST("/v1/near/transaction/broadcast", {
      body: {
        signed_tx_serialized: signResponse.signed_tx.data.signed_tx_serialized,
      }
    });

Rewards earned on DYDX are DYDX-USDC. In this tutorial we will present how to bridge these rewards to Ethereum or to Osmosis using the Kiln SDK. These flows can be done directly from Kiln Dashboard if you are using Fireblocks.

Bridge to Ethereum

The goal of this bridge is to bring your dYdX rewards in USDC on your ETH address so that you can use them for other purposes like depositing them on a centralized exchange to get some dYdX back.

To convert your DYDX-USDC to USDC on Ethereum, we will use the Noble bridge developed by Circle, which is the recommended on-chain approach.

There is 3 steps to this flow:

1) Transfer the USDC from DYDX to the Noble chain

2) Burn the USDC on Noble

3) Mint the USDC on Ethereum

Here is a TypeScript code snippet that you can use:

import { Kiln } from "@kilnfi/sdk";
import axios from 'axios';

const f = async () => {
  const k = new Kiln({
    baseUrl: 'https://api.kiln.fi',
    apiToken: 'YOUR_KILN_API_TOKEN',
  });

  /**
   * Send dydx-usdc rewards to noble
   */
  // Craft IBC transfer transaction
  const transferTx = await k.client.POST(
    '/v1/dydx/transaction/noble-ibc-transfer',
    {
      body: {
        pubkey: '02d92b48d3e9ef34f2016eac7857a02768c88e30aea7a2366bc5ba032a22eceb8b',
        amount_uusdc: '1000000',
      }
    }
  );
  // Sign the transaction with Fireblocks or your custody solution
  const signResponse = await k.fireblocks.signDydxTx(vault, tx.data.data);
  // Broadcast the transaction on DYDX
  const broadcastedTx = await k.client.POST("/v1/dydx/transaction/broadcast", {
    body: {
      tx_serialized: signResponse.signed_tx.data.tx_serialized,
    }
  });


  /**
   * Burn the usdc on noble for eth address recipient
   */
  // Craft burn transaction
  const txburn = await k.client.POST(
    '/v1/noble/transaction/burn-usdc',
    {
      body: {
        pubkey: '02d92b48d3e9ef34f2016eac7857a02768c88e30aea7a2366bc5ba032a22eceb8b',
        amount_usdc: '1000000',
        recipient: '0xBC86717BaD3F8CcF86d2882a6bC351C94580A994',
      }
    }
  );
  // Sign the transaction with Fireblocks or your custody solution
  const signResponseBurn = await k.fireblocks.signDydxTx(vault, txburn.data.data);
  // Broadcast the transaction on Noble
  const broadcastedTxBurn = await k.client.POST("/v1/noble/transaction/broadcast", {
    body: {
      tx_serialized: signResponseBurn.signed_tx.data.tx_serialized,
    }
  });

  /**
   * Mint the USDC on Ethereum to the recipient
   */

  // Fetch the attestation from circle's API (https://developers.circle.com/stablecoins/reference/getattestation)
  const { data: attestation } = await axios.get(`https://iris-api-sandbox.circle.com/v1/messages/4/${burnTxHash}`);

  // Craft the Ethereum mint transaction
  // todo: Kiln to add this part to the sdk
  const mintTx;
  // Sign and broadcast the transaction with Fireblocks on Ethereum
  const txHash = await k.fireblocks.signAndBroadcastEthTx(vault, mintTx);
};

f();

Bridge to Osmosis

The goal of this bridge is to bring your dYdX rewards in USDC on another cosmos address here on Osmosis so that you can use them for other purposes like depositing them on a centralized exchange or a Swap on Osmosis to get some dYdX back.

This flow follows two steps:

1) Transfer the DYDX-USDC to the Noble chain

2) Transfer the USDC on Noble to Osmosis

Here is a TypeScript code snippet that you can use:

import { Kiln } from "@kilnfi/sdk";
import axios from 'axios';

const f = async () => {
  const k = new Kiln({
    apiToken: 'YOUR_KILN_API_TOKEN',
  });

  /**
   * Send dydx-usdc rewards to noble
   */
  // Craft IBC transfer transaction
  const transferTx = await k.client.POST(
    '/v1/dydx/transaction/noble-ibc-transfer',
    {
      body: {
        pubkey: '02d92b48d3e9ef34f2016eac7857a02768c88e30aea7a2366bc5ba032a22eceb8b',
        amount_uusdc: '1000000',
      }
    }
  );
  // Sign the transaction with Fireblocks or your custody solution
  const signResponse = await k.fireblocks.signDydxTx(vault, tx.data.data);
  // Broadcast the transaction on DYDX
  const broadcastedTx = await k.client.POST("/v1/dydx/transaction/broadcast", {
    body: {
      tx_serialized: signResponse.signed_tx.data.tx_serialized,
    }
  });


  /**
   * Send usdc from noble to osmosis
   */
  // Craft IBC transfer transaction
  const tx = await k.client.POST(
      '/v1/noble/transaction/osmo-ibc-transfer',
      {
        body: {
          pubkey: '02d92b48d3e9ef34f2016eac7857a02768c88e30aea7a2366bc5ba032a22eceb8b',
          recipient: 'osmo1qz0jvz6v3v7z2zg3z2zg3z2zg3z2zg3z2zg3z2',
          amount_uusdc: '1000000',
        }
      }
    );
  // Sign the transaction with Fireblocks or your custody solution
  const signResponse = await k.fireblocks.signDydxTx(vault, tx.data.data);
  // Broadcast the transaction on Noble
  const broadcastedTx = await k.client.POST("/v1/noble/transaction/broadcast", {
    body: {
      tx_serialized: signResponse.signed_tx.data.tx_serialized,
    }
  });
};

f();

1. Install the SDK

The Kiln Connect SDK is only available in TS/JS for now, if you have other programming language requirements, please contact the .

2. Retrieve your Kiln API key

Create an application on your Kiln Dashboard, and retrieve the given API key.

The API key is used to authenticate with the Kiln REST API which can manage Kiln accounts, craft transactions, and provide reporting data.

3. Set up Fireblocks (required to sign transactions)

In the case that you would like to craft and sign transactions with your Fireblocks vault, you will need to setup the following in Fireblocks:

1. The raw signing feature is required on all protocols except on EVM compatible protocols (ETH, MATIC). Make sure that it is enabled in your workspace in case you wish to stake on other protocols. You can ask the Fireblocks support for information.

3. Generate the CSR certificate and make sure you store it somewhere safe.

4. Get the API key of the user by clicking on "Copy API key" of the user in the workspace members list

4. Configure the SDK

You can now configure the SDK with you Kiln API token.​