Solana IDL Policies

The solData criterion provides advanced validation of Solana transaction instruction data using Interface Definition Language (IDL) specifications. It decodes and validates instruction parameters against specific rules before signing, and applies to API key authentication wallets only.

For general policy setup, see the Policy Engine Overview. For common Solana policy patterns, see Solana Policies.

How solData works

A solData criterion specifies which Solana programs to validate via the idls field, then defines instruction-level validation rules via the conditions field.

The idls field accepts either:

• Known program shortcuts — "SystemProgram", "TokenProgram", "AssociatedTokenProgram"
• Custom IDL objects for any other program

IDL specifications

Anchor IDL format

IDL specifications must follow Anchor’s IDL format v0.30+. To convert older formats:

anchor idl convert path/to/idl.json -o path/to/idl.json

Supported argument types

Primitive types supported: bool, string, pubkey, u8–u256, i8–i256, f32, f64.

Complex types (user-defined types, arrays, vectors, optionals) are not currently supported. Reach out on CDP Discord if you need them.

Instruction discriminators

Discriminators are unique byte sequences that identify instructions within a program:

Program Type	Format	Size	Example
SystemProgram	4-byte little-endian u32	4 bytes	Transfer = [2,0,0,0]
SPL Token	1-byte enum index	1 byte	Transfer = 3
Associated Token	Borsh-encoded enum	1 byte	Create = 0
Anchor Programs	SHA256 of "global:instruction_name"	8 bytes	—

IDL configuration

Known program shortcuts

Use predefined names for common programs instead of providing full IDL objects:

• "SystemProgram" — Native Solana system program
• "TokenProgram" — SPL Token program
• "AssociatedTokenProgram" — Associated Token Account program

Custom IDL objects

For custom programs, provide IDL objects with:

• address — The program’s public key
• instructions — Array of instruction definitions, each with name, discriminator, and args

Conditions

Evaluation logic

• Multiple conditions in a solData criterion are evaluated with OR logic — any matching condition passes
• Parameters within a condition are evaluated with AND logic — all must match

Condition structure

Each condition includes:

• instruction — Name matching an instruction in one of the provided IDLs
• params (optional) — Array of parameter validations, each with name, operator (==, <=, >=, <, >, !=, in, not in), and value or values

Examples

Using known program shortcuts

Node (TypeScript)

import { CdpClient } from "@coinbase/cdp-sdk";
import "dotenv/config";

const cdp = new CdpClient();

const policy = await cdp.policies.createPolicy({
  policy: {
    scope: "account",
    description: "solData policy using known IDLs",
    rules: [
      {
        action: "accept",
        operation: "signSolTransaction",
        criteria: [
          {
            type: "solData",
            idls: ["SystemProgram", "TokenProgram", "AssociatedTokenProgram"],
            conditions: [
              {
                instruction: "transfer",
                params: [{ name: "lamports", operator: "<=", value: "1000000" }],
              },
              {
                instruction: "transfer_checked",
                params: [
                  { name: "amount", operator: "<=", value: "100000" },
                  { name: "decimals", operator: "==", value: "6" },
                ],
              },
              { instruction: "create" },
            ],
          },
        ],
      },
    ],
  },
});

console.log("Created solData policy:", policy.id);

const account = await cdp.solana.getOrCreateAccount({ name: "MyAccount" });
await cdp.solana.updateAccount({
  address: account.address,
  update: { accountPolicy: policy.id },
});

Using custom IDL objects

Node (TypeScript)

import { CdpClient } from "@coinbase/cdp-sdk";

const cdp = new CdpClient();

const policy = await cdp.policies.createPolicy({
  policy: {
    scope: "account",
    description: "solData policy with custom IDLs",
    rules: [
      {
        action: "accept",
        operation: "signSolTransaction",
        criteria: [
          {
            type: "solData",
            idls: [
              {
                address: "11111111111111111111111111111111",
                instructions: [
                  {
                    name: "transfer",
                    discriminator: [163, 52, 200, 231, 140, 3, 69, 186],
                    args: [{ name: "lamports", type: "u64" }],
                  },
                ],
              },
              {
                address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
                instructions: [
                  {
                    name: "transfer_checked",
                    discriminator: [119, 250, 202, 24, 253, 135, 244, 121],
                    args: [
                      { name: "amount", type: "u64" },
                      { name: "decimals", type: "u8" },
                    ],
                  },
                ],
              },
            ],
            conditions: [
              {
                instruction: "transfer",
                params: [{ name: "lamports", operator: "<=", value: "1000000" }],
              },
              {
                instruction: "transfer_checked",
                params: [
                  { name: "amount", operator: "<=", value: "100000" },
                  { name: "decimals", operator: "==", value: "6" },
                ],
              },
            ],
          },
        ],
      },
    ],
  },
});

console.log("Created custom IDL solData policy:", policy.id);

Building Anchor-formatted instructions for the above examples

Node (TypeScript)

import { Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from "@solana/spl-token";

function createAnchorSystemTransferInstruction(amount: bigint): TransactionInstruction {
  const testAccount = Keypair.generate().publicKey;
  const data = Buffer.concat([
    Buffer.from([163, 52, 200, 231, 140, 3, 69, 186]),
    (() => { const b = Buffer.alloc(8); b.writeBigUInt64LE(amount); return b; })(),
  ]);
  return new TransactionInstruction({
    keys: [
      { pubkey: testAccount, isSigner: true, isWritable: true },
      { pubkey: testAccount, isSigner: false, isWritable: true },
    ],
    programId: new PublicKey("11111111111111111111111111111111"),
    data,
  });
}

function createAnchorSPLTransferCheckedInstruction(amount: number, decimals: number): TransactionInstruction {
  const testAccount = Keypair.generate().publicKey;
  const amountBuf = Buffer.alloc(8); amountBuf.writeBigUInt64LE(BigInt(amount));
  const decimalsBuf = Buffer.alloc(1); decimalsBuf.writeUInt8(decimals);
  const data = Buffer.concat([Buffer.from([119, 250, 202, 24, 253, 135, 244, 121]), amountBuf, decimalsBuf]);
  return new TransactionInstruction({
    keys: [
      { pubkey: testAccount, isSigner: false, isWritable: true },
      { pubkey: testAccount, isSigner: false, isWritable: false },
      { pubkey: testAccount, isSigner: false, isWritable: true },
      { pubkey: testAccount, isSigner: true, isWritable: false },
    ],
    programId: TOKEN_PROGRAM_ID,
    data,
  });
}

function createAnchorAssociatedTokenAccountCreateInstruction(): TransactionInstruction {
  const testAccount = Keypair.generate().publicKey;
  return new TransactionInstruction({
    keys: Array(6).fill({ pubkey: testAccount, isSigner: false, isWritable: false }),
    programId: ASSOCIATED_TOKEN_PROGRAM_ID,
    data: Buffer.from([24, 30, 200, 40, 5, 28, 7, 119]),
  });
}

For TypeScript projects using custom Anchor programs, the @coral-xyz/anchor SDK provides type-safe instruction builders and IDL utilities that simplify constructing properly formatted transactions.

Ecosystem program examples

The solData criterion works with any Solana program. Common use cases by category:

Category	Programs
DeFi / Trading	Jupiter (slippage limits), Raydium (liquidity constraints)
Staking	Jito (validator selection), Marinade (deposit/withdrawal limits)
NFTs	Metaplex (mint parameters), Magic Eden (bid validation)

Key considerations

• Always use Anchor IDL format v0.30+
• Discriminator bytes must exactly match the program’s instruction identifiers
• Convert older IDL formats with anchor idl convert before use