The GET shortcuts/route/nontokenized endpoint constructs an optimal conversion route. This API allows entering a non-tokenized DeFi position from any ERC20 or native token.

You must use delegate strategy when working with non-tokenized positions.

1

Authentication

  1. Create an API key using Enso Dashboard.
  2. Securely store your API key and make it available in your environment:
authentication.sh
ENSO_API_KEY="$ENSO_API_KEY"
echo $ENSO_API_KEY >> .env
git ignore .env
source .env
2

Understand non-tokenized positions

Unlike tokenized positions where you receive a token representing your position (like aTokens in Aave), non-tokenized positions are stored directly in a smart contract (usually a Smart Wallet). This endpoint is specifically designed for interacting with these types of positions.

Common examples include:

  • Borrowing on lending protocols
  • Creating CDPs (Collateralized Debt Positions)
  • Complex multi-step DeFi interactions

Note: This endpoint requires the use of a Smart Wallet or a delegatecall-compatible contract.

3

Create a routing transaction

Generate a transaction that routes your input token to a non-tokenized position:

import { EnsoClient } from '@ensofinance/sdk';

// Initialize client with your API key
const ensoClient = new EnsoClient({
  apiKey: process.env.ENSO_API_KEY!
});

// Create a transaction to borrow USDC from Aave using ETH as collateral
async function borrowFromAave() {
  try {
    // Smart wallet address to execute the transaction
    const fromAddress = "0xd8da6bf26964af9d7eed9e03e53415d37aa96045";
    
    // Define parameters for the non-tokenized route
    const routeParams = {
      chainId: 1,                                                  // Ethereum mainnet
      fromAddress: fromAddress,                                    // Smart wallet address
      routingStrategy: "delegate",                                 // Use delegate call
      tokenIn: ["0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"],     // ETH as input token
      positionOut: "0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2",   // Aave V3 lending pool
      amountIn: ["1000000000000000000"],                           // 1 ETH
      slippage: "300",                                             // 3% slippage
      receiver: fromAddress,                                       // Receiver of the position
      spender: fromAddress                                         // Spender of the input tokens
    };

    // Call the non-tokenized route endpoint
    const routeData = await fetch(
      `https://api.enso.finance/api/v1/shortcuts/route/nontokenized?` + 
      new URLSearchParams(routeParams as any).toString(),
      {
        headers: {
          'Authorization': `Bearer ${process.env.ENSO_API_KEY}`
        }
      }
    ).then(res => res.json());

    console.log("Transaction generated:", routeData);
    
    // The returned data contains the transaction that can be sent to the blockchain
    return routeData;
  } catch (error) {
    console.error('Error generating borrow transaction:', error);
    throw error;
  }
}

The response will include:

  • tx: The transaction object ready to be submitted to the blockchain
  • gas: Estimated gas for the transaction
  • route: Array of steps the transaction will take
  • createdAt: Block number when the transaction was created
4

Execute the transaction

Send the generated transaction to the blockchain:

import { ethers } from 'ethers';

async function executeTransaction(txData: any) {
  try {
    // Initialize provider and signer
    const provider = new ethers.providers.Web3Provider(window.ethereum);
    const signer = provider.getSigner();
    
    // Create transaction object
    const transaction = {
      to: txData.tx.to,
      from: txData.tx.from,
      data: txData.tx.data,
      value: txData.tx.value || "0",
      gasLimit: ethers.BigNumber.from(txData.gas).mul(15).div(10) // Add 50% buffer
    };
    
    // Send the transaction
    console.log("Sending transaction...");
    const txResponse = await signer.sendTransaction(transaction);
    console.log("Transaction sent:", txResponse.hash);
    
    // Wait for transaction to be mined
    const receipt = await txResponse.wait();
    console.log("Transaction confirmed in block:", receipt.blockNumber);
    
    return receipt;
  } catch (error) {
    console.error("Error executing transaction:", error);
    throw error;
  }
}
5

Next steps

Updated

Was this page helpful?