Hexel-chain NPM

Hexel Chain

A open-source framework empowers AI agents to seamlessly interact with Solana’s ecosystem, regardless of the underlying model. These agents can autonomously handle a wide range of tasks—more than 60 different blockchain operations—including:

Buying, selling, and launching tokens
Facilitating asset lending and borrowing
Distributing compressed airdrops
Deploying tokens on automated market makers (AMMs)
Executing blinks and other transactions
And much more...

Whether you’re a blockchain developer or an AI researcher exploring decentralized finance, this toolkit simplifies the integration of AI-driven automation into Solana, making advanced on-chain interactions more efficient than ever.

Replit template created by Hexel Chain

🔧 Core Blockchain Features

Token Transactions
- Deploy SPL tokens using Metaplex
- Facilitate asset transfers
- Verify balances
- Stake SOL
- Zk-compressed airdrops powered by Light Protocol and Helius
NFTs on 3.Land
- Design and launch your own collection
- Automatically create and list NFTs on 3.land
- Sell NFTs in any SPL token
NFT Management with Metaplex
- Deploy collections
- Mint NFTs
- Manage metadata
- Configure royalty settings
DeFi Integration
- Swap assets via Jupiter Exchange
- Launch on Pump through PumpPortal
- Create Raydium pools (CPMM, CLMM, AMMv4)
- Integrate with Orca Whirlpool
- Set up Manifest markets and limit orders
- Utilize Meteora Dynamic AMM, DLMM Pool, and Alpha Vault
- Establish Openbook markets
- Register and resolve SNS domains
- Execute Jito Bundles
- Fetch asset prices using Pyth Price feeds
- Register and resolve Alldomains
- Trade perpetuals with Adrena Protocol
- Access Drift Vaults, Perps, Lending, and Borrowing
- Enable cross-chain bridging via deBridge DLN
Solana Blinks
- Access lending services via Lulo (offering the best APR for USDC)
- Send Arcade Games
- Stake with JupSOL
- Stake SOL via Solayer (sSOL)
Non-Financial Actions
- Register bounties using Gib Work
Market Data Integration
- Integrate with CoinGecko Pro API
- Access real-time token pricing
- Track trending tokens and liquidity pools
- Analyze top gainers
- Retrieve detailed token information
- Monitor the latest pool updates

🤖 AI Integration Features

LangChain Integration
- Pre-built LangChain tools for blockchain tasks
- Autonomous agent compatibility using the React framework
- Persistent memory management for continuous interactions
- Streaming responses for instant real-time feedback
Vercel AI SDK Integration
- AI agent integration with Vercel AI SDK
- Support for multiple frameworks
- Fast and simple toolkit deployment
Autonomous Modes
- Interactive chat mode for guided workflows
- Fully autonomous mode for independent agent execution
- Customizable action intervals
- Integrated error handling and recovery system
AI-Powered Tools
- DALL-E integration for NFT artwork creation
- Natural language processing for blockchain commands
- Price feed integration for real-time market analysis
- Automated decision-making for enhanced efficiency

📃 Documentation

You can view the full documentation of the kit at docs.hexelchain.com

📦 Installation

npm install hexel-chain

Quick Start

import { HexelChain, createSolanaTools } from "hexel-chain";

// Initialize with private key and optional RPC URL
const agent = new HexelChain(
  "your-wallet-private-key-as-base58",
  "https://api.mainnet-beta.solana.com",
  "your-openai-api-key"
);

// Create LangChain tools
const tools = createSolanaTools(agent);

Usage Examples

Deploy a New Token

const result = await agent.deployToken(
  "my ai token", // name
  "uri", // uri
  "token", // symbol
  9, // decimals
  1000000 // initial supply
);

console.log("Token Mint Address:", result.mint.toString());

Create NFT Collection on 3Land

const isDevnet = false; // (Optional) if not present TX takes place in Mainnet
const priorityFeeParam = 1000000; // (Optional) if not present the default priority fee will be 50000

 const collectionOpts: CreateCollectionOptions = {
    collectionName: "",
    collectionSymbol: "",
    collectionDescription: "",
    mainImageUrl: ""
  };

const result = await agent.create3LandCollection(
      collectionOpts,
      isDevnet, // (Optional) if not present TX takes place in Mainnet
      priorityFeeParam, //(Optional)
    );

Create NFT on 3Land

When you create an NFT using 3Land's tool, it is automatically listed for sale on the 3.land website.

