sendaifun/solana-agent-kit

• plugin-defi/src/drift/tools/drift.ts:222 and 288, and drift_vault.ts:639
• the Flash tools
• plugin-misc/src/gibwork/tools/create_gibwork_task.ts:62
• plugin-misc/src/crossmint/tools/checkout.ts:104
• plugin-blinks/src/sendarcade/tools/rock_paper_scissor.ts:99, which also reports the prize as claimed without confirmation
• plugin-nft/src/metaplex/tools/deploy_token2022.ts:80

if (agent.wallet.signAndSendTransaction) {
  const { signature } = await agent.wallet.signAndSendTransaction(tx);

A host that configured sign-only, for example to have a human approve each transaction, still has funds moved without approval.

Route every send through one function that honours sign-only. Fix the cross-version instanceof check, for example with 'version' in tx, instead of working around it.

• phantom-agent-starter/src/app/utils/provider.ts:9
• crossmint-sak-v2/src/lib/ai/providers.ts:9
• privy-agent-tanstack-starter/src/lib/ai/providers.ts:9
• privy-sak-react-native/src/lib/ai/providers.ts:20

apiKey: process.env.NEXT_PUBLIC_OPENAI_API_KEY,

Any visitor, or anyone who unpacks the APK, can copy the key and spend on the account.

Call the model from an authenticated server route, and rotate the keys.

const API_PRIVATE_KEY = process.env.NEXT_PUBLIC_TURNKEY_API_PRIVATE_KEY as string

Anyone can create wallets and sign for the organisation.

Keep the key server-side, and rotate it.

const user = await getUser(data.email, data.walletAddress);
...
await session.update({ id: user[0].id,

loginFn and signupFn open a session for whichever user matches the posted email or wallet address. They check no signature and no token. Wallet addresses are public, so anyone can log in as any user and read or act on their chats. An unknown user also crashes the login: getUser returns an array, an empty array is truthy, and user[0].walletAddress then throws.

Verify a Crossmint or Privy auth token, or a signed challenge, on the server before you create the session. Test user.length === 0 for the not-found case.

const walletAddress = req.headers['x-wallet-address'] as string || req.query.walletAddress as string;

Wallet addresses are public on chain, so anyone can read, overwrite or delete any user's chats. A query such as ?walletAddress[$ne]=x reaches findOne as an operator object, which bypasses the login altogether. POST /user changes any user's profile without any check.

Verify a Privy access token or a signed nonce, then issue a session. Reject values that are not strings. Put /user behind the same middleware.

const txBuffer = Buffer.from(transactionData.substring(2), "hex");
const transaction = VersionedTransaction.deserialize(txBuffer);

The bridge-execution tool takes a hex transaction from the model's tool arguments and signs it with the agent wallet. A prompt injection can make the model pass a transaction that drains the wallet.

Execute only orders this tool created itself (keep them server-side and look them up by id). Decode the instructions and check the programs, the fee payer, the amounts and the destinations before signing.

let evmWallet: Wallet | null;

In a process that serves several agents or tenants, later agents sign EVM swaps with the first agent's private key and spend from the wrong wallet.

Build the wallet from the current agent's configuration on each call, or cache it per agent.

solanaAgentWithPara.wallet = {

Concurrent users sign and send with each other's wallets. Anyone can post a key share or drive the chat route.

Create one agent per authenticated session or request, and require authentication on both routes.

const memory = new MemorySaver();
...
thread_id: "Solana Agent Kit!",

• Conversations from different visitors merge and can leak to each other.
• History is duplicated on every request.
• The unauthenticated route lets any visitor direct the server wallet (line 46).

Key the thread by an authenticated session, send only the new message, require authentication, and limit spending.

accountLoader: new BulkAccountLoader(agent.connection, "processed", 10),

Each early throw leaves a poller hitting the RPC for the life of the process. Repeated failures stack pollers until the provider rate-limits the agent. One deposit opens four or more clients.

Call cleanUp() in finally blocks, use one client per operation, and poll about every second.

txSigs.push(signature);
}
throw new Error(

The throw runs on every loop iteration. Every array call sends transaction 1 and then reports failure, so the rest are never sent. Callers may retry and pay twice. Affected callers include cancelling limit orders and the Raydium launch.

Put the throw in an else branch, or check support once before the loop. Add a two-transaction test.

const API_KEY = "lv2_…";

Everyone who installs the package gets the key and can use up its quota.

Revoke and rotate the key. Read it from the agent configuration and fail fast when it is missing.

let REFERRAL_WALLET = new PublicKey(
  "FPfG…",

That address is passed as the token creator (line 88), so creator-fee ownership goes to a fixed outside wallet unless the user overrides it.

Default the creator to the agent wallet, and make any referral an explicit, documented opt-in.

• plugin-defi/src/flash/tools/utils/flashUtils.ts:275
• plugin-defi/src/adrena/tools/utils/anchor/AdrenaClient.ts:45
• plugin-defi/src/okx/tools/execute_swap.ts:33

agent.wallet.signTransaction,

The default keypair wallet reads this.payer, so a detached call throws. Mayan, Flash and Adrena trades cannot be signed.

Pass wrappers such as (tx) => agent.wallet.signTransaction(tx).

• lines 113, 138 and 274
• plugin-defi/src/drift/tools/drift.ts:215 and 280
• plugin-token/src/solana/tools/close_empty_token_accounts.ts:60

const txn = new Transaction().add(...depositPlaceOrderIx);
txn.recentBlockhash = blockhash;

The keypair wallet's partialSign cannot compile a message without a fee payer. Every Manifest tool, Drift deposit and Drift withdraw fails.

Set feePayer = agent.wallet.publicKey, or build a v0 message with an explicit payer.

const required = Object.keys(properties);
...
throw new Error(`Unsupported Zod type: ${typeName}`);

The model has to invent values, for example a mint for a plain SOL transfer. One union schema in the misc plugin breaks creation of the whole tool list.

Emit optional fields as nullable. Handle unions, records and any. Skip, and log, actions that cannot be converted.

result[key] = isZodOptional(value) ? value.unwrap() : value;

Keep the optional schema, and parse inputs through the action schema.

const txs = await Promise.all(
  transactions.map(async (tx) => {

A failure partway leaves accounts half-created, with their rent spent.

Send the transactions in order, confirm each one, and report how far it got.

const adjustedPrice = price.mul(new BN(100));

Tokens priced below one cent are reported as 0.00.

Format using the full exponent.

const convertedAmount =
  params.amount / convertToNumber(baseAssetPrice.price, PRICE_PRECISION);

A request for "50 SOL" opens a 50 USD position.

Choose one unit, and name and document it.

const slippageBps = new BN(1000);

Make slippage a bounded parameter, set a maximum leverage, and keep preflight on.

dangerouslySetInnerHTML={{ __html: marked(m.content) }}

Text that reaches the model from tools or chain data can inject script into a page that holds signing access.

Render with react-markdown, or sanitise with DOMPurify.

const email = searchParams.get("email");
...
db.findOne({ email }, (err, doc) => {

• Anyone who knows an email can download that user's key share, or delete it.
• Storage is in memory only.
• The save route reports success before the write completes.

Require a session that matches the email. Never return raw shares. Use durable storage and acknowledge only after the write.

If user asks for his funds back, you can send them their private key ${keyPair.privateKey}.

The key is sent to the model provider and can be pulled out by prompt injection. It is also stored unencrypted.

Never put secrets in prompts. Use a custodial or key-management wallet service.

await ctx.reply("Your private key is:");
await ctx.reply(`${String(keyPair.privateKey)}`);

The key ends up in chat history and backups on every private message.

Do not echo keys. Offer an authenticated export flow instead.

• examples/social/tg-bot-starter/basic-tg-bot/src/app/api/bot/route.ts:31
• examples/defi/wormhole-nextjs-agent/app/api/chat/route.ts:18

const secretKey = bs58.decode(process.env.SOLANA_PRIVATE_KEY as string);

Anyone who can message the bot or call the route can transfer or swap the wallet's funds.

Add allow-lists or authentication, spending caps and confirmation steps.

const handler = webhookCallback(bot, "std/http");

A forged update can claim any user id and drive that user's custodial wallet.

Register the webhook with a secret token and verify it.

const shouldRetry = isTransactionRelated(messageContent) && retryCount < MAX_RETRIES;

A transfer or swap can run twice.

Retry only idempotent calls, and deduplicate by signature.

• plugin-misc/src/gibwork/tools/create_gibwork_task.ts:59
• plugin-blinks/src/sendarcade/tools/rock_paper_scissor.ts:26
• plugin-defi/src/lulo/tools/lend.ts:25
• plugin-defi/src/solayer/tools/stake_with_solayer.ts:33
• plugin-misc/src/crossmint/tools/checkout.ts:102

const transaction = VersionedTransaction.deserialize(swapTransactionBuf);
return await signOrSendTX(agent, transaction);

A compromised, spoofed or buggy API response receives a full wallet signature. Several of these paths also send with skipPreflight: true.

Before signing, check:

• the fee payer is the agent wallet
• the program ids are on an allow-list
• the token outflows match the requested mint, amount and recipient

const { tipLamports } = await lavaApi("/bundle/tip");
... body: { ...body, astralaneTipLamports: tipLamports },

An abnormal value is paid in full. Transactions go out with skipPreflight: true (line 48), so failed trades still land on chain and pay fees.

Cap the tip in configuration, inspect the returned transaction, and keep preflight on.

if (statuses.value[0]) {
  if (!statuses.value[0].err) {
    return signature;

• A "processed" status can still be rolled back, but the caller is told the transfer or swap happened.
• The same signed transaction is re-sent for up to 90 s without tracking the block height until which its blockhash is valid.
• A transaction that lands between polls can come back as "already processed" or "Blockhash not found", and that gets reported as a failure. The caller may then retry and pay twice.

Require at least "confirmed" status. Use confirmTransaction with lastValidBlockHeight, and treat "already processed" as a status check, not an error.

• plugin-token/src/solana/tools/request_faucet_funds.ts:20
• plugin-nft/src/metaplex/tools/deploy_token2022.ts:80, which confirms only at "processed"

await agent.connection.confirmTransaction({
  signature,
  blockhash: latestBlockhash.blockhash,

A transaction that reverts is reported as success.

Use the blockhash of the signed transaction. Throw when value.err is set, and confirm at "confirmed" or higher.

throw new Error(`Transaction ${swapRes.serializedTrx} reverted!`);
...
if (res.status !== 200) { throw error;

The revert error is thrown inside the same try block, so the catch returns the signature as success whenever the vendor explorer answers 200.

Handle result.value.err outside the try and always fail on it. Fall back to the explorer only for RPC timeouts.

• plugin-defi/src/drift/tools/drift.ts:143, plus lines 208, 274, 601 and 683
• plugin-defi/src/meteora/tools/create_meteora_dlmm_pool.ts:34

const mintInfo = await getMint(agent.connection, mint);
...
createTransferInstruction(

Token-2022 mints fail or derive the wrong token account. An unchecked transfer also lets a wrong-decimals amount through.

• Read the mint's owner program and pass it to the mint lookup, the ATA derivation and the instruction builders.
• Use createTransferCheckedInstruction.
• Create the ATA with the idempotent instruction.

programId: mintInfoA.owner.toString(),

Liquidity can be deposited into a pool for a mint with a permanent delegate, a transfer hook or a transfer fee, and none of these are checked.

Require the owner to be one of the two token programs. Decode the mint, and reject or warn on risky extensions and on active mint or freeze authorities.

• plugin-defi/src/sanctum/tools/sanctum_get_owned_lst.ts:12
• plugin-misc/src/helius/tools/send_transaction_with_priority.ts:99
• plugin-nft/src/tensor/tools/tensor_trade.ts:22

programId: TOKEN_PROGRAM_ID,

Token-2022 holdings are left out of portfolios and lookups.

Query both token programs and merge the results.

const ix = await pumpSdk.collectCoinCreatorFeeInstructions(REFERRAL_WALLET);
...
payerKey: REFERRAL_WALLET,

The agent cannot provide that wallet's signature, so the claim fails. It also targets a third party's fees instead of the agent's.

Use agent.wallet.publicKey as both the payer and the creator.

fee_payer: agent.wallet.publicKey.toBase58(),
...
...rest,

...rest can override the fee payer, and the OKX schema lets the model choose the user wallet. The Ranger module is not registered at the moment, but it will become reachable once someone registers it.

Set these fields from the agent wallet, after the spread. Remove them from the schemas.

• jupiter/tools/stake_with_jup.ts:28
• mayan/tools/swap.ts:99
• dexscreener/tools/get_token_data.ts:19
• plugin-defi/src/drift/tools/drift.ts:754
• plugin-blinks/src/sendarcade/tools/rock_paper_scissor.ts:68
• plugin-misc/src/messari/tools/ask_messari_ai.ts:31

const { swapTransaction } = await (
...
const swapTransactionBuf = Buffer.from(swapTransaction, "base64");

An outage or an error body ends as an obscure TypeError, or is returned to the user as data with status "success".

Check response.ok, validate the fields you need, and pass the vendor's error message on.

const data = await response.json();
const parsedData = data.parsed;

Stale or wide-confidence prices size positions and collateral.

Reject prices older than a threshold or with a large confidence interval, and check the HTTP status.

programId: messages.staticAccountKeys[ix.programIdIndex],
keys: ix.accountKeyIndexes.map((i) => ({
  pubkey: messages.staticAccountKeys[i],

Indexes that point into lookup tables resolve to undefined, so the swap crashes or is built wrongly.

Use the vendor message as delivered and only refresh the blockhash. Otherwise, decompile it with the lookup-table accounts.

`Transaction failed: ${statuses.value[0].err.toString()}`,

Users see [object Object] or {} instead of the reason the transaction failed.

Serialise the error object, or map known errors to text. Include the signature.

• plugin-defi/src/drift/tools/drift.ts:615 says "Failed to get APYs" in the staking function.
• examples/misc/agent-kit-nextjs-langchain/app/api/chat/route.ts:79 returns raw exception text.
• examples/embedded-wallets/para-plugin-example/app/api/wallet/init/route.ts:19 returns raw exception text.
• plugin-nft/src/tensor/tools/tensor_trade.ts:35 swallows the ownership error.

throw new Error(`Transaction ${swapRes.serializedTrx} reverted!`);

Give a short, accurate message with the signature, and keep the technical detail in the logs.

return token_account.value.uiAmount || 0;

• get_balance passes the mint address to getTokenAccountBalance, which expects a token account, and a null result becomes 0.
• In the vault tool, an explicit fee or hurdle of 0 is treated as "not provided".

• Derive the owner's token account from the mint.
• Use the raw amount and the decimals.
• Treat null as an error.
• Test !== undefined, not truthiness.

.toSorted((a, b) => (b.daily_volume ?? 0) - (a.daily_volume ?? 0))

Handle a missing field explicitly. Use ?? so that a value of 0 survives, and do not mutate the caller's parameters.

`https://worker.jup.ag/blinks/swap/So111.../jupSoLaH.../${amount}`

Move to a documented public API, or put this endpoint behind a configuration flag with a clear error when it stops working.

const transactionHash = await phantom.solana.signAndSendTransaction(tx);
return { signature: transactionHash };

The provider returns an object, so the "signature" is an object. Rendering the signMessage result as a string crashes the component.

Read .signature and encode it before you store or display it.

const phantomInstance = await createPhantom({

Check window.isSecureContext and show a clear message when the page is served over plain HTTP.

if (wallet.provider === 'mwa' || Platform.OS === 'android') {

• On Android, a user of the embedded wallet would be routed to a different wallet.
• The cluster is hard-coded to devnet, and the authorization result, including its token, is logged.
• The file imports a module that does not exist, so today it is dead code.

Route only on wallet.provider === 'mwa', take the chain from configuration, and stop logging auth tokens.

const prefersDark = window.matchMedia('(prefers-color-scheme: light)').matches;

First-time visitors get the opposite of their system theme.

Query (prefers-color-scheme: dark).

const [theme, setTheme] = useState<Theme>("light");

Dark-mode users see a light flash on every load. The Android splash is white, with no night override, before the app's dark UI appears.

Set the theme with an inline head script before hydration. Make the splash colour match the app background.

<item name="android:statusBarColor">#ffffff</item>

Use colour resources with night variants, and switch the logo per theme.

sizes="100%"

The browser falls back to 100vw and downloads a full-width image for a small avatar.

Pass the drawn width, for example sizes="48px".

if (!authenticated && e.target.value.trim() !== "") {
  checkAuthAndShowModal();

Ask for sign-in on send, which the submit handler already does.

let solutiofiClient: SolutioFi | null = null;

Later agents reuse the first agent's API key. Parallel calls can use the client before authenticate() has finished.

Cache one in-flight promise per agent or per API key, and clear it on failure.

const pollInterval = setInterval(async () => {
...
return { success: false, error: "Payment confirmation timeout",

Values returned from timer callbacks go nowhere. A paid order is reported as failed, which invites a re-order, and the timers fire after the function has returned.

Write an awaited loop that polls, sleeps and checks a deadline, returns the real status, and leaves no dangling timers.

const statuses = await agent.connection.getSignatureStatuses([signature]);

This is about 180 RPC calls per transaction.

Use confirmTransaction with the blockhash and block height, and re-send at a slower interval.

plugin.initialize(this as SolanaAgentKit);
...
throw new Error(`Method ${methodName} already exists in methods`);

A name collision throws after some methods are already bound. The plugin is left half-registered, and a retry fails.

Check all names first, then update the methods, actions and plugin map together.

JSON.stringify(await action.handler(solanaAgentKit, inputs)),

Run every adapter through executeAction, so that validation and error shape are the same everywhere.

const connection = new Connection(this.rpcUrl);

Create these once.

await new Promise((resolve) => setTimeout(resolve, 2000));

Wait for the init transaction to confirm, fetch the account again, and rethrow unexpected errors.

if (walletDataStr) {
  fs.writeFileSync(WALLET_DATA_FILE, walletDataStr);

Remove the no-op read and write, and create the checkpointer once.

await updateDoc(userDocRef, { inProgress: true });

Two messages can both pass the check. A function killed at its time limit leaves the user locked out permanently.

Use a transactional compare-and-set with a lease timestamp that expires, and reset the flag in one place.

const existingMessage = await Message.findOne({ id });

Ownership is checked only against the chat id in the request, so a caller can supply a message id that belongs to another user's chat.

Look the message up by both { id, chatId }.

const messageId = `${ctx.chatId}-${ctx.message.message_id}`;
...
id: messageId + 1,

"<chat>-45" + 1 becomes "<chat>-451", which later collides with a real message id. The batch insert then fails and the chat history silently stops growing.

Use UUIDs, or prefixes such as u- and a-.

walletAddress: text("walletAddress").notNull().default(""),

Concurrent sign-ups create duplicate users, and every user without a wallet matches ''.

Add unique constraints and a check that an email or a wallet address is present. Use an upsert.

const agent = new SolanaAgentKit(keypairWallet, keypairWallet.rpcUrl, {});

No plugins are loaded, so the server starts without error but exposes no tools. The start promise is also left unhandled.

Load the plugins, build the configuration from the environment, and exit with an error when the tool list is empty.

"x-api-key": process.env.FLEXLEND_API_KEY!,

A key supplied through the configuration is ignored. If the variable is unset, the request fails with an unrelated TypeError.

Read the key from agent.config, fail fast when it is missing, and check response.ok.

apiKey: agent.config.OKX_API_KEY ?? "",

Add one credential helper that throws a clear error.

export async function getLendingAndBorrowAPY(

Split the file into client, user account, insurance fund, swap and market data modules. Have each protocol export its own bundle of methods and actions.

• the openai, langchain and vercel-ai adapters
• packages/core/src/types/action.ts:25 versus types/index.ts:115
• the no-op initialize loop copied into every plugin (packages/plugin-token/src/index.ts:156)

for (const action of actions.slice(0, 127)) {

Add one helper for limiting actions and building tool descriptions, and keep one Action type definition.

import { type feeTiers, getComputeBudgetInstructions, sendTx } from "../utils/send_tx";

Move signOrSendTX into utils/ and keep types/ for declarations only.

- name: Run lint and fix
  run: pnpm run lint:fix

Run pnpm run lint instead. Add a test job, including a smoke test that loads every plugin and builds each tool list. Align the pnpm version with the one in package.json.

const tokenData = await agent.methods.getAsset(
...
// Add your DeFi plugin test here

Write real assertions against a mocked RPC, port or delete the old-API files, and exit non-zero on failure.

"test": "jest"

Add a test runner with a configuration and smoke tests, or remove the scripts.

adjustment_type: "Increase", // TODO: Confirm if this should be "Increase" or another type for open

Check each value against the provider's API before you enable this module.

export const TOKENS = {
  SEND: new PublicKey("SENDdRQt..."),

Keep one exported table in core, import it everywhere, and fix the RERERRAL_FEE typo once.

const response = await fetch(
  `https://mainnet.helius-rpc.com/?api-key=${agent.config?.HELIUS_API_KEY}`,

Extract one helper in core.

console.warn(
  `No token account found for wallet ${wallet_address.toString()} ...

Log once, at the boundary that handles the error, through an injectable logger.

run: pnpm install --no-frozen-lockfile

Use --frozen-lockfile, and publish from CI with provenance.

• the root generate script points at a missing file
• .lintstagedrc targets ESLint, but the project uses Biome and the .husky hook directory is gitignored

import { SolanaAgentKit } from "../src";

Port the duplicate-tool check to the current API and run it in CI, or delete these files.

agent.config?.ALLORA_API_KEY || "UP-d…";

Remove the literal, require the key from configuration, and rotate it.

const mint = Keypair.generate();
...
const txHash = await signOrSendTX(agent, tx);

The create instruction needs the mint's signature, so no token can ever be launched.

Call tx.sign([mint]) before the wallet signs, in both the send and sign-only branches.

new BN(amount),

A value such as 0.1 is truncated to 0 or throws. The slippage and priority-fee inputs are dropped.

Convert SOL to lamports, derive the token amount explicitly, and pass slippage and fee through.

return [await signOrSendTX(agent, tx), marketKeypair.publicKey.toBase58()];

Creating the account requires the new account's signature, so market creation always fails.

Call tx.partialSign(marketKeypair), or pass the keypair as an extra signer.

for (let i = 0; i < Math.max(0, MAX_INSTRUCTIONS - spl_token.length); i++) {
  transaction.add(token_2022[i]);

undefined is added and throws, including when there is nothing to close.

Bound the loop by token_2022.length, move the empty check above the loops, and report the number actually closed.

const txs = await sendCompressedAirdrop(
  mintAddress,

The agent argument is missing and strings are passed where PublicKeys are expected, so the action always fails. The tool also serialises a transaction that has no blockhash or fee payer (send_compressed_airdrop.ts:125).

Pass the agent and PublicKey values, and build complete transactions.

const sigOrTx = await signOrSendTX(agent, tx);
...
await signOrSendTX(agent, tx);

A successful mint ends in a duplicate-send error, and the agent may mint again.

Delete the second call.

const buyerTokenAccount = getAssociatedTokenAddressSync(
  agent.wallet.publicKey,
  TOKENS.USDC,

The wallet is passed as the mint and USDC as the owner, so registration always fails.

Use getAssociatedTokenAddressSync(TOKENS.USDC, agent.wallet.publicKey).

fees.sort((a, b) => a.prioritizationFee - b.prioritizationFee)[
  Math.floor(fees.length * feeTiers[feeTier])
].prioritizationFee,

On localnet, devnet or a quiet RPC, every send fails.

Fall back to a default fee and clamp the index.

const signedTransaction = await agent.wallet.signTransaction(transaction);
...
return sendTx(

Browser and hardware wallets prompt the user several times. A valid signed transaction is handed to the fee-estimate provider.

Sign once. Estimate fees from an unsigned serialisation.

priorityFee = data.result.priorityFeeEstimate;

An abnormal estimate is paid in full. On devnet with a Helius key configured, every send is blocked.

Validate and cap the estimate, check response.ok, and pick the host from the configured cluster.

• plugin-nft/src/metaplex/tools/deploy_token.ts:64
• plugin-defi/src/fluxbeam/tools/create_pool.ts:30
• plugin-misc/src/helius/tools/send_transaction_with_priority.ts:45
• plugin-defi/src/pumpfunAmm/tools/removeLiquidity.ts:31, which also assumes 6 decimals

lamports: amount * LAMPORTS_PER_SOL,

1.1 * 1e9 is not an integer, so web3.js rejects ordinary amounts. Large values lose precision.

Convert decimal strings to bigint using the mint's decimals.

tools[index.toString()] = tool({

The model sees tools named "0", "1" and so on, and the names change whenever plugins change. Descriptions are cut at 1,023 characters.

Use tools[action.name].

const tools = actions.slice(0, 127).map((action) => {

Use one constant for the check, the slice and the message.

`.../search/trending${agent.config?.COINGECKO_DEMO_API_KEY && `?x_cg_demo_api_key=...`}`

Use a ternary that falls back to "", and send the key in a header.

console.error("Error creating Crossmint Amazon order:", error);

The logged error includes the request headers, and with them the production key.

Log only the message, the status and the response body.

transaction: bs58.encode(transaction.serialize()),

Every SPL transfer through this action fails. When the recipient already has a token account, it fails anyway.

Add the instructions first, serialise with signature checks disabled for the estimate, and use the idempotent ATA instruction.

const openResult = await test("OPEN_POSITION (2x long cbBTC/USDC, $2)", () =>

If the position lookup is slow, the position stays open with real funds and the errors are swallowed.

Delete the script, or gate it behind an explicit opt-in on devnet and close the position in a finally block.

"solana-agent-kit": "2.0.7"

Core is at 2.0.10, so installs hit peer conflicts. A second copy of core can be installed, which breaks shared class checks.

Make core a peer dependency with a range only.

const { exportWallet } = require("@open-wallet-standard/core") as {

The package is "type": "module", and require is undefined in its ES-module build.

Use a static import, createRequire, or a dynamic import().

.sort((a: any, b: any) => (b.fdv || 0) - (a.fdv || 0));

A copycat token with an inflated supply wins the ranking, and value-moving actions then use its mint.

Resolve tickers against a verified list, or require the mint address.

} catch (_error) {
  continue;

Partial or failed irreversible operations are reported as success.

Collect a result per transaction and throw on failure.

inputAmount: z.number().positive("Input amount must be positive"),

Calls that follow the documented examples are rejected.

Remove the field, or make it optional.

_slippageBps: number = DEFAULT_OPTIONS.SLIPPAGE_BPS,

Users cannot limit swap slippage.

Send slippageBps, or cap dynamic slippage with it.

`https://voltr.xyz/api/remaining-accounts/deposit-strategy?vault=...`

Withdrawals revert, or run the wrong strategy instruction.

Call the withdraw endpoint.

await driftClient.connection.getAccountInfo(
  deriveInsuranceFundStakeAccount,

getAccountInfo returns null rather than throwing, so first-time stakes fail.

Set shouldCreateAccount = info === null.

numberToSafeBN(amount, QUOTE_PRECISION),

For a 9-decimal vault, the amount is off by a factor of 1,000.

Use the precision of the vault's asset.

const position = AdrenaClient.findPositionAddress(owner, principalCustody, "long",

Short trades target the wrong account.

Use "short".

.describe("Leverage in basis points (2000 = 2x)")

On chain, 10,000 means 1x, so 2000 is 0.2x, and the confirmation text shows the wrong multiplier.

Accept a multiplier and convert it once.

affiliateFeeRecipient: params.affiliateFeeRecipient,

A prompt injection can divert a share of bridged funds.

Take these values from trusted configuration only, with a cap.

clientOrderId: Number(Math.random() * 1000),

A u64 id field receives a non-integer from a small range, so ids collide.

Use an integer that increases monotonically or is generated with a cryptographic RNG.

slippageBps: z.number().optional().default(50)

Add .int().min(1).max(500) or a configured ceiling.

if (agent.connection.rpcEndpoint.includes("mainnet")) {

Valid custom endpoints are rejected as an unsupported network.

Use the genesis hash or explicit configuration.

]).start(() => {
  // Loop the animation
  animateDots();

stopAnimation completes the sequence, which starts the loop again, so it costs battery and CPU indefinitely.

Restart only when finished is true.

Clipboard.setString(walletAddress);

The core Clipboard has been removed, so copying the address fails.

Use expo-clipboard, which is already a dependency.

...transactions?api-key=${HELIUS_API_KEY}`;

Proxy the calls through the app's server, and rotate the key.

signingConfig signingConfigs.debug

The keystore and its password are public, so anyone can sign a replacement update for this wallet app.

Add a release signing configuration fed from CI secrets.

• privy-agent-tanstack-starter/src/functions/chats.ts:93
• examples/misc/privy-server-wallet-agent/app/(chat)/actions.ts:37 and 46, which also changes chat visibility
• crossmint-sak-v2/src/functions/chats.ts:133, where saving a message checks only that some session exists

export const deleteTrailingMessages = createServerFn({ method: "GET" })

Anyone can delete other users' history or make their chats public. Using GET also makes the delete triggerable by cross-site requests.

Require a session, check that the chat belongs to the caller, and use POST or DELETE.

password: "Chan…",

Anyone with the repository can forge session cookies.

Load a random secret from the environment and refuse to start without it.

router.post('/upload', upload.single('file'), uploadFile);

Require authentication, add per-user quotas, and serve uploads from a separate origin.

text: 'Message content unavailable'

Tool, image and reasoning parts are lost on save.

Persist the real part shapes, and reject invalid input.

for await (const chunk of (await Promise.race([
  stream,

The stream is already resolved when the race starts, so a hung model call runs until the platform kills the function.

Apply the deadline to the whole iteration.

if (codeData?.usedBy != null) {

One invite code can be redeemed several times. A second concurrent setDoc replaces a keypair whose address was already shown to the user, so funds sent to it are lost.

Use Firestore transactions, or create-if-absent writes.

userChatHistory.push(new HumanMessage(agentMessage));

Store replies as AI messages, cap the history, and persist it.

db.delete(usersTable).where(eq(usersTable.id, userId))

• There is no confirmation and no balance check, so funds become unreachable.
• The messages that the help text promises to delete remain.
• History is read in no defined order and with no limit.

Ask for confirmation, check the balance, delete the messages, and read history ordered and limited.

while (true) {
  try {
    const thought = "Be creative and do something interesting on the blockchain. " +

Add spending caps, allow-lists and a dry-run default, and trim the conversation history.

const solanaAgent = new SolanaAgentKit(
  process.env.SOLANA_PRIVATE_KEY!,

The route fails at start. Once that is fixed, special characters in user input throw or backtrack badly.

Migrate to the current API, and escape the input or use startsWith.

const keypairWallet = new KeypairWallet(keypair, process.env.RPC_URL as string);

The template defines only SOLANA_RPC_URL, so the wallet has no RPC.

Use one variable and fail fast if it is missing.

if (authority?.isMutable !== undefined) {
  defaultAuthority.isMutable = authority?.isMutable;

Tokens are created mutable, with the wallet as update authority, whatever the user asked for.

Pass the options into the create call, or reject them.

const result = await createCollection({}, collectionOpts);

Provide the agent's signer, and return the minted asset's address.

fromPubkey: agent.wallet.publicKey,

Use the vault PDA as the sender, and pass the vault index through.

return Buffer.from(signature);

Decode with the encoding the provider documents, and check that the result is 64 bytes.

<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>

Drawing over other apps makes overlay attacks on the signing prompts possible.

Keep that permission in the debug manifest only, and drop the permissions the app does not use.

signTransaction: async (tx) => {
  return tx;

Throw "not supported", or implement real signing.

signatures: [signedTransaction],

Deserialise and return the signed transaction. Make the stub sendTransaction throw.

console.log("keyPair", keyPair);

Log only the public key.

Exchange Rate: ${formatNumber(result.priceImpactPercentage)}%

Compute the rate from both token amounts. Give the model only the quote tool, and run the swap only after an explicit yes.