const isDevnet = true; // (Optional) if not present TX takes place in Mainnet
const withPool = true; // (Optional) only present if NFT will be created with a Liquidity Pool for a specific SPL token
const priorityFeeParam = 1000000; // (Optional) if not present the default priority fee will be 50000
const collectionAccount = ""; //hash for the collection
const createItemOptions: CreateSingleOptions = {
  itemName: "",
  sellerFee: 500, //5%
  itemAmount: 100, //total items to be created
  itemSymbol: "",
  itemDescription: "",
  traits: [
    { trait_type: "", value: "" },
  ],
  price: 0, //100000000 == 0.1 sol, can be set to 0 for a free mint
  splHash: "", //present if listing is on a specific SPL token, if not present sale will be on $SOL, must be present if "withPool" is true
  poolName: "", // Only present if "withPool" is true
  mainImageUrl: "",
};
const result = await agent.create3LandNft(
  collectionAccount,
  createItemOptions,
  isDevnet, // (Optional) if not present TX takes place in Mainnet
  withPool
  priorityFeeParam, //(Optional)
);

Create NFT Collection

const collection = await agent.deployCollection({
  name: "My NFT Collection",
  uri: "https://arweave.net/metadata.json",
  royaltyBasisPoints: 500, // 5%
  creators: [
    {
      address: "creator-wallet-address",
      percentage: 100,
    },
  ],
});

Swap Tokens

import { PublicKey } from "@solana/web3.js";

const signature = await agent.trade(
  new PublicKey("target-token-mint"),
  100, // amount
  new PublicKey("source-token-mint"),
  300 // 3% slippage
);

Lend Tokens

import { PublicKey } from "@solana/web3.js";

const signature = await agent.lendAssets(
  100 // amount of USDC to lend
);

Stake SOL

const signature = await agent.stake(
  1 // amount in SOL to stake
);

Stake SOL on Solayer

const signature = await agent.restake(
  1 // amount in SOL to stake
);

Send an SPL Token Airdrop via ZK Compression

import { PublicKey } from "@solana/web3.js";

(async () => {
  console.log(
    "~Airdrop cost estimate:",
    getAirdropCostEstimate(
      1000, // recipients
      30_000 // priority fee in lamports
    )
  );

  const signature = await agent.sendCompressedAirdrop(
    new PublicKey("JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN"), // mint
    42, // amount per recipient
    [
      new PublicKey("1nc1nerator11111111111111111111111111111111"),
      // ... add more recipients
    ],
    30_000 // priority fee in lamports
  );
})();

Fetch Price Data from Pyth

const priceFeedID = await agent.getPythPriceFeedID("SOL");

const price = await agent.getPythPrice(priceFeedID);

console.log("Price of SOL/USD:", price);

Open PERP Trade

import { PublicKey } from "@solana/web3.js";

const signature = await agent.openPerpTradeLong({
  price: 300, // $300 SOL Max price
  collateralAmount: 10, // 10 jitoSOL in
  collateralMint: new PublicKey("J1toso1uCk3RLmjorhTtrVwY9HJ7X8V9yYac6Y7kGCPn"), // jitoSOL
  leverage: 50000, // x5
  tradeMint: new PublicKey("J1toso1uCk3RLmjorhTtrVwY9HJ7X8V9yYac6Y7kGCPn"), // jitoSOL
  slippage: 0.3, // 0.3%
});

Close PERP Trade

import { PublicKey } from "@solana/web3.js";

const signature = await agent.closePerpTradeLong({
  price: 200, // $200 SOL price
  tradeMint: new PublicKey("J1toso1uCk3RLmjorhTtrVwY9HJ7X8V9yYac6Y7kGCPn"), // jitoSOL
});

Close Empty Token Accounts

const { signature } = await agent.closeEmptyTokenAccounts();

Create a Drift account

Create a drift account with an initial token deposit.

const result = await agent.createDriftUserAccount()

Create a Drift Vault

Create a drift vault.

const signature = await agent.createDriftVault({
  name: "my-drift-vault",
  marketName: "USDC-SPOT",
  redeemPeriod: 1, // in days
  maxTokens: 100000, // in token units e.g 100000 USDC
  minDepositAmount: 5, // in token units e.g 5 USDC
  managementFee: 1, // 1%
  profitShare: 10, // 10%
  hurdleRate: 5, // 5%
  permissioned: false, // public vault or whitelist
})

Deposit into a Drift Vault

Deposit tokens into a drift vault.

const signature = await agent.depositIntoDriftVault(100, "41Y8C4oxk4zgJT1KXyQr35UhZcfsp5mP86Z2G7UUzojU")

Deposit into your Drift account

Deposit tokens into your drift account.

const {txSig} = await agent.depositToDriftUserAccount(100, "USDC")

Derive a Drift Vault address

Derive a drift vault address.

const vaultPublicKey = await agent.deriveDriftVaultAddress("my-drift-vault")

Do you have a Drift account

Check if agent has a drift account.

const {hasAccount, account} = await agent.doesUserHaveDriftAccount()

Get Drift account information

Get drift account information.

const accountInfo = await agent.driftUserAccountInfo()

Request withdrawal from Drift vault

Request withdrawal from drift vault.

const signature = await agent.requestWithdrawalFromDriftVault(100, "41Y8C4oxk4zgJT1KXyQr35UhZcfsp5mP86Z2G7UUzojU")

Carry out a perpetual trade using a Drift vault

Open a perpetual trade using a drift vault that is delegated to you.

const signature = await agent.tradeUsingDelegatedDriftVault({
  vault: "41Y8C4oxk4zgJT1KXyQr35UhZcfsp5mP86Z2G7UUzojU",
  amount: 500,
  symbol: "SOL",
  action: "long",
  type: "limit",
  price: 180 // Please long limit order at $180/SOL
})

Carry out a perpetual trade using your Drift account

Open a perpetual trade using your drift account.

const signature = await agent.tradeUsingDriftPerpAccount({
  amount: 500,
  symbol: "SOL",
  action: "long",
  type: "limit",
  price: 180 // Please long limit order at $180/SOL
})

Update Drift vault parameters

Update drift vault parameters.

const signature = await agent.updateDriftVault({
  name: "my-drift-vault",
  marketName: "USDC-SPOT",
  redeemPeriod: 1, // in days
  maxTokens: 100000, // in token units e.g 100000 USDC
  minDepositAmount: 5, // in token units e.g 5 USDC
  managementFee: 1, // 1%
  profitShare: 10, // 10%
  hurdleRate: 5, // 5%
  permissioned: false, // public vault or whitelist
})

Withdraw from Drift account

Withdraw tokens from your drift account.

const {txSig} = await agent.withdrawFromDriftAccount(100, "USDC")

Borrow from Drift

Borrow tokens from drift.

const {txSig} = await agent.withdrawFromDriftAccount(1, "SOL", true)

Repay Drift loan

Repay a loan from drift.

const {txSig} = await agent.depositToDriftUserAccount(1, "SOL", true)

Withdraw from Drift vault

Withdraw tokens from a drift vault after the redemption period has elapsed.

const signature = await agent.withdrawFromDriftVault( "41Y8C4oxk4zgJT1KXyQr35UhZcfsp5mP86Z2G7UUzojU")

Update the address a Drift vault is delegated to

Update the address a drift vault is delegated to.

const signature = await agent.updateDriftVaultDelegate("41Y8C4oxk4zgJT1KXyQr35UhZcfsp5mP86Z2G7UUzojU", "new-address")

Get Voltr Vault Position Values

Get the current position values and total value of assets in a Voltr vault.

const values = await agent.voltrGetPositionValues("7opUkqYtxmQRriZvwZkPcg6LqmGjAh1RSEsVrdsGDx5K")

Deposit into Voltr Strategy

Deposit assets into a specific strategy within a Voltr vault.

const signature = await agent.voltrDepositStrategy(
  new BN("1000000000"), // amount in base units (e.g., 1 USDC = 1000000)
  "7opUkqYtxmQRriZvwZkPcg6LqmGjAh1RSEsVrdsGDx5K", // vault
  "9ZQQYvr4x7AMqd6abVa1f5duGjti5wk1MHsX6hogPsLk"  // strategy
)

Withdraw from Voltr Strategy

Withdraw assets from a specific strategy within a Voltr vault.

const signature = await agent.voltrWithdrawStrategy(
  new BN("1000000000"), // amount in base units (e.g., 1 USDC = 1000000)
  "7opUkqYtxmQRriZvwZkPcg6LqmGjAh1RSEsVrdsGDx5K", // vault
  "9ZQQYvr4x7AMqd6abVa1f5duGjti5wk1MHsX6hogPsLk"  // strategy
)

Get a Solana asset by its ID

const asset = await agent.getAsset("41Y8C4oxk4zgJT1KXyQr35UhZcfsp5mP86Z2G7UUzojU")

Get a price inference from Allora

Get the price for a given token and timeframe from Allora's API

const sol5mPrice = await agent.getPriceInference("SOL", "5m");
console.log("5m price inference of SOL/USD:", sol5mPrice);

List all topics from Allora

const topics = await agent.getAllTopics();
console.log("Allora topics:", topics);

Get an inference for an specific topic from Allora

const inference = await agent.getInferenceByTopicId(42);
console.log("Allora inference for topic 42:", inference);

Simulate a Switchboard feed

Simulate a given Switchboard feed. Find or create feeds here.

const value = await agent.simulateSwitchboardFeed(
      "9wcBMATS8bGLQ2UcRuYjsRAD7TPqB1CMhqfueBx78Uj2", // TRUMP/USD
      "http://crossbar.switchboard.xyz");;
console.log("Simulation resulted in the following value:", value);

### Cross-Chain Swap

```typescript
import { PublicKey } from "@solana/web3.js";

const signature = await agent.swap(
  amount: "10",
  fromChain: "bsc",
  fromToken: "0x3c499c542cef5e3811e1192ce70d8cc03d5c3359",
  toChain: "solana",
  toToken: "0x0000000000000000000000000000000000000000",
  dstAddr: "0xc2d3024d64f27d85e05c40056674Fd18772dd922",
);

Cross-Chain Bridge via deBridge

The Hexel Chain supports cross-chain token transfers using deBridge's DLN protocol. Here's how to use it:

Check supported chains:

const chains = await agent.getDebridgeSupportedChains();
console.log("Available chains:", chains);
// Example output: { chains: [{ chainId: "1", chainName: "Ethereum" }, { chainId: "7565164", chainName: "Solana" }] }

Get available tokens (optional):

const tokens = await agent.getDebridgeTokensInfo("1", "USDC"); // Search for USDC on Ethereum
console.log("Available tokens:", tokens);
// Shows tokens matching 'USDC' on the specified chain

Create bridge order (SOL -> ETH):

const orderInput = {
  srcChainId: "7565164", // Solana
  srcChainTokenIn: "11111111111111111111111111111111", // Native SOL
  srcChainTokenInAmount: "1000000000", // 1 SOL (9 decimals)
  dstChainId: "1", // Ethereum
  dstChainTokenOut: "0x0000000000000000000000000000000000000000", // ETH
  dstChainTokenOutRecipient: "0x23C279e58ddF1018C3B9D0C224534fA2a83fb1d2" // ETH recipient
};

const order = await agent.createDebridgeOrder(orderInput);
console.log("Order created:", order);
// Contains transaction data and estimated amounts

Execute the bridge order:

const signature = await agent.executeDebridgeOrder(order.tx.data);
console.log("Bridge transaction sent:", signature);

Check bridge status:

const status = await agent.checkDebridgeTransactionStatus(signature);
console.log("Bridge status:", status);
// Shows current status: Created, Fulfilled, etc.

Note: When bridging between chains:

To Solana: Use base58 addresses for recipients and token mints
From Solana: Use EVM addresses for recipients and ERC-20 format for tokens
Always verify addresses and amounts before executing bridge transactions

Get Token Price Data from CoinGecko

const priceData = await agent.getTokenPriceData([
  "So11111111111111111111111111111111111111112", // SOL
  "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"  // USDC
]);
console.log("Token prices:", priceData);

Get Trending Tokens

const trendingTokens = await agent.getTrendingTokens();
console.log("Trending tokens:", trendingTokens);

Get Latest Pools

const latestPools = await agent.getLatestPools();
console.log("Latest pools:", latestPools);

Get Token Information

const tokenInfo = await agent.getTokenInfo("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
console.log("Token info:", tokenInfo);

Get Top Gainers

const topGainers = await agent.getTopGainers("24h", "all");
console.log("Top gainers:", topGainers);

Get Trending Pools

const trendingPools = await agent.getTrendingPools("24h");
console.log("Trending pools:", trendingPools);

Examples

LangGraph Multi-Agent System

The repository includes an advanced example of building a multi-agent system using LangGraph and Hexel Chain. Located in examples/agent-kit-langgraph, this example demonstrates:

Multi-agent architecture using LangGraph's StateGraph
Specialized agents for different tasks:
- General purpose agent for basic queries
- Transfer/Swap agent for transaction operations
- Read agent for blockchain data queries
- Manager agent for routing and orchestration
Fully typed TypeScript implementation
Environment-based configuration

Check out the LangGraph example for a complete implementation of an advanced Solana agent system.

Dependencies

The toolkit relies on several key Solana and Metaplex libraries:

@solana/web3.js
@solana/spl-token
@metaplex-foundation/digital-asset-standard-api
@metaplex-foundation/mpl-token-metadata
@metaplex-foundation/mpl-core
@metaplex-foundation/umi
@lightprotocol/compressed-token
@lightprotocol/stateless.js
@coingecko/sdk

Contributing

Contributions are welcome! Please feel free to submit a Pull Request. Refer to CONTRIBUTING.md for detailed guidelines on how to contribute to this project.

Contributors

License

Apache-2 License

Security

This toolkit handles private keys and transactions. Always ensure you're using it in a secure environment and never share your private keys.

solana agent ai hexel chain

5 months ago

5 months ago

5 months ago

5 months ago

5 months ago