diff --git a/.context/program-examples b/.context/program-examples deleted file mode 160000 index bf2705a4..00000000 --- a/.context/program-examples +++ /dev/null @@ -1 +0,0 @@ -Subproject commit bf2705a42094fb0568be74cc2e8c9599464c30df diff --git a/.entire/.gitignore b/.entire/.gitignore new file mode 100644 index 00000000..2cffdefa --- /dev/null +++ b/.entire/.gitignore @@ -0,0 +1,4 @@ +tmp/ +settings.local.json +metadata/ +logs/ diff --git a/.entire/settings.json b/.entire/settings.json new file mode 100644 index 00000000..f6821f94 --- /dev/null +++ b/.entire/settings.json @@ -0,0 +1,5 @@ +{ + "strategy": "auto-commit", + "enabled": true, + "telemetry": false +} diff --git a/.gitignore b/.gitignore index f6f2388f..4c892c3f 100644 --- a/.gitignore +++ b/.gitignore @@ -9,4 +9,7 @@ node_modules/ stash docs-audit.md -docs-audit.txt \ No newline at end of file +docs-audit.txt +docs-anchor.json +product-docs.json +tabs-docs.json \ No newline at end of file diff --git a/ai-tools/guide.mdx b/ai-tools/guide.mdx index 7fc4325e..cbaf543f 100644 --- a/ai-tools/guide.mdx +++ b/ai-tools/guide.mdx @@ -2,36 +2,50 @@ title: "AI Tools Guide" description: "Guidance to AI tools when working with ZK Compression. Includes Agent Skill, MCP server, DeepWiki, and AI Search guides." --- +import InstallAgentSkills from "/snippets/setup/install-agent-skills.mdx"; # For Docs - **Docs AI Search** - Search documentation with AI in the search bar. - **Markdown Export** - Append `.md` to any page URL for raw markdown. +* **View [`/llms.txt`](https://zkcompression.com/llms.txt)** for an index of the docs - It lists key pages with descriptions +so agents can navigate to answers quickly. # For Development -## AI agents - -### `skill.md` +## Agent Skills -`skill.md` is a structured capability file that tells agents what they can do -with Light Protocol and ZK Compression. If you're -building with agents, start here. +View or install [`/skill.md`](https://zkcompression.com/skill.md), a structured capability file that tells agents what they can do +with Light Protocol and ZK Compression. If you're building with agents, start here. -* View: [`/skill.md`](https://zkcompression.com/skill.md) +Install or view dedicated agent skills: -### `llms.txt` +| Use case | Skill | +| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------- | +| Build DeFi programs (AMMs, vaults, lending) with Anchor or Pinocchio | [defi-program](https://github.com/Lightprotocol/skills/tree/main/skills/defi-program) | +| Integrate rent-free markets into routers and aggregators | [defi-router](https://github.com/Lightprotocol/skills/tree/main/skills/defi-router) | +| Stream account state via Laserstream gRPC | [data-streaming](https://github.com/Lightprotocol/skills/tree/main/skills/data-streaming) | +| Wallets and payment flows with light-token. Includes privy, wallet adapter, mobile wallet adapter signing. Optional nullifier to prevent your onchain instruction from being executed more than once. | [payments-and-wallets](https://github.com/Lightprotocol/skills/tree/main/skills/payments-and-wallets) | +| Airdrops, DePIN, token distribution | [airdrop](https://github.com/Lightprotocol/skills/tree/main/skills/airdrop) | +| Anti-double-spend nullifiers for Privacy-preserving ZK programs | [zk-nullifier](https://github.com/Lightprotocol/skills/tree/main/skills/zk-nullifier) | +| Testing programs and clients on localnet, devnet, mainnet | [testing](https://github.com/Lightprotocol/skills/tree/main/skills/testing) | +| Help with Debugging and Questions via DeepWiki MCP | [ask-mcp](https://github.com/Lightprotocol/skills/tree/main/skills/ask-mcp) | -`llms.txt` is an index of the docs. It lists key pages with descriptions -so agents can navigate to answers quickly. +> View all skills here: https://github.com/Lightprotocol/skills. -* View: [`/llms.txt`](https://zkcompression.com/llms.txt) +All skills are included and are auto-discovered based on context. Ask about light-token, defi, payments, or program migration and the agent uses the relevant skill automatically. -### `llms-full.txt` + -`llms-full.txt` is the full, expanded index for agents that want complete coverage of the documentation. +## AI Prompts -* View: [`/llms-full.txt`](https://zkcompression.com/llms-full.txt) + ## MCP @@ -175,14 +189,9 @@ mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "your question") You can specify any public GitHub repo that is indexed with DeepWiki. When you connect to the MCP, you specify the repository when calling the tools. Learn more [here](https://docs.devin.ai/work-with-devin/deepwiki-mcp). -
-

Alternative: DeepWiki Web

- - Ask DeepWiki - -
+ -If you don't have the MCP installed we recommend to use AskDevin in your browser. +If you don't have the MCP installed we recommend to use [AskDevin](https://deepwiki.com/Lightprotocol/light-protocol) in your browser. + + + diff --git a/ai-tools/prompts.mdx b/ai-tools/prompts.mdx new file mode 100644 index 00000000..d0fb3581 --- /dev/null +++ b/ai-tools/prompts.mdx @@ -0,0 +1,305 @@ +--- +title: "AI Prompts" +description: "Ready-to-use AI prompts for Light Protocol. Copy a prompt, paste into your AI coding agent, and let it implement the recipe in your project." +--- + +{/* ts-cookbook */} +import TsCreateMint from "/snippets/ai-prompts/ts-cookbook/create-mint.mdx"; +import TsCreateAta from "/snippets/ai-prompts/ts-cookbook/create-ata.mdx"; +import TsMintTo from "/snippets/ai-prompts/ts-cookbook/mint-to.mdx"; +import TsTransferInterface from "/snippets/ai-prompts/ts-cookbook/transfer-interface.mdx"; +import TsApproveRevoke from "/snippets/ai-prompts/ts-cookbook/approve-revoke.mdx"; +import TsWrapUnwrap from "/snippets/ai-prompts/ts-cookbook/wrap-unwrap.mdx"; + +{/* rust-cookbook */} +import RustCreateMint from "/snippets/ai-prompts/rust-cookbook/create-mint.mdx"; +import RustCreateAta from "/snippets/ai-prompts/rust-cookbook/create-ata.mdx"; +import RustCreateTokenAccount from "/snippets/ai-prompts/rust-cookbook/create-token-account.mdx"; +import RustMintTo from "/snippets/ai-prompts/rust-cookbook/mint-to.mdx"; +import RustTransferInterface from "/snippets/ai-prompts/rust-cookbook/transfer-interface.mdx"; +import RustTransferChecked from "/snippets/ai-prompts/rust-cookbook/transfer-checked.mdx"; +import RustApproveRevoke from "/snippets/ai-prompts/rust-cookbook/approve-revoke.mdx"; +import RustFreezeThaw from "/snippets/ai-prompts/rust-cookbook/freeze-thaw.mdx"; +import RustWrapUnwrap from "/snippets/ai-prompts/rust-cookbook/wrap-unwrap.mdx"; +import RustCloseTokenAccount from "/snippets/ai-prompts/rust-cookbook/close-token-account.mdx"; +import RustBurn from "/snippets/ai-prompts/rust-cookbook/burn.mdx"; + +{/* program-cookbook */} +import ProgCreateMintCpi from "/snippets/ai-prompts/program-cookbook/create-mint-cpi.mdx"; +import ProgCreateMintMacros from "/snippets/ai-prompts/program-cookbook/create-mint-macros.mdx"; +import ProgCreateAtaCpi from "/snippets/ai-prompts/program-cookbook/create-ata-cpi.mdx"; +import ProgCreateAtaMacros from "/snippets/ai-prompts/program-cookbook/create-ata-macros.mdx"; +import ProgCreateTokenAccountCpi from "/snippets/ai-prompts/program-cookbook/create-token-account-cpi.mdx"; +import ProgCreateTokenAccountMacros from "/snippets/ai-prompts/program-cookbook/create-token-account-macros.mdx"; +import ProgMintTo from "/snippets/ai-prompts/program-cookbook/mint-to.mdx"; +import ProgTransferInterface from "/snippets/ai-prompts/program-cookbook/transfer-interface.mdx"; +import ProgTransferChecked from "/snippets/ai-prompts/program-cookbook/transfer-checked.mdx"; +import ProgApproveRevoke from "/snippets/ai-prompts/program-cookbook/approve-revoke.mdx"; +import ProgFreezeThaw from "/snippets/ai-prompts/program-cookbook/freeze-thaw.mdx"; +import ProgCloseTokenAccount from "/snippets/ai-prompts/program-cookbook/close-token-account.mdx"; +import ProgBurn from "/snippets/ai-prompts/program-cookbook/burn.mdx"; + +{/* anchor-programs */} +import DefiAnchor from "/snippets/ai-prompts/anchor-programs/defi-anchor.mdx"; +import DefiPinocchio from "/snippets/ai-prompts/anchor-programs/defi-pinocchio.mdx"; +import LightPda from "/snippets/ai-prompts/anchor-programs/light-pda.mdx"; + +{/* cpi-programs */} +import CpiCreate from "/snippets/ai-prompts/cpi-programs/create.mdx"; +import CpiUpdate from "/snippets/ai-prompts/cpi-programs/update.mdx"; +import CpiClose from "/snippets/ai-prompts/cpi-programs/close.mdx"; +import CpiReinitialize from "/snippets/ai-prompts/cpi-programs/reinitialize.mdx"; +import CpiBurn from "/snippets/ai-prompts/cpi-programs/burn.mdx"; +import CpiClientGuide from "/snippets/ai-prompts/cpi-programs/client-guide.mdx"; + +{/* defi - routers */} +import Routers from "/snippets/ai-prompts/defi/routers.mdx"; + +{/* streaming */} +import StreamingMints from "/snippets/ai-prompts/streaming/mints.mdx"; +import StreamingTokens from "/snippets/ai-prompts/streaming/tokens.mdx"; + +{/* toolkits */} +import Payments from "/snippets/ai-prompts/toolkits/payments.mdx"; +import WalletsIntegration from "/snippets/ai-prompts/toolkits/wallets.mdx"; +import Nullifiers from "/snippets/ai-prompts/toolkits/nullifiers.mdx"; +import Airdrop from "/snippets/ai-prompts/toolkits/airdrop.mdx"; + +{/* wallets */} +import Privy from "/snippets/ai-prompts/wallets/privy.mdx"; + +{/* migration */} +import V1ToV2Migration from "/snippets/ai-prompts/v1-to-v2-migration.mdx"; + +## Light Token Recipes + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +## DeFi + + + + + + + + + + + + + +## Data Streaming + + + + + + + + + +## Stablecoin Payments + + + + + + + + + +## Wallets + + + + + + + + + +## Light-PDA + + + + + +## Compressed PDA + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +## Token Distribution + + + + \ No newline at end of file diff --git a/api-reference/json-rpc-methods/methods.mdx b/api-reference/json-rpc-methods/methods.mdx deleted file mode 100644 index 67124992..00000000 --- a/api-reference/json-rpc-methods/methods.mdx +++ /dev/null @@ -1,100 +0,0 @@ ---- -title: JSON RPC Methods -description: Reference to all JSON RPC endpoints for ZK Compression on Solana. -sidebarTitle: "Overview" ---- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
[GetCompressedAccount](/api-reference/json-rpc-methods/getcompressedaccount)Retrieves information about a specific compressed account by its address or hash.
[GetCompressedAccountsByOwner](/api-reference/json-rpc-methods/getcompressedaccountsbyowner)Returns all compressed accounts owned by a specific address.
[GetCompressedBalance](/api-reference/json-rpc-methods/getcompressedbalance)Retrieves the balance of a compressed account.
[GetCompressedBalanceByOwner](/api-reference/json-rpc-methods/getcompressedbalancebyowner)Gets the total balance of all compressed accounts owned by an address.
[GetCompressedMintTokenHolders](/api-reference/json-rpc-methods/getcompressedminttokenholders)Lists all holders of a specific compressed token mint.
[GetCompressedTokenAccountBalance](/api-reference/json-rpc-methods/getcompressedtokenaccountbalance)Retrieves the token balance of a compressed token account.
[GetCompressedTokenAccountsByDelegate](/api-reference/json-rpc-methods/getcompressedtokenaccountbydelegate)Returns all compressed token accounts delegated to a specific address.
[GetCompressedTokenAccountsByOwner](/api-reference/json-rpc-methods/getcompressedtokenaccountsbyowner)Lists all compressed token accounts owned by a specific address.
[GetCompressedTokenBalancesByOwner](/api-reference/json-rpc-methods/getcompressedtokenbalancesbyowner)Retrieves all token balances for compressed accounts owned by an address.
[GetCompressionSignaturesForAccount](/api-reference/json-rpc-methods/getcompressionsignaturesforaccount)Returns signatures for transactions involving a compressed account.
[GetCompressionSignaturesForAddress](/api-reference/json-rpc-methods/getcompressionsignaturesforaddress)Retrieves signatures for transactions involving a specific address.
[GetCompressionSignaturesForOwner](/api-reference/json-rpc-methods/getcompressionsignaturesforowner)Returns signatures for transactions where an address is the owner.
[GetCompressionSignaturesForTokenOwner](/api-reference/json-rpc-methods/getcompressionsignaturesfortokenowner)Lists signatures for transactions involving tokens owned by an address.
[GetIndexerHealth](/api-reference/json-rpc-methods/getindexerhealth)Returns the health status of the compression indexer.
[GetIndexerSlot](/api-reference/json-rpc-methods/getindexerslot)Retrieves the current slot of the compression indexer.
[GetLatestCompressionSignatures](/api-reference/json-rpc-methods/getlatestcompressionsignatures)Returns the most recent transaction signatures related to compression.
[GetLatestNon-VotingSignatures](/api-reference/json-rpc-methods/getlatestnonvotingsignatures)Retrieves recent non-voting transaction signatures.
[GetMultipleCompressedAccounts](/api-reference/json-rpc-methods/getmultiplecompressedaccounts)Retrieves multiple compressed accounts in a single request.
[GetMultipleNewAddressProofs](/api-reference/json-rpc-methods/getmultiplenewaddressproofs)Returns proofs that the new addresses are not taken already and can be created.
[GetTransactionWithCompressionInfo](/api-reference/json-rpc-methods/gettransactionwithcompressioninfo)Returns transaction details with additional compression-related information.
[GetValidityProof](/api-reference/json-rpc-methods/getvalidityproof)Retrieves a validity proof for compressed data.
diff --git a/api-reference/json-rpc-methods/overview.mdx b/api-reference/json-rpc-methods/overview.mdx index 288dab49..36dd8570 100644 --- a/api-reference/json-rpc-methods/overview.mdx +++ b/api-reference/json-rpc-methods/overview.mdx @@ -1,27 +1,31 @@ --- title: JSON RPC Methods -description: Overview JSON RPC endpoints on Solana, best practices, and error codes. +description: Photon indexer methods for querying compressed state on Solana. sidebarTitle: "Overview" --- -The API exposed by the indexer closely mirrors existing RPC calls, with one-to-one mapping: + +The Light Token SDK calls these methods internally via interface functions +like `transferInterface` and `getAtaInterface`. You rarely need to call +them directly. -| Solana RPC | Photon RPC Calls | -| :---------------------- | :------------------------------- | +Call these methods directly if you are building a block explorer, +custom indexer, or working with +[legacy compressed tokens](/compressed-tokens/overview). + + +| Solana RPC | Photon RPC | +| :---------------------- | :-------------------------------- | | getAccountInfo | getCompressedAccount | -| getBalance | getCompressedBalance | -| getTokenAccountsByOwner | getCompressedTokenAccountsByOwner | -| getProgramAccounts | getCompressedAccountsByOwner | +| getBalance | getCompressedBalanceByOwner | +| getAccountInfo | getCompressedTokenAccountsByOwner | +| getTokenAccountBalance | getCompressedTokenBalancesByOwner | +| getSignaturesForAddress | getCompressionSignaturesForAddress| +| getSignaturesForAddress | getCompressionSignaturesForOwner | + - -## Create an RPC Connection +## Create an RPC connection @@ -29,7 +33,7 @@ The API exposed by the indexer closely mirrors existing RPC calls, with one-to-o // Helius exposes Solana and Photon RPC endpoints through a single URL import { createRpc, Rpc } from '@lightprotocol/stateless.js'; -const RPC_ENDPOINT = ''; +const RPC_ENDPOINT = 'https://mainnet.helius-rpc.com?api-key=YOUR_KEY'; const connection: Rpc = createRpc(RPC_ENDPOINT, RPC_ENDPOINT); ``` @@ -45,41 +49,138 @@ const connection: Rpc = createRpc(RPC_ENDPOINT, RPC_ENDPOINT); -## Best Practices - -| Best Practice | Description | -|:----------------------|:----------------------------------------------------------------------------------------------------------------| -| **Commitment Levels**| Use appropriate commitment levels: `processed` (fastest), `confirmed` (balanced), `finalized` (most reliable) | -| **Rate Limiting** | Implement retry logic and respect rate limits. Public endpoints: 100 req/s, Private: 1000+ req/s | -| **Batch Requests** | Use batch requests when possible to improve efficiency and reduce API calls | -| **Caching** | Cache frequently accessed data to reduce API calls and improve performance | +## Best practices -## Error Codes +| Best practice | Description | +|:-----------------------|:---------------------------------------------------------------------------------------------------------------| +| **Commitment levels** | Use appropriate commitment levels: `processed` (fastest), `confirmed` (balanced), `finalized` (most reliable). | +| **Rate limiting** | Implement retry logic and respect rate limits. Public endpoints: 100 req/s, Private: 1000+ req/s. | +| **Batch requests** | Use batch requests when possible to reduce API calls. | +| **Caching** | Cache frequently accessed data to reduce API calls. | - -
- For help with debugging use - - Ask DeepWiki - -
- +## Error codes | Code | Message | Description | -| :------ | :-------------------- | :-------------------------------------------- | -| -32600 | Invalid Request | The JSON sent is not a valid Request object | -| -32601 | Method not found | The method does not exist / is not available | -| -32602 | Invalid params | Invalid method parameter(s) | -| -32603 | Internal error | Internal JSON-RPC error | -| -32000 | Account not found | The compressed account was not found | -| -32001 | Invalid account hash | The provided account hash is invalid | - -# Next Steps - - +| :----- | :------------------- | :------------------------------------------- | +| -32600 | Invalid Request | The JSON sent is not a valid Request object. | +| -32601 | Method not found | The method does not exist / is not available. | +| -32602 | Invalid params | Invalid method parameter(s). | +| -32603 | Internal error | Internal JSON-RPC error. | +| -32000 | Account not found | The compressed account was not found. | +| -32001 | Invalid account hash | The provided account hash is invalid. | + +## Methods + +These methods are called internally by the Light Token SDK. Call them +directly for custom indexing, block explorers, or debugging. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
[GetCompressedAccount](/api-reference/json-rpc-methods/getcompressedaccount)Returns a compressed account by address or hash.
[GetCompressedAccountsByOwner](/api-reference/json-rpc-methods/getcompressedaccountsbyowner)Returns all compressed accounts for an owner.
[GetCompressedBalanceByOwner](/api-reference/json-rpc-methods/getcompressedbalancebyowner)Returns the total compressed balance for an owner.
[GetCompressedTokenAccountsByOwner](/api-reference/json-rpc-methods/getcompressedtokenaccountsbyowner)Returns all compressed token accounts for an owner.
[GetCompressedTokenBalancesByOwner](/api-reference/json-rpc-methods/getcompressedtokenbalancesbyowner)Returns all token balances for compressed accounts owned by an address.
[GetValidityProof](/api-reference/json-rpc-methods/getvalidityproof)Returns a validity proof for compressed state transitions.
[GetCompressionSignaturesForAddress](/api-reference/json-rpc-methods/getcompressionsignaturesforaddress)Returns signatures for transactions involving an address.
[GetCompressionSignaturesForOwner](/api-reference/json-rpc-methods/getcompressionsignaturesforowner)Returns signatures for transactions where an address is the owner.
[GetTransactionWithCompressionInfo](/api-reference/json-rpc-methods/gettransactionwithcompressioninfo)Returns transaction details with compression context.
[GetIndexerHealth](/api-reference/json-rpc-methods/getindexerhealth)Returns the health status of the Photon indexer.
[GetIndexerSlot](/api-reference/json-rpc-methods/getindexerslot)Returns the current slot of the Photon indexer.
+ +## Legacy + +Methods for direct compressed-token workflows. Not called by the Light +Token SDK interface functions. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
[GetCompressedBalance](/api-reference/json-rpc-methods/getcompressedbalance)Returns the balance of a single compressed account.
[GetCompressedMintTokenHolders](/api-reference/json-rpc-methods/getcompressedminttokenholders)Lists all holders of a compressed token mint.
[GetCompressedTokenAccountBalance](/api-reference/json-rpc-methods/getcompressedtokenaccountbalance)Returns the token balance of a single compressed token account.
[GetCompressedTokenAccountsByDelegate](/api-reference/json-rpc-methods/getcompressedtokenaccountbydelegate)Returns all compressed token accounts delegated to an address.
[GetCompressionSignaturesForAccount](/api-reference/json-rpc-methods/getcompressionsignaturesforaccount)Returns signatures for transactions involving a compressed account.
[GetCompressionSignaturesForTokenOwner](/api-reference/json-rpc-methods/getcompressionsignaturesfortokenowner)Returns signatures for token transactions by owner.
[GetLatestCompressionSignatures](/api-reference/json-rpc-methods/getlatestcompressionsignatures)Returns the most recent compression-related signatures.
[GetLatestNonVotingSignatures](/api-reference/json-rpc-methods/getlatestnonvotingsignatures)Returns recent non-voting transaction signatures.
[GetMultipleCompressedAccounts](/api-reference/json-rpc-methods/getmultiplecompressedaccounts)Returns multiple compressed accounts in a single request.
[GetMultipleNewAddressProofs](/api-reference/json-rpc-methods/getmultiplenewaddressproofs)Returns proofs that new addresses can be created.
\ No newline at end of file diff --git a/api-reference/sdk.mdx b/api-reference/sdk.mdx new file mode 100644 index 00000000..488d0888 --- /dev/null +++ b/api-reference/sdk.mdx @@ -0,0 +1,8 @@ +--- +title: SDK Reference +description: Client and program SDKs for Light Token and ZK Compression. +--- + +import SdkReference from "/snippets/overview-tables/sdk-reference.mdx"; + + \ No newline at end of file diff --git a/ask.skill b/ask.skill new file mode 100644 index 00000000..749b8227 Binary files /dev/null and b/ask.skill differ diff --git a/compressed-pdas/program-examples.mdx b/compressed-pdas/program-examples.mdx deleted file mode 100644 index 7e14d3d8..00000000 --- a/compressed-pdas/program-examples.mdx +++ /dev/null @@ -1,66 +0,0 @@ ---- -title: Program Examples -description: Program example repository for compressed accounts with tests. ---- - -## Basic Operations - -* [**basic-operations/anchor**](https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor) - Anchor program with Rust and TypeScript tests -* [**basic-operations/native**](https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/native) - Native Solana program with `light-sdk` and Rust tests. - - -Basic Operations include: -- **create** - Initialize a new compressed account -- **update** - Modify data of an existing compressed account -- **close** - Close a compressed account (it can be initialized again). -- **reinit** - Reinitialize a closed account -- **burn** - Permanently delete a compressed account (it cannot be initialized again). - - -## Counter Program - -Full compressed account lifecycle (create, increment, decrement, reset, close): - -* [**counter/anchor**](https://github.com/Lightprotocol/program-examples/tree/main/counter/anchor) - Anchor program with Rust and TypeScript tests -* [**counter/native**](https://github.com/Lightprotocol/program-examples/tree/main/counter/native) - Native Solana program with `light-sdk` and Rust tests. -* [**counter/pinocchio**](https://github.com/Lightprotocol/program-examples/tree/main/counter/pinocchio) - Pinocchio program with `light-sdk-pinocchio` and Rust tests. - -## Create-and-update Program - -* [**create-and-update**](https://github.com/Lightprotocol/program-examples/tree/main/create-and-update) - Create a new compressed account and update an existing compressed account with a single validity proof in one instruction. - -## Create-and-read Program - -* [**read-only**](https://github.com/Lightprotocol/program-examples/tree/main/read-only) - Create a new compressed account and read it on-chain. - -## Compare Programs with Solana and Compressed Accounts - -* [**account-comparison**](https://github.com/Lightprotocol/program-examples/tree/main/account-comparison) - Compare compressed vs regular Solana accounts. - -## Nullifier Program - -* [**nullifier-program**](https://github.com/Lightprotocol/nullifier-program) - For some use cases, such as sending payments, you might want to prevent your onchain instruction from being executed more than once. Creates a rent-free PDA derived from an id. If the id has been used before, the PDA already exists, causing the instruction to fail. - -## Token Claim Reference Implementations - -* **Basic**: [**simple-claim**](https://github.com/Lightprotocol/program-examples-airdrop-implementations/simple-claim) - Distributes compressed tokens that get decompressed to SPL on claim. -* **Advanced**: [**merkle-distributor**](https://github.com/Lightprotocol/distributor) - Distributes SPL tokens, uses compressed PDAs to track claims with linear vesting, partial claims, clawback and admin controls. - - -For simple client side distribution visit [this example](https://github.com/Lightprotocol/example-token-distribution). - - -## ZK-ID Program - -* [**zk-id**](https://github.com/Lightprotocol/program-examples/tree/main/zk-id) - A minimal Solana program that uses zero-knowledge proofs for identity verification with compressed accounts. - - -# Next Steps - - \ No newline at end of file diff --git a/compressed-tokens/advanced-guides.mdx b/compressed-tokens/advanced-guides.mdx deleted file mode 100644 index 94066669..00000000 --- a/compressed-tokens/advanced-guides.mdx +++ /dev/null @@ -1,9 +0,0 @@ ---- -title: Advanced Guides -description: "Reference table to advanced guides. Includes guides for airdrops, using token-2022, wallet support for compressed tokens, and client examples." -sidebarTitle: "Overview" ---- - -import AdvancedGuidesTable from '/snippets/overview-tables/compressed-tokens-advanced-guides-table.mdx'; - - diff --git a/compressed-tokens/advanced-guides/add-wallet-support-for-compressed-tokens.mdx b/compressed-tokens/advanced-guides/add-wallet-support-for-compressed-tokens.mdx deleted file mode 100644 index 8f7c9112..00000000 --- a/compressed-tokens/advanced-guides/add-wallet-support-for-compressed-tokens.mdx +++ /dev/null @@ -1,640 +0,0 @@ ---- -title: Add Wallet Support for Compressed Tokens -description: Guide to add Compressed Token Support to Your Wallet Application -keywords: ["wallet integration compressed tokens", "wallet infrastructure on solana"] ---- - -import InstallDependencies from '/snippets/setup/install-dependencies-codegroup.mdx'; -import SetupEnvironment from '/snippets/setup/setup-environment-tabs.mdx'; - - -Leading Solana Wallets like Phantom and Backpack already support compressed tokens. - - -# Integration Steps - - - - -### Display Compressed Token Balances - -```javascript -import { Rpc, createRpc } from '@lightprotocol/stateless.js'; -import { PublicKey } from '@solana/web3.js'; - -const connection: Rpc = createRpc(); -const publicKey = new PublicKey('FWwR2s4TwpWN3nkCzVfhuPrpePG8kNzBXAxEbNsaDFNu'); - -(async () => { - const balances = await connection.getCompressedTokenBalancesByOwnerV2(publicKey); - - if (balances.value.items.length === 0) { - console.log("No compressed token balances found"); - return; - } - - for (const item of balances.value.items) { - const balanceValue = typeof item.balance === 'string' - ? parseInt(item.balance, 16) - : item.balance; - - const mintInfo = await connection.getAccountInfo(new PublicKey(item.mint)); - const decimals = mintInfo.data[44]; - const formattedBalance = balanceValue / Math.pow(10, decimals); - - console.log(`Mint: ${item.mint}`); - console.log(`Balance: ${formattedBalance} tokens\n`); - } -})(); -``` - -### Get Transaction History - -```typescript -import { Rpc, createRpc } from '@lightprotocol/stateless.js'; -import { PublicKey } from '@solana/web3.js'; - -const connection: Rpc = createRpc(); -const publicKey = new PublicKey('FWwR2s4TwpWN3nkCzVfhuPrpePG8kNzBXAxEbNsaDFNu'); - -(async () => { - const signatures = await connection.getCompressionSignaturesForTokenOwner(publicKey); - - if (signatures.items.length > 0) { - console.log(`Signatures:`); - signatures.items.forEach((sig, index) => { - console.log(`${index + 1}. ${sig.signature}`); - console.log(` Slot: ${sig.slot}`); - console.log(` Time: ${new Date(sig.blockTime * 1000).toISOString()}`); - }); - } else { - console.log("No transactions found"); - } -})(); -``` - - - -```typescript -import { Rpc, createRpc } from '@lightprotocol/stateless.js'; -import { PublicKey } from '@solana/web3.js'; - -const RPC_ENDPOINT = process.env.RPC_ENDPOINT || 'https://devnet.helius-rpc.com?api-key='; - -const connection: Rpc = createRpc(RPC_ENDPOINT, RPC_ENDPOINT); -const publicKey = new PublicKey('FWwR2s4TwpWN3nkCzVfhuPrpePG8kNzBXAxEbNsaDFNu'); - -(async () => { - try { - const signatures = await connection.getCompressionSignaturesForTokenOwner(publicKey); - - if (signatures.items.length === 0) { - console.log("No transactions found"); - return; - } - - console.log(`Latest Transaction:`); - console.log(`Signature: ${signatures.items[0].signature}`); - console.log(`Slot: ${signatures.items[0].slot}`); - - const txInfo = await connection.getTransactionWithCompressionInfo(signatures.items[0].signature); - - if (!txInfo) { - console.log('Transaction not found or has no compression info'); - return; - } - - if (txInfo.compressionInfo) { - console.log(`\nClosed Accounts: ${txInfo.compressionInfo.closedAccounts.length}`); - console.log(`Opened Accounts: ${txInfo.compressionInfo.openedAccounts.length}`); - } - } catch (error) { - console.error('Error fetching transaction history:', error); - } -})(); -``` - - - -### Send Compressed Tokens - -```typescript expandable -import { - Rpc, - createRpc, - bn, - dedupeSigner, - sendAndConfirmTx, - buildAndSignTx, -} from "@lightprotocol/stateless.js"; -import { - LightTokenProgram, - selectMinCompressedTokenAccountsForTransfer, -} from "@lightprotocol/compressed-token"; -import { ComputeBudgetProgram, Keypair, PublicKey } from "@solana/web3.js"; - -const connection: Rpc = createRpc(); -const mint = new PublicKey("MINT_ADDRESS"); -const payer = PAYER_KEYPAIR; -const owner = payer; -const recipient = Keypair.generate(); -const amount = bn(1e8); - -(async () => { - const compressedTokenAccounts = - await connection.getCompressedTokenAccountsByOwner(owner.publicKey, { mint }); - - if (compressedTokenAccounts.items.length === 0) { - console.log("No compressed token accounts found"); - return; - } - - const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer( - compressedTokenAccounts.items, - amount - ); - - const proof = await connection.getValidityProof( - inputAccounts.map((account) => account.compressedAccount.hash) - ); - - const ix = await LightTokenProgram.transfer({ - payer: payer.publicKey, - inputCompressedTokenAccounts: inputAccounts, - toAddress: recipient.publicKey, - amount, - recentInputStateRootIndices: proof.rootIndices, - recentValidityProof: proof.compressedProof, - }); - - const { blockhash } = await connection.getLatestBlockhash(); - const additionalSigners = dedupeSigner(payer, [owner]); - const signedTx = buildAndSignTx( - [ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 }), ix], - payer, - blockhash, - additionalSigners - ); - - const transferTxId = await sendAndConfirmTx(connection, signedTx); - console.log(`Transaction: ${transferTxId}`); -})(); -``` - - - - - -### Prerequisites - -Make sure you have dependencies and developer environment set up! - - - -**Dependencies** - - - -**Developer Environment** - - - - - - -### Display Compressed Token Balances - -This example fetches and displays all compressed token balances for a wallet address. - -```javascript -import { Rpc, createRpc } from '@lightprotocol/stateless.js'; -import { Keypair, PublicKey } from '@solana/web3.js'; -import * as fs from 'fs'; -import * as os from 'os'; - -const connection: Rpc = createRpc(); - -const walletPath = `${os.homedir()}/.config/solana/id.json`; -const secretKey = JSON.parse(fs.readFileSync(walletPath, 'utf8')); -const payer = Keypair.fromSecretKey(Buffer.from(secretKey)); - -(async () => { - const balances = await connection.getCompressedTokenBalancesByOwnerV2(payer.publicKey); - - if (balances.value.items.length === 0) { - console.log("No compressed token balances found"); - return; - } - - for (const item of balances.value.items) { - const balanceValue = typeof item.balance === 'string' - ? parseInt(item.balance, 16) - : item.balance; - - const mintInfo = await connection.getAccountInfo(new PublicKey(item.mint)); - const decimals = mintInfo.data[44]; - const formattedBalance = balanceValue / Math.pow(10, decimals); - - console.log(`Mint: ${item.mint}`); - console.log(`Balance: ${formattedBalance} tokens\n`); - } -})(); -``` - - - -### Get Transaction History - -This example retrieves compression transaction signatures to display transaction history of the wallet. - -```javascript -import { Rpc, createRpc } from '@lightprotocol/stateless.js'; -import { Keypair } from '@solana/web3.js'; -import * as fs from 'fs'; -import * as os from 'os'; - -const connection: Rpc = createRpc(); - -const walletPath = `${os.homedir()}/.config/solana/id.json`; -const secretKey = JSON.parse(fs.readFileSync(walletPath, 'utf8')); -const payer = Keypair.fromSecretKey(Buffer.from(secretKey)); - -(async () => { - const signatures = await connection.getCompressionSignaturesForTokenOwner(payer.publicKey); - - if (signatures.items.length > 0) { - console.log(`Signatures:`); - signatures.items.forEach((sig, index) => { - console.log(`${index + 1}. ${sig.signature}`); - console.log(` Slot: ${sig.slot}`); - console.log(` Time: ${new Date(sig.blockTime * 1000).toISOString()}`); - }); - } else { - console.log("No transactions found"); - } -})(); -``` - - - -### Send Compressed Tokens - -First, set up a test mint to and mint 10 compressed tokens to your filesystem wallet. - - - -```typescript -import { Keypair } from "@solana/web3.js"; -import { Rpc, confirmTx, createRpc } from '@lightprotocol/stateless.js'; -import { createMint, mintTo } from '@lightprotocol/compressed-token'; -import * as fs from 'fs'; -import * as os from 'os'; - -// 1. Setup RPC connection and load filesystem wallet for mint operations -// 2. Call createMint() to create SPL mint with SPL interface for compression -// 3. Call mintTo() to mint compressed tokens to filesystem wallet - -const connection: Rpc = createRpc(); // defaults to localhost:8899 - -// Load wallet from filesystem -const walletPath = `${os.homedir()}/.config/solana/id.json`; -const secretKey = JSON.parse(fs.readFileSync(walletPath, 'utf8')); -const payer = Keypair.fromSecretKey(Buffer.from(secretKey)); -const mintKeypair = Keypair.generate(); - -(async() => { - // Fund payer with SOL - await connection.requestAirdrop(payer.publicKey, 1e9); - await new Promise(resolve => setTimeout(resolve, 1000)); - - // Create SPL mint with SPL interface for compression - const { mint, transactionSignature } = await createMint( - connection, - payer, - payer.publicKey, // mint authority - 9, - mintKeypair, - ); - console.log(`Mint address: ${mint.toString()}`); - console.log(`Transaction: ${transactionSignature}`); - - // Mint compressed tokens to payer - const mintToTxId = await mintTo( - connection, - payer, - mint, // SPL mint with SPL interface for compression - payer.publicKey, // recipient address - payer, - 10e9, - ); - - console.log(`\nMinted ${10e9 / 1e9} compressed token`); - console.log(`Transaction: ${mintToTxId}`); -})(); -``` - - - - -Make sure you add your Mint address to `send-tokens.ts`. - - -```typescript send-tokens.ts expandable -// Compressed Token Transfer - Local -// 1. Load wallet and fetch compressed token accounts with getCompressedTokenAccountsByOwner() -// 2. Select accounts for transfer using selectMinCompressedTokenAccountsForTransfer() -// and get validity proof with getValidityProof() -// 3. Create transfer instruction with LightTokenProgram.transfer() -// and submit transaction with sendAndConfirmTx() -// 4. Verify balances via getCompressedTokenAccountsByOwner() - -import { - Rpc, - createRpc, - bn, - dedupeSigner, - sendAndConfirmTx, - buildAndSignTx, -} from "@lightprotocol/stateless.js"; -import { - LightTokenProgram, - selectMinCompressedTokenAccountsForTransfer, -} from "@lightprotocol/compressed-token"; -import { ComputeBudgetProgram, Keypair, PublicKey } from "@solana/web3.js"; -import * as fs from 'fs'; -import * as os from 'os'; - -// Step 1: Setup RPC connection and define transfer parameters -const connection: Rpc = createRpc(); // defaults to localhost:8899 -const mint = new PublicKey("MINT ADDRESS"); // Replace with mint address - -// Load wallet from filesystem -const walletPath = `${os.homedir()}/.config/solana/id.json`; -const secretKey = JSON.parse(fs.readFileSync(walletPath, 'utf8')); -const payer = Keypair.fromSecretKey(Buffer.from(secretKey)); -const owner = payer; - -const recipient = Keypair.generate(); -const amount = bn(1e8); - -(async () => { - // Step 2: Fetch compressed account hashes from state trees - const compressedTokenAccounts = - await connection.getCompressedTokenAccountsByOwner(owner.publicKey, { - mint, // SPL mint with SPL interface for compression - }); - - if (compressedTokenAccounts.items.length === 0) { - console.log("No compressed token accounts found for this mint"); - return; - } - - // Show initial sender balance - const initialBalance = compressedTokenAccounts.items.reduce((sum, account) => sum + Number(account.parsed.amount), 0); - console.log(`Sender balance: ${initialBalance / 1e8} compressed tokens`); - - // Step 3: Select minimum compressed accounts for transfer amount - const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer( - compressedTokenAccounts.items, - amount - ); - - // Get validity proof for Merkle tree verification - const proof = await connection.getValidityProof( - inputAccounts.map((account) => account.compressedAccount.hash) - ); - - // Step 4: Create transfer instruction that consumes input accounts and creates new output accounts - const ix = await LightTokenProgram.transfer({ - payer: payer.publicKey, - inputCompressedTokenAccounts: inputAccounts, // accounts to consume - toAddress: recipient.publicKey, - amount, - recentInputStateRootIndices: proof.rootIndices, - recentValidityProof: proof.compressedProof, - }); - - // Step 5: Build, sign, and submit transaction - const { blockhash } = await connection.getLatestBlockhash(); - const additionalSigners = dedupeSigner(payer, [owner]); - const signedTx = buildAndSignTx( - [ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 }), ix], - payer, - blockhash, - additionalSigners - ); - const transferTxId = await sendAndConfirmTx(connection, signedTx); - - console.log(`\nTransferred ${amount.toNumber() / 1e8} compressed tokens`); - console.log(`Transaction: ${transferTxId}`); - console.log(`Recipient: ${recipient.publicKey.toString()}`); - - // Step 6: Verify via getCompressedTokenAccountsByOwner - const senderCompressedAccounts = await connection.getCompressedTokenAccountsByOwner(payer.publicKey, { mint }); - const senderBalance = senderCompressedAccounts.items.reduce((sum, account) => sum + Number(account.parsed.amount), 0); - - const recipientCompressedAccounts = await connection.getCompressedTokenAccountsByOwner(recipient.publicKey, { mint }); - const recipientBalance = recipientCompressedAccounts.items.reduce((sum, account) => sum + Number(account.parsed.amount), 0); - - console.log(`\nSummary compressed token balances:`); - console.log(`Sender balance: ${senderBalance / 1e8} compressed tokens`); - console.log(`Recipient balance: ${recipientBalance / 1e8} compressed token`); - - return transferTxId; -})(); -``` - - - - - -# Advanced Integrations - -Use these integrations to let users convert between regular and compressed format as needed. - - - -This example converts compressed tokens to regular SPL format using `LightTokenProgram.decompress().` - -```javascript -import { - bn, - buildAndSignTx, - sendAndConfirmTx, - dedupeSigner, - Rpc, - createRpc, -} from "@lightprotocol/stateless.js"; -import { ComputeBudgetProgram } from "@solana/web3.js"; -import { - LightTokenProgram, - getTokenPoolInfos, - selectMinCompressedTokenAccountsForTransfer, - selectTokenPoolInfosForDecompression, -} from "@lightprotocol/compressed-token"; - -// 1. Setup RPC connection and fetch compressed token accounts with getCompressedTokenAccountsByOwner() -// 2. Select accounts and SPL interface infos using selectMinCompressedTokenAccountsForTransfer() and selectTokenPoolInfosForDecompression() -// 3. Create decompress instruction with LightTokenProgram.decompress() and submit transaction - -// Step 1: Setup RPC connection and define decompression parameters -const connection: Rpc = createRpc("https://mainnet.helius-rpc.com?api-key=";); -const payer = PAYER_KEYPAIR; -const owner = PAYER_KEYPAIR; -const mint = MINT_ADDRESS; -const amount = 1e5; // 100K tokens to decompress - -(async () => { - // 1. Fetch compressed token accounts - const compressedTokenAccounts = - await connection.getCompressedTokenAccountsByOwner(owner.publicKey, { - mint, - }); - - // 2. Select - const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer( - compressedTokenAccounts.items, - bn(amount) - ); - - // 3. Fetch validity proof - const proof = await connection.getValidityProof( - inputAccounts.map((account) => account.compressedAccount.hash) - ); - - // 4. Fetch & Select tokenPoolInfos - const tokenPoolInfos = await getTokenPoolInfos(connection, mint); - const selectedTokenPoolInfos = selectTokenPoolInfosForDecompression( - tokenPoolInfos, - amount - ); - - // 5. Build instruction - const ix = await LightTokenProgram.decompress({ - payer: payer.publicKey, - inputCompressedTokenAccounts: inputAccounts, - toAddress: owner.publicKey, - amount, - tokenPoolInfos: selectedTokenPoolInfos, - recentInputStateRootIndices: proof.rootIndices, - recentValidityProof: proof.compressedProof, - }); - - - // 6. Sign, send, and confirm. - // Example with keypair: - const { blockhash } = await connection.getLatestBlockhash(); - const additionalSigners = dedupeSigner(payer, [owner]); - const signedTx = buildAndSignTx( - [ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 }), ix], - payer, - blockhash, - additionalSigners - ); - - return await sendAndConfirmTx(connection, signedTx); -})(); -``` - - - - - -This example converts regular SPL tokens to compressed format using `LightTokenProgram.compress().` - -```typescript -// 1. Setup RPC connection and get user ATA with getOrCreateAssociatedTokenAccount() -// 2. Fetch state tree and SPL interface infos using getStateTreeInfos() and getTokenPoolInfos() -// 3. Create compress instruction with LightTokenProgram.compress() and submit transaction - - -import { - buildAndSignTx, - sendAndConfirmTx, - Rpc, - createRpc, - selectStateTreeInfo, -} from "@lightprotocol/stateless.js"; -import { ComputeBudgetProgram } from "@solana/web3.js"; -import { - LightTokenProgram, - getTokenPoolInfos, - selectTokenPoolInfo, -} from "@lightprotocol/compressed-token"; -import { getOrCreateAssociatedTokenAccount } from "@solana/spl-token"; - -// Step 1: Setup RPC connection and define compression parameters -const connection: Rpc = createRpc( - "https://mainnet.helius-rpc.com?api-key=" -); - const payer = ; - const mint = ; -const amount = 1e5; // 100K tokens to compress - -(async () => { - // Step 2: Get or create associated token account for SPL tokens - const sourceTokenAccount = await getOrCreateAssociatedTokenAccount( - connection, - payer, // fee payer - mint, // token mint address - payer.publicKey // token account owner - ); - - // Step 3: Fetch and select state tree info for compression - const treeInfos = await connection.getStateTreeInfos(); - const treeInfo = selectStateTreeInfo(treeInfos); - - // Step 4: Fetch and select SPL interface info for compression - const tokenPoolInfos = await getTokenPoolInfos(connection, mint); - const tokenPoolInfo = selectTokenPoolInfo(tokenPoolInfos); - - // Step 5: Create compress instruction - transfer SPL tokens to pool and create compressed accounts - const compressInstruction = await LightTokenProgram.compress({ - payer: payer.publicKey, // fee payer - owner: payer.publicKey, // owner of source SPL tokens - source: sourceTokenAccount.address, // source ATA address - toAddress: payer.publicKey, // recipient of compressed tokens (self) - amount, // amount to compress - mint, // token mint address - outputStateTreeInfo: treeInfo, // state tree for compressed accounts - tokenPoolInfo, - }); - - // Step 6: Build, sign, and submit compression transaction - const { blockhash } = await connection.getLatestBlockhash(); - const tx = buildAndSignTx( - [ - ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 }), - compressInstruction, - ], - payer, // transaction signer - blockhash, - [payer] // additional signers - ); - await sendAndConfirmTx(connection, tx); -})(); -``` - - - -# Common Errors - - - -If `getCompressedTokenBalancesByOwnerV2` returns empty: - -* Ensure the wallet has compressed tokens (not regular SPL tokens) -* Verify you're on the correct network (devnet/mainnet) - - - -# Next Steps - - - diff --git a/compressed-tokens/advanced-guides/example-token-distribution.mdx b/compressed-tokens/advanced-guides/example-token-distribution.mdx deleted file mode 100644 index b034f615..00000000 --- a/compressed-tokens/advanced-guides/example-token-distribution.mdx +++ /dev/null @@ -1,8 +0,0 @@ ---- -title: "Example Token Distribution" -description: "Reference implementations for airdrops, payments, and rewards with ZK Compression" -url: "https://github.com/Lightprotocol/example-token-distribution" -keywords: ["scalable token distribution on solana", "infrastructure for token distribution", "mass token distribution", "reward distribution for depins", "depin infrastructure on solana"] ---- - -View the full example on GitHub: [example-token-distribution](https://github.com/Lightprotocol/example-token-distribution) diff --git a/compressed-tokens/advanced-guides/how-to-combine-operations-in-one-transaction.mdx b/compressed-tokens/advanced-guides/how-to-combine-operations-in-one-transaction.mdx deleted file mode 100644 index 26fc80a6..00000000 --- a/compressed-tokens/advanced-guides/how-to-combine-operations-in-one-transaction.mdx +++ /dev/null @@ -1,198 +0,0 @@ ---- -title: Combine Instructions in One Transaction -description: Combine multiple instructions in one transaction. Full example: create SPL Interface PDA and first-time compression of existing SPL tokens. -keywords: ["batch token operations solana", "combine transactions solana"] ---- - -import InstallDependencies from '/snippets/setup/install-dependencies-codegroup.mdx'; -import SetupEnvironment from '/snippets/setup/setup-environment-tabs.mdx'; - -The SDK provides instruction-level APIs that return instructions without sending transactions. Combine these instructions to build custom transactions with multiple instructions. - -This guide demonstrates creating an SPL interface and compressing existing SPL tokens in a single transaction. - -# Full Code Example - - - -### Prerequisites - -Make sure you have dependencies and developer environment set up! - - - -**Dependencies** - - - -**Developer Environment** - - - - - - -### Create SPL interface + compress - -```typescript create-pool-and-compress.ts highlight={26,71} expandable -// 1. Setup: Create regular SPL token and mint to ATA -// 2. Build instructions for SPL interface and compress -// 3. Combine instructions in one transaction -// 4. Verify compressed balance - -import { - Keypair, - ComputeBudgetProgram, -} from '@solana/web3.js'; -import { - createRpc, - buildAndSignTx, - sendAndConfirmTx, - selectStateTreeInfo, -} from '@lightprotocol/stateless.js'; -import { LightTokenProgram } from '@lightprotocol/compressed-token'; -import { - createMint, - getOrCreateAssociatedTokenAccount, - mintTo, - TOKEN_PROGRAM_ID, -} from '@solana/spl-token'; -import BN from 'bn.js'; - -async function createPoolAndCompress() { - // Step 1: Setup - Create regular SPL token and mint to ATA - const rpc = createRpc(); - const payer = Keypair.generate(); - const airdropSignature = await rpc.requestAirdrop(payer.publicKey, 1000000000); - await rpc.confirmTransaction(airdropSignature); - - // Create regular SPL token mint - const mint = await createMint( - rpc, - payer, - payer.publicKey, - null, - 9, - undefined, - undefined, - TOKEN_PROGRAM_ID - ); - - // Create ATA and mint tokens to it - const ata = await getOrCreateAssociatedTokenAccount( - rpc, - payer, - mint, - payer.publicKey, - undefined, - undefined, - undefined, - TOKEN_PROGRAM_ID - ); - - await mintTo( - rpc, - payer, - mint, - ata.address, - payer, - 1_000_000_000, // 1 token with 9 decimals - undefined, - undefined, - TOKEN_PROGRAM_ID - ); - - console.log("Regular SPL token created:", mint.toBase58()); - console.log("ATA balance:", 1, "token"); - - // Step 2: Build instructions for SPL interface and compress - const outputStateTreeInfo = selectStateTreeInfo(await rpc.getStateTreeInfos()); - - // Derive SPL Interface PDA - const tokenPoolPda = LightTokenProgram.deriveTokenPoolPda(mint); - - // Create SPL interface instruction - const createSplInterfaceIx = await LightTokenProgram.createSplInterface({ - feePayer: payer.publicKey, - mint, - tokenProgramId: TOKEN_PROGRAM_ID, - }); - - // Manually construct TokenPoolInfo for first-time compression (SPL interface not yet on-chain) - const tokenPoolInfo = { - mint: mint, - tokenPoolPda: tokenPoolPda, - tokenProgram: TOKEN_PROGRAM_ID, - isInitialized: true, // Set to true even though pool will be created in this tx - balance: new BN(0), - poolIndex: 0, - bump: 0, // Placeholder value - }; - - // Create compress instruction - const compressIx = await LightTokenProgram.compress({ - outputStateTreeInfo, - tokenPoolInfo, - payer: payer.publicKey, - owner: payer.publicKey, - source: ata.address, - toAddress: payer.publicKey, - amount: new BN(1_000_000_000), - mint, - }); - - // Step 3: Combine instructions in one transaction - const { blockhash } = await rpc.getLatestBlockhash(); - - const allInstructions = [ - ComputeBudgetProgram.setComputeUnitLimit({ units: 1_000_000 }), - createSplInterfaceIx, - compressIx, - ]; - - const tx = buildAndSignTx( - allInstructions, - payer, - blockhash, - [] - ); - - const txId = await sendAndConfirmTx(rpc, tx); - - console.log("Token pool created and tokens compressed"); - console.log("Transaction:", txId); - - // Step 4: Verify compressed balance - const compressedAccounts = await rpc.getCompressedTokenAccountsByOwner( - payer.publicKey, - { mint } - ); - - const compressedBalance = compressedAccounts.items.reduce( - (sum, account) => sum.add(account.parsed.amount), - new BN(0) - ); - - console.log("Compressed balance:", compressedBalance.toNumber() / 1_000_000_000, "tokens"); - - return { - transactionSignature: txId, - mint, - compressedBalance: compressedBalance.toNumber(), - }; -} - -createPoolAndCompress().catch(console.error); -``` - - - -# Next Steps - - diff --git a/compressed-tokens/advanced-guides/use-token-2022-with-compression.mdx b/compressed-tokens/advanced-guides/use-token-2022-with-compression.mdx deleted file mode 100644 index 25597daa..00000000 --- a/compressed-tokens/advanced-guides/use-token-2022-with-compression.mdx +++ /dev/null @@ -1,277 +0,0 @@ ---- -title: Use Token-2022 with Compression -description: Complete guide to mint, compress and transfer tokens with Token-2022 Metadata with ZK Compression. -keywords: ["token 2022 on solana", "token extensions on solana", "token 2022 compression"] ---- - -import InstallDependencies from '/snippets/setup/install-dependencies-codegroup.mdx'; -import SetupEnvironment from '/snippets/setup/setup-environment-tabs.mdx'; - -# What you will do - -With this guide you will mint, compress, and transfer tokens with Token-2022 Metadata. - -# Overview Token 2022 Extensions - -Token 2022 Extensions are optional features that can be added to Token 2022 mints on Solana to enable additional functionality. - -ZK Compression supports compressing the following mint-extensions: - -* MetadataPointer -* TokenMetadata -* InterestBearingConfig -* GroupPointer -* GroupMemberPointer -* TokenGroup -* TokenGroupMember - -All other extensions are not yet supported. - - -If you require support for other mint-extensions, [let us know](https://t.me/swen_light)! - - -# Get started - - - - - -You need the following SDK versions: - -* `@lightprotocol/stateless.js` ≥ 0.21.0 -* `@lightprotocol/compressed-token` ≥ 0.21.0 -* `@solana/web3.js` ≥ 1.95.3 - - -Make sure you have dependencies and developer environment set up! - - - -**Dependencies** - - - -**Developer Environment** - - - - - - -Run `compress-t22.ts`. - -```typescript compress-t22.ts expandable -// Token-2022 with ZK Compression - Local -// 1. Load wallet and connect to local validator -// 2. Create Token-2022 mint with metadata extension and register for compression via createSplInterface() -// 3. Mint SPL tokens to ATA, compress via compress(), and transfer compressed tokens via transfer() -// 4. Verify balances via getTokenAccountBalance and getCompressedTokenAccountsByOwner - -import { confirmTx, createRpc } from "@lightprotocol/stateless.js"; -import { - compress, - createSplInterface, - transfer, -} from "@lightprotocol/compressed-token"; -import { - getOrCreateAssociatedTokenAccount, - mintTo as mintToSpl, - TOKEN_2022_PROGRAM_ID, - createInitializeMetadataPointerInstruction, - createInitializeMintInstruction, - ExtensionType, - getMintLen, - LENGTH_SIZE, - TYPE_SIZE, -} from "@solana/spl-token"; -import { - Keypair, - sendAndConfirmTransaction, - SystemProgram, - Transaction, -} from "@solana/web3.js"; -import { - createInitializeInstruction, - pack, - TokenMetadata, -} from "@solana/spl-token-metadata"; - -// Step 1: Setup local connection and load wallet -import * as fs from 'fs'; -import * as os from 'os'; - -const walletPath = `${os.homedir()}/.config/solana/id.json`; -const secretKey = JSON.parse(fs.readFileSync(walletPath, 'utf8')); -const payer = Keypair.fromSecretKey(Buffer.from(secretKey)); -const connection = createRpc(); // defaults to localhost:8899 - -(async () => { - - // Generate mint keypair and define Token-2022 metadata - const mint = Keypair.generate(); - const decimals = 9; - - const metadata: TokenMetadata = { - mint: mint.publicKey, - name: "Local Test Token", - symbol: "LTT", - uri: "https://example.com/token-metadata.json", - additionalMetadata: [["environment", "localnet"], ["test", "true"]], - }; - - // Calculate space requirements for Token-2022 mint with MetadataPointer extension - const mintLen = getMintLen([ExtensionType.MetadataPointer]); - const metadataLen = TYPE_SIZE + LENGTH_SIZE + pack(metadata).length; - - // Check wallet balance - const balance = await connection.getBalance(payer.publicKey); - - // Step 2: Create Token-2022 mint with metadata extension - const mintLamports = await connection.getMinimumBalanceForRentExemption( - mintLen + metadataLen - ); - - const mintTransaction = new Transaction().add( - // Create account for Token-2022 mint - SystemProgram.createAccount({ - fromPubkey: payer.publicKey, - newAccountPubkey: mint.publicKey, - space: mintLen, - lamports: mintLamports, - programId: TOKEN_2022_PROGRAM_ID, - }), - // Initialize MetadataPointer extension - createInitializeMetadataPointerInstruction( - mint.publicKey, - payer.publicKey, - mint.publicKey, - TOKEN_2022_PROGRAM_ID - ), - // Initialize Token-2022 mint account - createInitializeMintInstruction( - mint.publicKey, - decimals, - payer.publicKey, - null, - TOKEN_2022_PROGRAM_ID - ), - // Initialize token metadata - createInitializeInstruction({ - programId: TOKEN_2022_PROGRAM_ID, - mint: mint.publicKey, - metadata: mint.publicKey, - name: metadata.name, - symbol: metadata.symbol, - uri: metadata.uri, - mintAuthority: payer.publicKey, - updateAuthority: payer.publicKey, - }) - ); - - // Send Token-2022 mint creation transaction - const mintCreationTxId = await sendAndConfirmTransaction( - connection, - mintTransaction, - [payer, mint] - ); - console.log(`Token-2022 mint created with address: ${mint.publicKey.toString()}`); - - // Step 3: Call createSplInterface() to initialize omnibus account - // and register Token-2022 mint with Light Token Program - // Create PDA that holds SPL tokens for compressed tokens - const registerTxId = await createSplInterface( - connection, - payer, - mint.publicKey, // Token-2022 mint to register with Light Token Program - undefined, - TOKEN_2022_PROGRAM_ID - ); - - // Step 4: Create associated token account and mint tokens - const ata = await getOrCreateAssociatedTokenAccount( - connection, - payer, - mint.publicKey, // Token-2022 mint with SPL interface for compression - payer.publicKey, - undefined, - undefined, - undefined, - TOKEN_2022_PROGRAM_ID - ); - - // Mint Token-2022 tokens to ATA - const mintAmount = 400_000_000; // 0.4 tokens - const mintToTxId = await mintToSpl( - connection, - payer, - mint.publicKey, // Token-2022 mint with SPL interface for compression - ata.address, // destination token account - payer.publicKey, // mint authority - mintAmount, // amount to mint - undefined, // multiSigners (not used for single authority) - undefined, - TOKEN_2022_PROGRAM_ID - ); - console.log(`Minted ${mintAmount / 1e9} Token-2022 tokens with metadata extension`); - console.log(`Transaction: ${mintToTxId}`); - - // Step 5: Call compress() to convert Token-2022 tokens to compressed format - // Transfer Token-2022 tokens to omnibus pool and mint compressed tokens - const compressAmount = 300_000_000; // 0.3 tokens - const compressTxId = await compress( - connection, - payer, - mint.publicKey, // Token-2022 mint with SPL interface for compression - compressAmount, // amount to compress - payer, // owner of SPL tokens - ata.address, // Source ATA for compression - payer.publicKey // recipient for compressed tokens - ); - console.log(`\nCompressed ${compressAmount / 1e9} Token-2022 tokens`); - console.log(`Transaction: ${compressTxId}`); - - // Step 6: Transfer compressed Token-2022 tokens - const transferRecipient = Keypair.generate(); // Keypair recipient - const transferAmount = 100_000_000; // 0.1 tokens - const transferTxId = await transfer( - connection, - payer, - mint.publicKey, // Token-2022 mint with SPL interface for compression - transferAmount, - payer, - transferRecipient.publicKey - ); - console.log(`\nTransferred ${transferAmount / 1e9} Compressed Token-2022 tokens`); - console.log(`Transaction: ${transferTxId}`); - console.log(`Recipient: ${transferRecipient.publicKey.toString()}`); - - // Step 7: Verify balances via getTokenAccountBalance and getCompressedTokenAccountsByOwner - const senderCompressedAccounts = await connection.getCompressedTokenAccountsByOwner(payer.publicKey, { mint: mint.publicKey }); - const senderBalance = senderCompressedAccounts.items.reduce((sum, account) => sum + Number(account.parsed.amount), 0); - - const recipientCompressedAccounts = await connection.getCompressedTokenAccountsByOwner(transferRecipient.publicKey, { mint: mint.publicKey }); - const recipientBalance = recipientCompressedAccounts.items.reduce((sum, account) => sum + Number(account.parsed.amount), 0); - - const splBalance = await connection.getTokenAccountBalance(ata.address); - - console.log(`\nSummary Token-2022 balances:`); - console.log(`Sender balance: ${senderBalance / 1e9} compressed tokens / ${splBalance.value.uiAmount} SPL tokens`); - console.log(`Recipient balance: ${recipientBalance / 1e9} compressed tokens`); - -})().catch(console.error); -``` - - - -# Next Steps - - - - diff --git a/compressed-tokens/advanced-guides/airdrop.mdx b/compressed-tokens/airdrop.mdx similarity index 99% rename from compressed-tokens/advanced-guides/airdrop.mdx rename to compressed-tokens/airdrop.mdx index ce18f3ef..72380bcd 100644 --- a/compressed-tokens/advanced-guides/airdrop.mdx +++ b/compressed-tokens/airdrop.mdx @@ -1,6 +1,6 @@ --- -title: Airdrop Guide with ZK Compression -sidebarTitle: Airdrop Guide +title: Airdrop Guide +sidebarTitle: Token Distribution description: Complete client and program guides to create an airdrop – with or without code. ZK compression is the most efficient way to distribute SPL tokens. keywords: ["solana airdrop", "merkle distributor", "merkle airdrop", "airdrop infrastructure on solana", "scalable token distribution on solana", "token airdrop for protocols"] --- @@ -8,6 +8,8 @@ keywords: ["solana airdrop", "merkle distributor", "merkle airdrop", "airdrop in import { TokenAccountCompressedVsSpl } from '/snippets/jsx/token-account-compressed-vs-spl.jsx'; import InstallDependencies from '/snippets/setup/install-dependencies-codegroup.mdx'; import SetupEnvironment from '/snippets/setup/setup-environment-tabs.mdx'; +import AgentSkillAirdrop from "/snippets/setup/agent-skill-airdrop.mdx"; +import AirdropAiPrompt from "/snippets/ai-prompts/toolkits/airdrop.mdx"; @@ -15,6 +17,8 @@ import SetupEnvironment from '/snippets/setup/setup-environment-tabs.mdx'; --- + + @@ -891,6 +895,9 @@ const recipients = [ + + + # Advanced Features diff --git a/compressed-tokens/for-privy.mdx b/compressed-tokens/for-privy.mdx index 035d3061..0d422410 100644 --- a/compressed-tokens/for-privy.mdx +++ b/compressed-tokens/for-privy.mdx @@ -1,6 +1,6 @@ --- title: "Rent-Free SPL Accounts with Privy" -sidebarTitle: "Privy Guide" +sidebarTitle: "Sign with Privy Wallet" description: "Integrate compressed tokens with Privy embedded wallets for rent-free SPL token accounts and transfers." keywords: ["privy solana", "privy compressed tokens", "embedded wallet compression", "rent-free tokens privy"] --- @@ -96,7 +96,7 @@ const rpc = createRpc(RPC_ENDPOINT); Before we call compress or decompresss, we need: -* An SPL mint with a interface PDA for compression. This PDA can be created for new SPL mints via [`createMint()`](/compressed-tokens/guides/create-mint-with-token-pool) or added to existing SPL mints via [`createSplInterface()`](/compressed-tokens/guides/add-token-pools-to-mint-accounts). +* An SPL mint with a interface PDA for compression. This PDA can be created for new SPL mints via [`createMint()`](https://github.com/Lightprotocol/examples-zk-compression/tree/main/compressed-token-cookbook) or added to existing SPL mints via [`createSplInterface()`](https://github.com/Lightprotocol/examples-zk-compression/tree/main/compressed-token-cookbook). * For `compress()` SPL tokens in an Associated Token Account, or * For `decompress()` compressed token accounts with sufficient balance. diff --git a/compressed-tokens/guides.mdx b/compressed-tokens/guides.mdx deleted file mode 100644 index 16a44ebd..00000000 --- a/compressed-tokens/guides.mdx +++ /dev/null @@ -1,9 +0,0 @@ ---- -title: Guides -description: "Overview of guides to compressed token operations and reference table with descriptions. Guides include full code examples, troubleshooting, and advanced configurations." -sidebarTitle: "Overview" ---- - -import GuidesTable from '/snippets/overview-tables/compressed-tokens-guides-table.mdx'; - - diff --git a/compressed-tokens/guides/add-token-pools-to-mint-accounts.mdx b/compressed-tokens/guides/add-token-pools-to-mint-accounts.mdx deleted file mode 100644 index bcc62989..00000000 --- a/compressed-tokens/guides/add-token-pools-to-mint-accounts.mdx +++ /dev/null @@ -1,111 +0,0 @@ ---- -title: Create SPL Interface for Existing Mints -description: "Create an SPL Interface PDA (omnibus account) for an existing SPL mint. Requires only fee_payer with no mint authority constraint." -keywords: ["SPL interface", "compression", "omnibus account"] ---- - -import FullSetup from "/snippets/setup/full-setup.mdx"; -import ActionCode from '/snippets/code-snippets/compressed-token/create-token-pool/action.mdx'; - -Create an SPL interface (omnibus account) for an existing SPL mint. `createSplInterface()` requires only `fee_payer` and has no mint authority constraint. - - -The SPL Interface PDA requires rent; individual compressed token accounts are rent-free. - - - -```typescript function-create-token-pool.ts -// Creates SPL interface (omnibus account) for existing SPL mint -const transactionSignature = await createSplInterface( - rpc, - payer, - mint, -); -``` - - - -**Best Practice:** Each mint supports up to 4 SPL interfaces. During compression/decompression, SPL Interface PDAs get write-locked. Use `addTokenPools()` to create additional interfaces and increase per-block write-lock capacity. - - -## Get Started - - - -### Create SPL interface - - - - - - - -# Troubleshooting - - - - -The mint has no SPL Interface PDA. - -```typescript -const poolTx = await createSplInterface(rpc, payer, mint); -console.log("SPL interface created:", poolTx); -``` - - - - -# Advanced Configuration - - - - -Create SPL interfaces for multiple mints: - -```typescript -const mints = [ - new PublicKey("MINT_1_ADDRESS"), - new PublicKey("MINT_2_ADDRESS"), - new PublicKey("MINT_3_ADDRESS"), -]; - -for (const mint of mints) { - try { - const poolTx = await createSplInterface(rpc, payer, mint); - console.log(`SPL interface created for ${mint.toBase58()}:`, poolTx); - } catch (error) { - console.log(`Failed for ${mint.toBase58()}:`, error.message); - } -} -``` - - - - - -Create SPL interface for Token-2022 mints: - -```typescript -import { TOKEN_2022_PROGRAM_ID } from '@solana/spl-token'; - -const poolTx = await createSplInterface( - rpc, - payer, - mint, // Token-2022 mint - undefined, - TOKEN_2022_PROGRAM_ID, -); -``` - - - - -# Next Steps - - diff --git a/compressed-tokens/guides/compress-decompress.mdx b/compressed-tokens/guides/compress-decompress.mdx deleted file mode 100644 index af196600..00000000 --- a/compressed-tokens/guides/compress-decompress.mdx +++ /dev/null @@ -1,217 +0,0 @@ ---- -title: Compress and Decompress SPL Tokens -description: "Convert SPL tokens between compressed and regular format with compress() and decompress()." -keywords: ["compress spl tokens", "decompress tokens on solana"] ---- - -import FullSetup from "/snippets/setup/full-setup.mdx"; -import MintPrereq from '/snippets/setup/compressed-tokens-mint-prereq.mdx'; -import CompressActionCode from '/snippets/code-snippets/compressed-token/compress/action.mdx'; -import DecompressActionCode from '/snippets/code-snippets/compressed-token/decompress/action.mdx'; - - -```typescript compress() -// Compress SPL tokens to compressed tokens -const compressionSignature = await compress( - rpc, - payer, - mint, // SPL mint with SPL interface for compression - amount, - payer, // owner of SPL tokens - tokenAccount.address, // source SPL token account (sourceTokenAccount parameter) - recipient, // recipient owner address (toAddress parameter) -); -``` - -```typescript decompress() -// Decompress compressed tokens to SPL tokens -const transactionSignature = await decompress( - rpc, - payer, - mint, // SPL mint with SPL interface for compression - amount, - payer, // owner of compressed tokens - tokenAccount.address, // destination token account (toAddress parameter) -); -``` - - - -**Function Difference and Best Practice:** - -* `compress(amount, sourceTokenAccount, toAddress)` compresses specific amounts from source to a specified recipient. Use for transfers and precise amounts. -* `compressSplTokenAccount(tokenAccount, remainingAmount)` compresses the entire SPL token account balance minus optional remaining amount only to the same owner. Use to migrate complete token accounts with optional partial retention. [Here is how](/compressed-tokens/guides/compress-spl-token-account). - - -## Get Started - - - -### Compress / Decompress Tokens - - - - -Before we can compress or decompresss, we need: - -* An SPL mint with an SPL interface. Create one for new mints via [`createMint()`](/compressed-tokens/guides/create-mint-with-token-pool) or for existing mints via [`createSplInterface()`](/compressed-tokens/guides/add-token-pools-to-mint-accounts). -* For `compress()` SPL tokens in an Associated Token Account, or -* For `decompress()` compressed token accounts with sufficient balance. - - - - - - - - - - - - - - -# Troubleshooting - - - - -Check your balances before operations: - -```typescript -// For decompression - check compressed balance -const compressedAccounts = await rpc.getCompressedTokenAccountsByOwner( - owner.publicKey, - { mint } -); -const compressedBalance = compressedAccounts.items.reduce( - (sum, account) => sum.add(account.parsed.amount), - new BN(0) -); - -// For compression - check SPL token balance -const tokenBalance = await rpc.getTokenAccountBalance(tokenAccount); -const splBalance = new BN(tokenBalance.value.amount); - -console.log("Can decompress up to:", compressedBalance.toString()); -console.log("Can compress up to:", splBalance.toString()); -``` - - - - - -Ensure the signer owns the tokens being decompressed/compressed: - -```typescript -// The owner parameter must be the actual owner -const decompressTx = await decompress( - rpc, - payer, // can be different (pays fees) - mint, - amount, - actualOwner, // must own compressed tokens - destinationAta, -); - -const compressTx = await compress( - rpc, - payer, // can be different (pays fees) - mint, - amount, - actualOwner, // must own SPL tokens - sourceAta, - recipient, -); -``` - - - - -# Advanced Configuration - - - - -Compress tokens directly to someone else: - -```typescript -const recipientWallet = new PublicKey("RECIPIENT_WALLET_ADDRESS"); - -// Compress your SPL tokens to recipient -const compressTx = await compress( - rpc, - payer, - mint, - amount, - tokenOwner, // current owner signs - tokenAccount, // your token account - recipientWallet, // recipient gets compressed tokens -); -``` - - - - - -Compress multiple token accounts: - -```typescript -// Compress to multiple recipients at once -const recipients = [recipient1.publicKey, recipient2.publicKey, recipient3.publicKey]; -const amounts = [1_000_000_000, 2_000_000_000, 500_000_000]; // Different amounts - -const batchCompressTx = await compress( - rpc, - payer, - mint, - amounts, // Array of amounts - owner, - tokenAccount, - recipients, // Array of recipients -); - -console.log("Batch compression completed:", batchCompressTx); -``` - - - - - -Decompress tokens using delegate authority: - -```typescript -import { decompressDelegated } from '@lightprotocol/compressed-token'; -import { getAssociatedTokenAddress, TOKEN_PROGRAM_ID } from '@solana/spl-token'; - -// Get ATA for decompressed tokens -const ataAddress = await getAssociatedTokenAddress( - mint, - recipient, - false, - TOKEN_PROGRAM_ID -); - -// Delegate decompresses tokens -await decompressDelegated( - rpc, - payer, - mint, - amount, - delegate, // Signer - owner of compressed tokens - ataAddress, // Uncompressed token account (ATA) -); -``` - - - - -# Next Steps - - diff --git a/compressed-tokens/guides/compress-spl-token-account.mdx b/compressed-tokens/guides/compress-spl-token-account.mdx deleted file mode 100644 index 3c0d1d6e..00000000 --- a/compressed-tokens/guides/compress-spl-token-account.mdx +++ /dev/null @@ -1,189 +0,0 @@ ---- -title: Compress Complete SPL Token Accounts -description: "Compress the entire balance of an SPL token account to reclaim rent. Optionally leave some tokens in SPL format." -keywords: ["compress spl token accounts", "migrate spl to compressed"] ---- - -import FullSetup from "/snippets/setup/full-setup.mdx"; -import MintPrereq from '/snippets/setup/compressed-tokens-mint-prereq.mdx'; -import ActionCode from '/snippets/code-snippets/compressed-token/compress-spl-account/action.mdx'; - - -```typescript compressSplTokenAccount() -// Compress entire SPL token account balance -const transactionSignature = await compressSplTokenAccount( - rpc, - payer, - mint, // SPL mint with SPL interface for compression - owner, - tokenAccount, // SPL token account to compress -); -``` - -```typescript partialCompression() -// Compress account while keeping some tokens in SPL format -const transactionSignature = await compressSplTokenAccount( - rpc, - payer, - mint, // SPL mint with SPL interface for compression - owner, - tokenAccount, // SPL token account to compress - remainingAmount, // amount to keep in SPL format -); -``` - - - -After compression, empty token accounts can now be closed to reclaim rent with [`closeAccount()`](https://solana.com/developers/cookbook/tokens/close-token-accounts). - - - -**Function Difference and Best Practice:** - -* `compressSplTokenAccount(tokenAccount, remainingAmount)` compresses the entire SPL token account balance minus optional remaining amount only to the same owner. Use to migrate complete token accounts with optional partial retention. -* `compress(amount, sourceTokenAccount, toAddress)` compresses specific amounts from source to a specified recipient. Use for transfers and precise amounts. [Here is how](/compressed-tokens/guides/compress-decompress). - - -## Get Started - - - -### Compress SPL Token Accounts - - - - - - - - - - -# Troubleshooting - - - - -The token account doesn't have enough tokens for the operation. - -```typescript -// Check token account balance before compression -const balance = await rpc.getTokenAccountBalance(tokenAccount); - -if (Number(balance.value.amount) === 0) { - console.log("Token account is empty"); - return; -} - -console.log("Available balance:", Number(balance.value.amount)); - -// Proceed with compression -const compressTx = await compressSplTokenAccount( - rpc, - payer, - mint, - owner, - tokenAccount, -); -``` - - - - - -The `remainingAmount` parameter exceeds the current account balance. - -```typescript -const balance = await rpc.getTokenAccountBalance(tokenAccount); -const availableAmount = Number(balance.value.amount); -const remainingAmount = bn(500_000_000); // 0.5 tokens - -if (remainingAmount.gt(bn(availableAmount))) { - console.log(`Cannot leave ${remainingAmount.toString()} tokens`); - console.log(`Available balance: ${availableAmount}`); - throw new Error("Remaining amount exceeds balance"); -} - -// Use valid remaining amount -const compressTx = await compressSplTokenAccount( - rpc, - payer, - mint, - owner, - tokenAccount, - remainingAmount, // must be <= balance -); -``` - - - - -# Advanced Configuration - - - - -Compress most tokens while leaving some in SPL format: - -```typescript -import { bn } from '@lightprotocol/stateless.js'; - -// Leave 100 tokens (0.1 with 9 decimals) in SPL account -const remainingAmount = bn(100_000_000); - -const compressTx = await compressSplTokenAccount( - rpc, - payer, - mint, - owner, - tokenAccount, - remainingAmount, // amount to keep in SPL format -); - -// Account will retain remainingAmount tokens -``` - - - - - -Compress several token accounts for the same mint: - -```typescript -const tokenAccounts = [ - { account: new PublicKey("ACCOUNT_1"), owner: owner1 }, - { account: new PublicKey("ACCOUNT_2"), owner: owner2 }, - { account: new PublicKey("ACCOUNT_3"), owner: owner3 }, -]; - -// Compress each account -for (const { account, owner } of tokenAccounts) { - console.log(`Compressing account: ${account.toBase58()}`); - - try { - const compressTx = await compressSplTokenAccount( - rpc, - payer, - mint, - owner, - account, - ); - console.log(`Compressed: ${compressTx}`); - } catch (error) { - console.log(`Failed: ${error.message}`); - } -} -``` - - - - -# Next Steps - - diff --git a/compressed-tokens/guides/create-compressed-token-accounts.mdx b/compressed-tokens/guides/create-compressed-token-accounts.mdx deleted file mode 100644 index 28eecd3f..00000000 --- a/compressed-tokens/guides/create-compressed-token-accounts.mdx +++ /dev/null @@ -1,20 +0,0 @@ ---- -title: Create Compressed Token Accounts -description: Short guide to compressed token account creation with ZK Compression on Solana and difference to regular token accounts. -keywords: ["create compressed token account", "rent free token accounts on solana"] ---- - -Compressed token accounts store ownership information for compressed tokens like regular token accounts with two core differences. Compressed Tokens - -* do not require an Associated Token Accounts (ATAs), and -* do not require a rent-exempt balance. - -Compressed token accounts are created in the following scenarios: - -1. `mintTo()` creates compressed token accounts for recipients. - -How to Mint Compressed Tokens - -2. `transfer()` consumes existing accounts of the sender as input, and creates new compressed token accounts with updated balances as output for the sender and recipient(s). - -Transfer Compressed Tokens \ No newline at end of file diff --git a/compressed-tokens/guides/create-mint-with-token-pool.mdx b/compressed-tokens/guides/create-mint-with-token-pool.mdx deleted file mode 100644 index e9decac6..00000000 --- a/compressed-tokens/guides/create-mint-with-token-pool.mdx +++ /dev/null @@ -1,99 +0,0 @@ ---- -title: Create a Mint with SPL Interface for Compression -description: "Create an SPL token mint with an SPL Interface PDA (omnibus account) for compression. The SPL interface holds SPL tokens while compressed and releases them when decompressed." -keywords: ["register mint for compression", "compressed mint account", "SPL interface"] ---- - -import FullSetup from "/snippets/setup/full-setup.mdx"; -import ActionCode from '/snippets/code-snippets/compressed-token/create-mint/action.mdx'; -import InstructionCode from '/snippets/code-snippets/compressed-token/create-mint/instruction.mdx'; - -The mint account itself requires rent (like regular SPL mints), but individual compressed token accounts are rent-free. -Create an SPL interface (omnibus account) for an existing SPL mint with [`createSplInterface()`](/compressed-tokens/guides/add-token-pools-to-mint-accounts) or use `createMint()` to create a new one from scratch. - - -```typescript createMint() -// Create SPL mint with SPL interface for compression -const { mint, transactionSignature } = await createMint( - rpc, - payer, - mintAuthority.publicKey, - decimals, -); -``` - - - -**Best Practice:** Each mint supports up to 4 SPL interfaces. During compression/decompression, SPL Interface PDAs get write-locked. Use `addTokenPools()` to create additional interfaces and increase per-block write-lock capacity. - - -## Get Started - - - -### Create a mint with SPL interface for compression - - - - - - - - - - - - - - -# Advanced Configuration - - - - -Customize who can mint new compressed tokens. - -```typescript -const mintAuthority = Keypair.generate(); - -const { mint, transactionSignature } = await createMint( - rpc, - payer, - mintAuthority.publicKey, - 9, -); -``` - - - - - -Customize who can freeze/thaw compressed token accounts. - -```typescript -const freezeAuthority = Keypair.generate(); - -const { mint, transactionSignature } = await createMint( - rpc, - payer, - payer.publicKey, // mint authority - 9, // decimals - Keypair.generate(), // mint keypair - undefined, // confirm options - undefined, // token program ID - freezeAuthority.publicKey, // freeze authority -); -``` - - - - -# Next Steps - - diff --git a/compressed-tokens/guides/delegate.mdx b/compressed-tokens/guides/delegate.mdx deleted file mode 100644 index a17c7c84..00000000 --- a/compressed-tokens/guides/delegate.mdx +++ /dev/null @@ -1,166 +0,0 @@ ---- -title: Approve and Revoke Delegate Authority -description: "Grant and remove delegate spending authority for compressed tokens with approve() and revoke(). Only the token owner can perform these operations." -keywords: ["delegate authority on solana", "token delegation compressed"] ---- - -import FullSetup from "/snippets/setup/full-setup.mdx"; -import ApproveActionCode from '/snippets/code-snippets/compressed-token/approve/action.mdx'; -import RevokeActionCode from '/snippets/code-snippets/compressed-token/revoke/action.mdx'; - -The `approve()` and `revoke()` functions grant and remove delegate spending authority for compressed tokens. Only the token owner can perform these instructions. - - -```typescript approve() -// Approve delegate for spending up to the specified amount -const approveSignature = await approve( - rpc, - payer, - mint, // SPL mint with SPL interface for compression - amount, - owner, - delegate.publicKey, // delegate account -); -``` - -```typescript revoke() -// Get delegated accounts for revocation -const delegatedAccounts = await rpc.getCompressedTokenAccountsByDelegate( - delegate.publicKey, - { mint } -); - -// Revoke delegate authority -const revokeSignature = await revoke( - rpc, - payer, - delegatedAccounts.items, // delegated compressed token accounts - owner, -); -``` - - -## Get Started - - - -### Approve / Revoke Delegates - - - - - - - - - - - - - -Before we approve or revoke delegates, we need: - -* compressed token accounts to delegate or revoke delegation from, and -* an SPL mint with an SPL interface. Create one for new mints via [`createMint()`](/compressed-tokens/guides/create-mint-with-token-pool) or for existing mints via [`createSplInterface()`](/compressed-tokens/guides/add-token-pools-to-mint-accounts). - - - - - -# Troubleshooting - - - - -Attempting to revoke non-delegated accounts. - -```typescript -/// Verify accounts are delegated before revocation. -const delegateAccounts = await rpc.getCompressedTokenAccountsByDelegate( - delegate.publicKey, - { mint } -); - -if (delegateAccounts.items.length === 0) { - console.log("No delegated accounts to revoke"); - return; -} -``` - - - - -# Advanced Configuration - - - - -```typescript -const delegates = [ - Keypair.generate().publicKey, - Keypair.generate().publicKey, -]; - -const amounts = [ - 200_000_000, // 0.2 tokens to first delegate - 300_000_000, // 0.3 tokens to second delegate -]; - -// Approve each delegate -for (let i = 0; i < delegates.length; i++) { - const approveTx = await approve( - rpc, - payer, - mint, - amounts[i], - tokenOwner, - delegates[i], - ); - - console.log(`Delegate ${i + 1} approved:`, approveTx); -} -``` - - - - - -```typescript -const delegates = [ - new PublicKey("DELEGATE_1_ADDRESS"), - new PublicKey("DELEGATE_2_ADDRESS"), -]; - -// Revoke each delegate -for (const delegate of delegates) { - // Get delegated accounts for this delegate - const delegateAccounts = await rpc.getCompressedTokenAccountsByDelegate( - delegate, - { mint } - ); - - if (delegateAccounts.items.length > 0) { - const revokeTx = await revoke( - rpc, - payer, - delegateAccounts.items, - tokenOwner, - ); - - console.log(`Delegate ${delegate.toBase58()} revoked:`, revokeTx); - } -} -``` - - - - -# Next Steps - - diff --git a/compressed-tokens/guides/merge-compressed-token-accounts.mdx b/compressed-tokens/guides/merge-compressed-token-accounts.mdx deleted file mode 100644 index 278547b2..00000000 --- a/compressed-tokens/guides/merge-compressed-token-accounts.mdx +++ /dev/null @@ -1,145 +0,0 @@ ---- -title: Merge Compressed Token Accounts -description: "Consolidate multiple compressed token accounts of the same mint into a single account to reduce fragmentation." -keywords: ["merge compressed token accounts", "consolidate token accounts"] ---- - -import FullSetup from "/snippets/setup/full-setup.mdx"; -import ActionCode from '/snippets/code-snippets/compressed-token/merge-token-accounts/action.mdx'; - -The `mergeTokenAccounts()` function consolidates multiple compressed accounts of the same mint into a single compressed account. - -The function - -1. consumes multiple compressed token accounts (up to 8 accounts), and -2. creates a single output compressed token account with combined balance for the owner. - - -State trees where compressed account's are stored, are append only. `mergeTokenAccounts()` reduces account fragmentation to simplify balance calculations from `getCompressedTokenAccountsByOwner`. - - - -```typescript function-merge-accounts.ts -// Combines multiple compressed token accounts into single compressed account -const transactionSignature = await mergeTokenAccounts( - rpc, - payer, - mint, // SPL mint with SPL interface for compression - owner, -); -``` - - -## Get Started - - - -### Merge Compressed Accounts - - - - - - -Before we merge compressed accounts, we need - -* Multiple compressed token accounts of the same mint owned by the same wallet, and -* an SPL mint with an SPL interface. Create one for new mints via [`createMint()`](/compressed-tokens/guides/create-mint-with-token-pool) or for existing mints via [`createSplInterface()`](/compressed-tokens/guides/add-token-pools-to-mint-accounts). - - - - - -# Troubleshooting - - - - -The owner has no compressed token accounts for the specified mint: - -```typescript -// Check if accounts exist before merging -const accounts = await rpc.getCompressedTokenAccountsByOwner( - owner.publicKey, - { mint } -); - -if (accounts.items.length === 0) { - console.log("No compressed token accounts found for this mint"); - console.log("Mint address:", mint.toBase58()); - console.log("Owner address:", owner.publicKey.toBase58()); - return; -} - -console.log(`Found ${accounts.items.length} accounts to merge`); -``` - - - - -# Advanced Configuration - - - - -```typescript -// Get account count -const accounts = await rpc.getCompressedTokenAccountsByOwner( - owner.publicKey, - { mint } -); - -// Only merge if more than 2 accounts -if (accounts.items.length > 2) { - console.log(`Merging ${accounts.items.length} accounts...`); - - const mergeTx = await mergeTokenAccounts( - rpc, - payer, - mint, - tokenOwner, - ); - - console.log("Merge completed:", mergeTx); -} else { - console.log("Merge not needed - optimal account structure"); -} -``` - - - - - -```typescript -const mints = [ - new PublicKey("MINT_1_ADDRESS"), - new PublicKey("MINT_2_ADDRESS"), -]; - -// Merge accounts for each mint -for (const mint of mints) { - console.log(`Merging accounts for mint: ${mint.toBase58()}`); - - const mergeTx = await mergeTokenAccounts( - rpc, - payer, - mint, - tokenOwner, - ); - - console.log(`Merge completed: ${mergeTx}`); -} -``` - - - - -# Next Steps - - diff --git a/compressed-tokens/guides/mint-compressed-tokens.mdx b/compressed-tokens/guides/mint-compressed-tokens.mdx deleted file mode 100644 index fe5b0fa4..00000000 --- a/compressed-tokens/guides/mint-compressed-tokens.mdx +++ /dev/null @@ -1,154 +0,0 @@ ---- -title: Mint Compressed Tokens -description: "Mint tokens to compressed token accounts for recipients and increases a mint's token supply. Only the mint authority can perform this operation." -keywords: ["mint compressed tokens on solana", "scalable token minting"] ---- - -import FullSetup from "/snippets/setup/full-setup.mdx"; -import MintPrereq from '/snippets/setup/compressed-tokens-mint-prereq.mdx'; -import ActionCode from '/snippets/code-snippets/compressed-token/mint-to/action.mdx'; -import InstructionCode from '/snippets/code-snippets/compressed-token/mint-to/instruction.mdx'; - -```typescript -// Mint compressed tokens - mints SPL tokens to pool, creates compressed token accounts -const transactionSignature = await mintTo( - rpc, - payer, - mint, // SPL mint with SPL interface for compression - recipient, // recipient address (toPubkey parameter) - payer, // mint authority - amount, -); -``` - -## Get Started - - - -### Mint Compressed Tokens - - - - - - - - - - - - - - - - -# Troubleshooting - - - - - -```typescript -// Error: SPL interface not found for this mint. Create a compressed token -// SPL interface PDA for mint: [ADDRESS] via createSplInterface(). -``` - -The mint has no SPL Interface PDA. Ensure you created the mint using `createMint` or call `createSplInterface()` for an existing mint. - -```typescript -// Create mint with SPL interface for compression -import { createMint } from '@lightprotocol/compressed-token'; -const { mint } = await createMint(rpc, payer, payer.publicKey, 9); -``` - - - - - -The SPL interface info doesn't correspond to the mint address. Ensure you're fetching the correct interface: - -```typescript -// Get SPL interface infos for your mint -const tokenPoolInfo = await getTokenPoolInfos(rpc, mint); -``` - - - - - -When minting to multiple recipients, ensure arrays are the same size. - -```typescript -// Wrong: Mismatched array lengths -const recipients = [addr1, addr2, addr3]; -const amounts = [100, 200]; // Only 2 amounts for 3 recipients - -// Correct: Same length arrays -const recipients = [addr1, addr2, addr3]; -const amounts = [100, 200, 300]; // 3 amounts for 3 recipients -``` - - - - -# Advanced Configuration - - - - -```typescript -// Mint different amounts to multiple recipients -const recipients = [ - Keypair.generate().publicKey, - Keypair.generate().publicKey, - Keypair.generate().publicKey, -]; - -const amounts = [ - 1_000_000_000, // 1 token - 2_000_000_000, // 2 tokens - 500_000_000, // 0.5 tokens -]; - -const transactionSignature = await mintTo( - rpc, - payer, - mint, // SPL mint with SPL interface for compression - recipients, // array of recipients (toPubkey parameter) - payer, // mint authority - amounts, // array of amounts (amount parameter) -); -``` - - - - - -Mint tokens using a custom mint authority with `approveAndMintTo()`: - -```typescript -import { approveAndMintTo } from '@lightprotocol/compressed-token'; - -// Mint tokens with a separate mint authority -const transactionSignature = await approveAndMintTo( - rpc, - payer, - mint, // SPL mint with SPL interface for compression - recipient.publicKey, // recipient of minted tokens (toPubkey parameter) - mintAuthority, // mint authority - mintAmount, -); -``` - - - - -# Next Steps - - \ No newline at end of file diff --git a/compressed-tokens/guides/transfer-compressed-tokens.mdx b/compressed-tokens/guides/transfer-compressed-tokens.mdx deleted file mode 100644 index 3e10eb27..00000000 --- a/compressed-tokens/guides/transfer-compressed-tokens.mdx +++ /dev/null @@ -1,190 +0,0 @@ ---- -title: Transfer Compressed Tokens -description: "Transfer compressed tokens between accounts. Transfers consume input accounts and create new output accounts with updated balances." -keywords: ["transfer compressed tokens", "token transfer on solana"] ---- - -import FullSetup from "/snippets/setup/full-setup.mdx"; -import MintPrereq from '/snippets/setup/compressed-tokens-mint-prereq.mdx'; -import ActionCode from '/snippets/code-snippets/compressed-token/transfer/action.mdx'; - -The `transfer()` function moves compressed tokens between accounts. -* SPL token transfers that update the existing account -* Compressed token transfers consume input accounts from the sender and create new output accounts for sender and recipient with updated balances. - -SPL token accounts can be compressed in the same transaction with `compress_or_decompress_amount`, if needed. - - - -```typescript function-transfer-compressed-tokens.ts -// Transfer compressed tokens -const transactionSignature = await transfer( - rpc, - payer, - mint, // SPL mint with SPL interface for compression - amount, - payer, - recipient, // destination address (toAddress parameter) -) -``` - -## Get Started - - - -### Transfer Compressed Tokens - - - - - - - - - -# Troubleshooting - - - - -The sender doesn't have enough compressed tokens for the requested transfer amount. - -```typescript -// Check current balance first -const tokenAccounts = await rpc.getCompressedTokenAccountsByOwner( - owner.publicKey, - { mint } -); - -if (tokenAccounts.items.length === 0) { - throw new Error("No compressed token accounts found"); -} - -// Calculate total balance across all accounts -const totalBalance = tokenAccounts.items.reduce( - (sum, account) => sum.add(account.parsed.amount), - new BN(0) -); - -console.log("Available balance:", totalBalance.toString()); - -// Ensure transfer amount doesn't exceed balance -if (new BN(transferAmount).gt(totalBalance)) { - throw new Error(`Transfer amount ${transferAmount} exceeds balance ${totalBalance.toString()}`); -} -``` - - - - - -The transfer requires more than 4 compressed accounts, which exceeds the transaction limit. - -```typescript -// Error message: "Account limit exceeded: max X (4 accounts) per transaction. -// Total balance: Y (Z accounts). Consider multiple transfers to spend full balance." - -// Split into multiple smaller transfers -const maxTransferPerTx = 1_000_000_000; // Adjust based on your account sizes - -if (transferAmount > maxTransferPerTx) { - console.log("Large transfer detected, splitting into multiple transactions..."); - - let remainingAmount = transferAmount; - while (remainingAmount > 0) { - const currentTransfer = Math.min(remainingAmount, maxTransferPerTx); - - await transfer( - rpc, - payer, - mint, - currentTransfer, - owner, - recipient - ); - - remainingAmount -= currentTransfer; - console.log(`Transferred ${currentTransfer}, remaining: ${remainingAmount}`); - } -} -``` - - - - -# Advanced Configuration - - - - -Transfer to multiple recipients in separate transactions: - -```typescript -const recipients = [ - Keypair.generate().publicKey, - Keypair.generate().publicKey, - Keypair.generate().publicKey, -]; - -const amounts = [ - 100_000_000, // 0.1 tokens - 200_000_000, // 0.2 tokens - 150_000_000, // 0.15 tokens -]; - -for (let i = 0; i < recipients.length; i++) { - const transactionSignature = await transfer( - rpc, - payer, - mint, - amounts[i], - owner, - recipients[i], - ); - - console.log(`Transfer ${i + 1} completed:`, transactionSignature); -} -``` - - - - - -Transfer tokens using delegate authority: - -```typescript -import { approve, transferDelegated } from '@lightprotocol/compressed-token'; - -// 1. Owner approves delegate -await approve( - rpc, - payer, - mint, - amount, - owner, // Signer - delegate.publicKey, // PublicKey -); - -// 2. Delegate transfers tokens -await transferDelegated( - rpc, - payer, - mint, - transferAmount, - delegate, // Signer - named "owner" in SDK - recipient, -); -``` - - - - -# Next Steps - - diff --git a/compressed-tokens/overview.mdx b/compressed-tokens/overview.mdx index cab4c9e9..93273753 100644 --- a/compressed-tokens/overview.mdx +++ b/compressed-tokens/overview.mdx @@ -1,6 +1,6 @@ --- -title: Overview -description: "Overview to compressed tokens and guides with full code examples. Use for distributing tokens (eg rewards, airdrops) or creating associated token accounts for users." +title: "Compressed Tokens" +description: "Compressed tokens are the most efficient way to distribute SPL tokens (eg rewards, airdrops). For other token purposes use Light Token." keywords: ["compressed tokens on solana", "scalable token distribution on solana", "infrastructure for token distribution", "airdrop infrastructure on solana", "launchpad infrastructure on solana"] --- @@ -9,10 +9,16 @@ import AdvancedGuidesTable from "/snippets/overview-tables/compressed-tokens-adv import SetupEnvironment from "/snippets/setup/setup-environment-tabs.mdx"; import InstallDependencies from "/snippets/setup/install-dependencies-codegroup.mdx"; import { TokenAccountCompressedVsSpl } from "/snippets/jsx/token-account-compressed-vs-spl.jsx"; +import AgentSkillAirdrop from "/snippets/setup/agent-skill-airdrop.mdx"; - - **Compressed Tokens are supported by leading Solana wallets such as Phantom and Backpack.** - + + + +**Note: The new [Light Token Program Beta](/light-token/welcome)** is live on Solana Devnet with mainnet expected in Q1 2026. +We recommend to use Light Token for most purposes except airdrops and other forms of token distribution. +The SDK for compressed tokens can still be used once Light Token is on Solana Mainnet. +For production use today, use Compressed Tokens, which are on Solana Mainnet. + | Creation | Solana | Compressed | | :---------------- | :------------------ | :----------------- | @@ -22,16 +28,20 @@ import { TokenAccountCompressedVsSpl } from "/snippets/jsx/token-account-compres 2. Compressed token accounts are rent-free. 3. Any light-token or SPL token can be compressed/decompressed at will. + + **Compressed Tokens are supported by leading Solana wallets such as Phantom and Backpack.** + + ## Recommended Usage of Compressed Tokens Distribute tokens without paying upfront rent per recipient. @@ -43,44 +53,38 @@ import { TokenAccountCompressedVsSpl } from "/snippets/jsx/token-account-compres title="Compress SPL Token Accounts" icon="chevron-right" color="#0066ff" - href="/compressed-tokens/guides/compress-spl-token-account" + href="https://github.com/Lightprotocol/examples-zk-compression/blob/main/compressed-token-cookbook/actions/compress.ts" horizontal /> -# Get Started - - - - - -### Install dependencies - - - +## RPC methods - +The Photon API provides ZK Compression methods that extend the default Solana JSON RPC API. -### Set up your developer environment + - +## Guides - +The SDK for compressed tokens can be used but is not maintained. +Use [Light Token](/light-token/welcome) for other purposes than token distribution or storage of inactive tokens. - +| | | +|---------|------| +| Compressed token cookbook | [GitHub](https://github.com/Lightprotocol/examples-zk-compression/tree/main/compressed-token-cookbook) | +| Token distribution | [GitHub](https://github.com/Lightprotocol/examples-zk-compression/tree/main/example-token-distribution) | +| Web client | [GitHub](https://github.com/Lightprotocol/examples-zk-compression/tree/main/example-web-client) | - - - - - - ### Basic Guides - - +--- - - ### Advanced Guides - - +## Didn't find what you were looking for? - + +Reach out! [Telegram](https://t.me/swen_light) | [email](mailto:support@lightprotocol.com) | [Discord](https://discord.com/invite/7cJ8BhAXhu) + diff --git a/convert_prompts.py b/convert_prompts.py new file mode 100644 index 00000000..31d76069 --- /dev/null +++ b/convert_prompts.py @@ -0,0 +1,177 @@ +#!/usr/bin/env python3 +"""Convert AI prompt snippet MDX files to include component wrapper.""" + +import os +import re +import sys + +BASE = "/home/tilo/Workspace/docs-main-reorder/snippets/ai-prompts" + +# Skip templates and already-converted files +SKIP_FILES = { + "template.mdx", + "rust-template.mdx", + "cpi-program-template.mdx", + "anchor-program-template.mdx", +} + +ALREADY_DONE = { + os.path.join("ts-cookbook", "create-mint.mdx"), +} + + +def find_mdx_files(base_dir): + """Find all .mdx files recursively.""" + results = [] + for root, _dirs, files in os.walk(base_dir): + for f in files: + if not f.endswith(".mdx"): + continue + rel = os.path.relpath(os.path.join(root, f), base_dir) + if f in SKIP_FILES: + print(f" SKIP (template): {rel}") + continue + if rel in ALREADY_DONE: + print(f" SKIP (already done): {rel}") + continue + results.append(os.path.join(root, f)) + return sorted(results) + + +def extract_description(content): + """Extract description from frontmatter line 2.""" + for line in content.split("\n"): + line = line.strip() + if line.startswith("description:"): + desc = line[len("description:"):].strip() + # Remove surrounding quotes if present + if (desc.startswith('"') and desc.endswith('"')) or \ + (desc.startswith("'") and desc.endswith("'")): + desc = desc[1:-1] + return desc + return None + + +def detect_fence(text): + """Detect the fence type used (backtick or tilde).""" + first_line = text.split("\n")[0].strip() + if first_line.startswith("~~~~"): + return "~~~~" + if first_line.startswith("```"): + return "```" + return None + + +def strip_fence(text, fence): + """Remove opening and closing fence lines.""" + lines = text.split("\n") + + # Find opening fence + start = 0 + for i, line in enumerate(lines): + if line.strip().startswith(fence): + start = i + 1 + break + + # Find closing fence (last occurrence) + end = len(lines) + for i in range(len(lines) - 1, -1, -1): + if lines[i].strip() == fence: + end = i + break + + return "\n".join(lines[start:end]) + + +def escape_backticks(text): + """Escape backticks for use inside JSX template literal {`...`}.""" + return text.replace("`", "\\`") + + +def convert_file(filepath): + """Convert a single MDX file.""" + with open(filepath, "r") as f: + original = f.read() + + # Skip if already converted + if original.strip().startswith("): {rel}") + return False + + fence = detect_fence(original) + if fence is None: + rel = os.path.relpath(filepath, BASE) + print(f" ERROR: no fence detected in {rel}") + return False + + # Extract the content between fences + inner = strip_fence(original, fence) + + # Extract description from frontmatter + desc = extract_description(inner) + if desc is None: + rel = os.path.relpath(filepath, BASE) + print(f" ERROR: no description found in {rel}") + return False + + # Escape description for JSX attribute (double quotes) + desc_attr = desc.replace('"', '"') + + # Build escaped version for JSX template literal + escaped_inner = escape_backticks(inner) + + # Determine the code block fence for the preserved block below + # If original used tildes, the code block should use backticks (```text) + # If original used backticks, keep ```text + code_fence = "```" + + # Build the new file content + # For tilde-fenced files, the code block below uses ~~~~text to preserve internal backticks + if fence == "~~~~": + code_block_open = "~~~~text" + code_block_close = "~~~~" + else: + code_block_open = "```text" + code_block_close = "```" + + output = ( + f'\n' + f'{{`{escaped_inner}`}}\n' + f'\n' + f'\n' + f'{code_block_open}\n' + f'{inner}\n' + f'{code_block_close}\n' + ) + + with open(filepath, "w") as f: + f.write(output) + + return True + + +def main(): + print(f"Scanning {BASE}...\n") + files = find_mdx_files(BASE) + print(f"\nFound {len(files)} files to convert.\n") + + converted = 0 + errors = 0 + skipped = 0 + + for filepath in files: + rel = os.path.relpath(filepath, BASE) + result = convert_file(filepath) + if result is True: + converted += 1 + print(f" OK: {rel}") + elif result is False: + # Could be skip or error — message already printed + pass + + print(f"\nDone: {converted} converted") + + +if __name__ == "__main__": + main() diff --git a/docs.json b/docs.json index e15a5e8d..66f0bac8 100644 --- a/docs.json +++ b/docs.json @@ -1,6 +1,6 @@ { "$schema": "https://mintlify.com/docs.json", - "theme": "aspen", + "theme": "maple", "name": "Light Protocol", "colors": { "primary": "#0066FF", @@ -20,216 +20,123 @@ } }, "navigation": { - "tabs": [ + "anchors": [ { - "tab": "Home", - "groups": [ - { - "group": "Overview", - "pages": [ - "home" - ] - } - ] - }, - { - "tab": "Light Token Program", + "anchor": "Documentation", + "icon": "book", "groups": [ { "group": "Get Started", "pages": [ - "light-token/welcome", - "light-token/quickstart", - "light-token/faq" - ] - }, - { - "group": "DeFi", - "pages": [ - "light-token/defi/routers", - "light-token/defi/programs", - "light-token/defi/programs-pinocchio" - ] - }, - { - "group": "Data Streaming", - "pages": [ - "light-token/toolkits/for-streaming-tokens", - "light-token/toolkits/for-streaming-mints" - ] - }, - { - "group": "Toolkits", - "pages": [ - "light-token/toolkits/overview", - "light-token/toolkits/for-payments", - "light-token/toolkits/for-wallets" - ] - }, - { - "group": "Cookbook", - "pages": [ - "light-token/cookbook/overview", + "home", { - "group": "Examples", - "expanded": true, + "group": "Light Token", "pages": [ - "light-token/examples/client", - "light-token/examples/program" + "light-token/welcome", + "light-token/faq", + "light-token/quickstart", + { + "group": "Cookbook", + "pages": [ + "light-token/cookbook/create-mint", + "light-token/cookbook/create-ata", + "light-token/cookbook/create-token-account", + "light-token/cookbook/mint-to", + "light-token/cookbook/transfer-interface", + "light-token/cookbook/transfer-checked", + "light-token/cookbook/approve-revoke", + "light-token/cookbook/freeze-thaw", + "light-token/cookbook/wrap-unwrap", + "light-token/cookbook/load-ata", + "light-token/cookbook/close-token-account", + "light-token/cookbook/burn" + ] + }, + { + "group": "Examples", + "expanded": true, + "pages": [ + "light-token/examples/client", + "light-token/examples/program" + ] + } ] }, { - "group": "Recipes", - "expanded": true, + "group": "PDA Accounts", "pages": [ - "light-token/cookbook/create-mint", - "light-token/cookbook/create-ata", - "light-token/cookbook/create-token-account", - "light-token/cookbook/mint-to", - "light-token/cookbook/transfer-interface", - "light-token/cookbook/transfer-checked", - "light-token/cookbook/approve-revoke", - "light-token/cookbook/freeze-thaw", - "light-token/cookbook/wrap-unwrap", - "light-token/cookbook/load-ata", - "light-token/cookbook/close-token-account", - "light-token/cookbook/burn" - + "pda/overview", + "pda/light-pda/overview", + { + "group": "Compressed PDA", + "pages": [ + "pda/compressed-pdas/overview", + "pda/compressed-pdas/guides/client-guide", + { + "group": "Program Guides", + "expanded": true, + "pages": [ + "pda/compressed-pdas/guides", + "pda/compressed-pdas/guides/how-to-create-compressed-accounts", + "pda/compressed-pdas/guides/how-to-update-compressed-accounts", + "pda/compressed-pdas/guides/how-to-close-compressed-accounts", + "pda/compressed-pdas/guides/how-to-reinitialize-compressed-accounts", + "pda/compressed-pdas/guides/how-to-burn-compressed-accounts" + ] + }, + "pda/compressed-pdas/program-examples", + { + "group": "Error Cheatsheet", + "pages": [ + "resources/error-cheatsheet", + "resources/error-cheatsheet/debug-0x179b-6043-proofverificationfailed" + ] + } + ] + } ] } ] }, { - "group": "Learn", + "group": "DeFi", "pages": [ - "learn/light-token-standard", - "ai-tools/guide" + "light-token/defi/routers", + "light-token/defi/programs", + "light-token/defi/programs-pinocchio" ] }, { - "group": "SDK Reference", - "pages": [ - "api-reference/libraries/light-sdk", - "api-reference/libraries/light-token", - "api-reference/libraries/light-program-test", - "api-reference/libraries/light-client", - "api-reference/libraries/stateless-js", - "api-reference/libraries/compressed-token" - ] - } - ] - }, - { - "tab": "ZK Compression", - "groups": [ - { - "group": "Get Started", + "group": "Data Streaming", "pages": [ - "welcome", - "quickstart" + "light-token/toolkits/for-streaming-mints", + "light-token/toolkits/for-streaming-tokens" ] }, { - "group": "ZK", + "group": "Stablecoin Payments", "pages": [ - "zk/overview", - "zk/examples" + "light-token/toolkits/for-payments", + "pda/compressed-pdas/guides/how-to-create-nullifier-pdas" ] }, { - "group": "Compressed PDAs", - "expanded": true, + "group": "Wallets", "pages": [ - "compressed-pdas/overview", - "client-library/client-guide", - { - "group": "Program Guides", - "pages": [ - "compressed-pdas/guides", - "compressed-pdas/guides/how-to-create-compressed-accounts", - "compressed-pdas/guides/how-to-update-compressed-accounts", - "compressed-pdas/guides/how-to-close-compressed-accounts", - "compressed-pdas/guides/how-to-reinitialize-compressed-accounts", - "compressed-pdas/guides/how-to-burn-compressed-accounts", - "compressed-pdas/guides/how-to-create-nullifier-pdas" - ] - }, - "compressed-pdas/program-examples", - "compressed-pdas/solana-attestation-service" + "light-token/toolkits/for-wallets", + "light-token/toolkits/for-privy" ] }, { - "group": "Compressed Tokens", + "group": "Other Use Cases", "pages": [ - "compressed-tokens/overview", - "compressed-tokens/for-privy", - "compressed-tokens/advanced-guides/airdrop", + "compressed-tokens/airdrop", + "pda/compressed-pdas/solana-attestation-service", { - "group": "Cookbook", + "group": "ZK", "pages": [ - "compressed-tokens/guides/create-compressed-token-accounts", - "compressed-tokens/guides/mint-compressed-tokens", - "compressed-tokens/guides/transfer-compressed-tokens", - "compressed-tokens/guides/compress-decompress", - "compressed-tokens/guides/compress-spl-token-account", - "compressed-tokens/guides/create-mint-with-token-pool", - "compressed-tokens/guides/add-token-pools-to-mint-accounts", - "compressed-tokens/guides/merge-compressed-token-accounts", - "compressed-tokens/guides/delegate" - ] - }, - { - "group": "Implementation Guides", - "pages": [ - { - "group": "Integration", - "expanded": true, - "pages": [ - "compressed-tokens/advanced-guides/how-to-combine-operations-in-one-transaction", - "compressed-tokens/advanced-guides/add-wallet-support-for-compressed-tokens", - "compressed-tokens/advanced-guides/use-token-2022-with-compression" - ] - }, - { - "group": "Examples", - "expanded": true, - "pages": [ - "compressed-tokens/advanced-guides/example-token-distribution" - ] - } - ] - } - ] - }, - { - "group": "JSON RPC Methods", - "pages": [ - "api-reference/json-rpc-methods/overview", - { - "group": "Methods", - "pages": [ - "api-reference/json-rpc-methods/methods", - "api-reference/json-rpc-methods/getcompressedaccount", - "api-reference/json-rpc-methods/getcompressedaccountsbyowner", - "api-reference/json-rpc-methods/getcompressedbalancebyowner", - "api-reference/json-rpc-methods/getcompressedbalance", - "api-reference/json-rpc-methods/getcompressedminttokenholders", - "api-reference/json-rpc-methods/getcompressedtokenaccountbalance", - "api-reference/json-rpc-methods/getcompressedtokenaccountbydelegate", - "api-reference/json-rpc-methods/getcompressedtokenaccountsbyowner", - "api-reference/json-rpc-methods/getcompressedtokenbalancesbyowner", - "api-reference/json-rpc-methods/getcompressionsignaturesforaccount", - "api-reference/json-rpc-methods/getcompressionsignaturesforaddress", - "api-reference/json-rpc-methods/getcompressionsignaturesforowner", - "api-reference/json-rpc-methods/getcompressionsignaturesfortokenowner", - "api-reference/json-rpc-methods/getindexerhealth", - "api-reference/json-rpc-methods/getindexerslot", - "api-reference/json-rpc-methods/getlatestcompressionsignatures", - "api-reference/json-rpc-methods/getlatestnonvotingsignatures", - "api-reference/json-rpc-methods/getmultiplecompressedaccounts", - "api-reference/json-rpc-methods/getmultiplenewaddressproofs", - "api-reference/json-rpc-methods/gettransactionwithcompressioninfo", - "api-reference/json-rpc-methods/getvalidityproof" + "zk/overview", + "zk/examples" ] } ] @@ -237,8 +144,10 @@ { "group": "Learn", "pages": [ + "learn/overview", + "learn/light-token-standard", { - "group": "Core Concepts", + "group": "Core Concepts ZK Compression", "pages": [ "learn/core-concepts", "learn/core-concepts/compressed-account-model", @@ -246,50 +155,80 @@ "learn/core-concepts/transaction-lifecycle", "learn/core-concepts/considerations" ] - }, - "ai-tools/guide" + } ] }, { - "group": "Resources", + "group": "Reference", "pages": [ + "api-reference/sdk", + "resources/anchor-constraints", + "resources/addresses-and-urls", + "references/terminology", "resources/cli-installation", - { - "group": "Error Cheatsheet", - "pages": [ - "resources/error-cheatsheet", - "resources/error-cheatsheet/debug-0x179b-6043-proofverificationfailed" - ] - }, - { - "group": "SDKs", - "pages": [ - "resources/sdks/client-development", - "resources/sdks/program-development" - ] - }, - "resources/addresses-and-urls" + "references/migration-v1-to-v2", + "compressed-tokens/overview", + "references/node-operators", + "references/whitepaper", + "references/security" ] - }, + } + ] + }, + { + "anchor": "JSON RPC Methods", + "icon": "code", + "groups": [ { - "group": "References", + "group": "JSON RPC Methods", "pages": [ - "references/whitepaper", - "references/node-operators", - "references/terminology", - "references/migration-v1-to-v2", - "support", - "references/security" + "api-reference/json-rpc-methods/overview", + "api-reference/json-rpc-methods/getcompressedaccount", + "api-reference/json-rpc-methods/getcompressedaccountsbyowner", + "api-reference/json-rpc-methods/getcompressedbalancebyowner", + "api-reference/json-rpc-methods/getcompressedtokenaccountsbyowner", + "api-reference/json-rpc-methods/getcompressedtokenbalancesbyowner", + "api-reference/json-rpc-methods/getvalidityproof", + "api-reference/json-rpc-methods/getcompressionsignaturesforaddress", + "api-reference/json-rpc-methods/getcompressionsignaturesforowner", + "api-reference/json-rpc-methods/gettransactionwithcompressioninfo", + "api-reference/json-rpc-methods/getindexerhealth", + "api-reference/json-rpc-methods/getindexerslot", + "api-reference/json-rpc-methods/getcompressedbalance", + "api-reference/json-rpc-methods/getcompressedminttokenholders", + "api-reference/json-rpc-methods/getcompressedtokenaccountbalance", + "api-reference/json-rpc-methods/getcompressedtokenaccountbydelegate", + "api-reference/json-rpc-methods/getcompressionsignaturesforaccount", + "api-reference/json-rpc-methods/getcompressionsignaturesfortokenowner", + "api-reference/json-rpc-methods/getlatestcompressionsignatures", + "api-reference/json-rpc-methods/getlatestnonvotingsignatures", + "api-reference/json-rpc-methods/getmultiplecompressedaccounts", + "api-reference/json-rpc-methods/getmultiplenewaddressproofs" ] - }, + } + ] + }, + { + "anchor": "AI Tools", + "icon": "robot", + "groups": [ { - "group": "SDK Reference", + "group": "AI Tools", "pages": [ - "api-reference/libraries/stateless-js", - "api-reference/libraries/compressed-token", - "api-reference/libraries/light-client", - "api-reference/libraries/light-sdk", - "api-reference/libraries/light-program-test" + "ai-tools/guide", + "ai-tools/prompts" + ] + } + ] + }, + { + "anchor": "Support", + "icon": "headset", + "groups": [ + { + "group": "Support", + "pages": [ + "support" ] } ] @@ -317,15 +256,14 @@ "navbar": { "links": [ { - "label": "Get Support", - "icon": "discord", - "href": "https://discord.gg/CYvjBgzRFP" + "label": "Changelog", + "icon": "megaphone", + "href": "https://github.com/Lightprotocol/light-protocol/releases" }, { - "type": "button", "label": "GitHub", "icon": "github", - "href": "https://github.com/Lightprotocol/light-protocol" + "href": "https://github.com/Lightprotocol" } ] }, @@ -365,11 +303,31 @@ "redirects": [ { "source": "/landing", - "destination": "/welcome" + "destination": "https://zkcompression.com/home" + }, + { + "source": "/welcome", + "destination": "https://zkcompression.com/home" + }, + { + "source": "/learn/ai-tools-guide", + "destination": "https://zkcompression.com/ai-tools/guide" + }, + { + "source": "/resources/sdks/client-development", + "destination": "https://zkcompression.com/api-reference/sdk" + }, + { + "source": "/resources/sdks/program-development", + "destination": "https://zkcompression.com/api-reference/sdk" + }, + { + "source": "/compressed-tokens/for-privy", + "destination": "https://zkcompression.com/light-token/toolkits/for-privy" }, { - "source": "https://www.zkcompression.com/learn/ai-tools-guide", - "destination": "https://www.zkcompression.com/ai-tools/guide" + "source": "/client-library/client-guide", + "destination": "https://zkcompression.com/pda/compressed-pdas/guides/client-guide" } ] -} \ No newline at end of file +} diff --git a/home.mdx b/home.mdx index 664e469e..c3a93ed8 100644 --- a/home.mdx +++ b/home.mdx @@ -1,34 +1,29 @@ --- title: "Home" +sidebarTitle: "Introduction" mode: "custom" -keywords: ["light protocol", "zk compression on solana", "scalable solana infrastructure", "rent free accounts on solana", "create tokens on solana", "scalable infrastructure for solana apps", "privacy on solana", "shielded transactions on solana"] +keywords: ["solana tokens", "spl tokens", "light protocol", "helius", "zk compression on solana", "scalable solana infrastructure", "rent free accounts on solana", "create tokens on solana", "scalable infrastructure for solana apps", "privacy on solana", "shielded transactions on solana"] --- import { Footer } from "/snippets/jsx/footer.jsx"; import { HeroCubeGrid } from "/snippets/jsx/hero-cube-grid.jsx"; import { LiquidGlassPill } from "/snippets/jsx/liquid-glass-pill.jsx"; -import WelcomePageInstall from "/snippets/setup/welcome-page-install.mdx"; +import { PartnerLogos } from "/snippets/jsx/partner-logos.jsx"; +import SdkReference from "/snippets/overview-tables/sdk-reference.mdx"; {/* Hero with animation - styles in style.css (no flash) */}
- + + +
{/* Content container - using Tailwind classes to avoid flash */}
- - - High performance token standard for rent-free DeFi and Payments. - - - Core primitives for rent-free tokens & accounts. - - - ## Features @@ -37,203 +32,138 @@ import WelcomePageInstall from "/snippets/setup/welcome-page-install.mdx"; Works with existing programs and accounts. -## Quickstart +## Light Token - - -### Installation - - - - -### Get started - +High-performance token standard that reduces the cost of mint and token accounts by 200x +while being more CU efficient than SPL on hot paths. - - + + Introduction to the Light Token program. + -## DeFi Integration +### DeFi - Build rent-free AMMs and DeFi programs with minimal code changes. + Build rent-free AMMs and DeFi programs. - Add support for rent-free AMMs to your aggregator or router. + Add support for rent-free AMMs to your aggregator. + + + High-performance DeFi programs with Pinocchio. -## Toolkits +### Payments - - - - Integrate light-token APIs with familiar SPL patterns. - - - - Allow users to display and swap light-tokens. - - - {/* - Stream mint events from the network in real-time. - */} - - {/* - Stream token events from the network in real-time. - */} - - - - - ZK Compression is the most efficient way to distribute SPL tokens. - - - Add rent-free SPL token accounts and transfers to your Privy embedded wallet. - - - Allow users to display and swap compressed tokens. - - - - Integrate Token-2022 extensions with compressed tokens. - - - - Common token distribution flows (airdrops, payments, rewards). - - - - - - Deterministically derived addresses to prevent double spending. - - - - Small proof size and fast verification. - - - - Use existing state Merkle trees with RPC indexer support. - - - - + + + Guide to integrate light-token APIs with comparison to SPL. + + + Prevent onchain instructions from being executed more than once. + + -## Cookbooks +### Wallets - - Program and client guides for mints, token accounts, and transfers. + + Guide for Wallet Applications to let users display and swap light-tokens. - - Client guides for compressed token accounts. + + Add light-tokens to Privy embedded wallets. - - Program and client guides for rent-free PDA accounts. + + +### Data Streaming + + + + Stream mint events from the network in real-time. + + + Stream token events from the network in real-time. + + + +### Guides and Examples + + + + Guides for mints, token accounts, and transfers. - - Build with compressed attestations using Rust or Typescript. + + TypeScript and Rust client examples. + + + Program examples for Light Token Anchor macros, instructions and Pinocchio. -## Using AI in Development +## PDA Accounts + + + + Solana PDAs with sponsored rent-exemption that can be implemented with minimal code changes. + Use like any other PDA, e.g. in your DeFi program. + + + Compressed PDAs to store user, app, or other infrequently accessed state without rent-exemption. Fully compatible with existing Solana programs, but requires custom logic. + + + +## Other Use Cases + + + + Distribute tokens on Solana 5000x cheaper. Merkle distributor and simple claim programs for airdrops with claim. + + + Credential system for KYC verification, professional badges, and compliance credentials in minutes. + + + Build ZK programs on Solana with groth-16 proofs and merklelized state. + + + +## AI Tools + + + + +Install orchestrator agent skill or view [skill.md](https://www.zkcompression.com/skill.md): -Download agent skill or view [skill.md](https://www.zkcompression.com/skill.md): ```bash npx skills add https://zkcompression.com ``` -| | | -| :------- | :--------------------------------------------------------------------------- | -| MCP | Connect AI tools to the Light Protocol repository via Model Context Protocol | -| DeepWiki | Use Deepwiki for advanced AI assistance with your development. | +Install or view dedicated agent skills: https://github.com/Lightprotocol/skills + + + +Add the marketplace and install: + +``` +/plugin marketplace add Lightprotocol/skills +/plugin install solana-rent-free-dev +``` + + +1. Open Settings (**Cmd+Shift+J** / **Ctrl+Shift+J**) +2. Navigate to **Rules & Commands** → **Project Rules** → **Add Rule** → **Remote Rule (GitHub)** +3. Enter: `https://github.com/Lightprotocol/skills.git` + + +``` +npx skills add Lightprotocol/skills +``` + + + + +Connect AI tools to the Light Protocol repository via MCP and DeepWiki. @@ -268,6 +198,8 @@ codex mcp add deepwiki -- npx -y mcp-remote@latest https://mcp.deepwiki.com/mcp ``` + + - - View security audits and formal verification. + + + Learn core concepts of the Light token program and ZK Compression Core. - - Learn core concepts of the Light token program. + + Syntax reference for #[light_account] constraints for PDA, mint, token, and associated token accounts. - - Learn core concepts of ZK Compression. + + RPC endpoints and addresses for programs, Merkle trees, and other accounts. - - -## SDK Reference - -### TypeScript - - - - Client SDK for Light Token and Compressed Accounts - - - Client for Light Token and Compressed Tokens. + + View security audits and formal verification. -### Rust +## SDK Reference - - - Rust client for Light Token and ZK Compression. - - - Core SDK for on-chain programs. - - - Testing framework for programs. - - +
diff --git a/images/helius-black.png b/images/helius-black.png new file mode 100644 index 00000000..af570ba6 Binary files /dev/null and b/images/helius-black.png differ diff --git a/images/helius-white.png b/images/helius-white.png new file mode 100644 index 00000000..155883f9 Binary files /dev/null and b/images/helius-white.png differ diff --git a/images/light-wordmark.svg b/images/light-wordmark.svg new file mode 100644 index 00000000..46f15005 --- /dev/null +++ b/images/light-wordmark.svg @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/learn/core-concepts/compressed-account-model.mdx b/learn/core-concepts/compressed-account-model.mdx index bb0355b3..51b5554f 100644 --- a/learn/core-concepts/compressed-account-model.mdx +++ b/learn/core-concepts/compressed-account-model.mdx @@ -20,6 +20,11 @@ Compressed accounts store state and are similar to regular Solana accounts but w These differences make compressed accounts rent-free and allow the protocol to store state as calldata on the Solana ledger instead of the costly on-chain account space. + +Compressed PDAs are compressed accounts with an address.
+Compressed Token accounts are compressed accounts that don't need an address. + + # In a Nutshell Transactions can use compressed account data inside Solana's virtual machine as if it were stored on-chain by combining state compression and zero-knowledge proofs: @@ -183,42 +188,6 @@ pub struct CompressedAccountData { - `data_hash`: Hash of the `data` field (32 bytes). - When computing the compressed account hash for the state tree, the protocol uses this fixed-size hash instead of the variable-length data bytes. -# Compressed Token Account - -Compressed token accounts store token balance, owner, and other information of token accounts (SPL, Token-2022, or Light). - -1. Any Solana token account can be compressed/decompressed at will. -2. We recommend to use compressed tokens for token distribution. - - - Learn how the Light token program uses ZK Compression under the hood - [here](/learn/light-token-standard). - - - - - - Diagram showing compressed token account structure with three components: Hash (identifier for compressed token account in purple box), Account (struct containing Data bytes, Executable flag, Lamports balance, and Address set to None), and AccountData (containing Mint, Owner, Amount, and Extensions fields marked as unimplemented) - - - - ```rust - pub struct TokenData { - pub mint: Pubkey, - pub owner: Pubkey, - pub amount: u64, - pub delegate: Option, - pub state: u8, - /// Placeholder for TokenExtension tlv data (unimplemented) - pub tlv: Option>, - } - ``` - - - # Next Steps \ No newline at end of file diff --git a/learn/core-concepts/merkle-trees-validity-proofs.mdx b/learn/core-concepts/merkle-trees-validity-proofs.mdx index 24e84277..5d0c4b4d 100644 --- a/learn/core-concepts/merkle-trees-validity-proofs.mdx +++ b/learn/core-concepts/merkle-trees-validity-proofs.mdx @@ -105,7 +105,7 @@ Two **state tree versions** with different proof mechanisms are currently suppor - **V1 state trees**: Always require the full 128-byte ZK proof - **V2 batched state trees**: Can use `prove_by_index` optimization that verifies the account exists with only one byte instead of 128-bytes. -**V2** optimizes optimize compute unit consumption by up to 70% and is **currently on Devnet**. +**V2** optimizes compute unit consumption by up to 70%. When using V2 trees, RPC requests automatically choose the proof mechanism. @@ -149,7 +149,7 @@ Two **address tree versions** are currently supported: - **V1 address trees** height 26 (\~67 million addresses). - **V2 batched address trees** with height 40 (\~1 trillion addresses). -**V2** optimizes optimize compute unit consumption by up to 70% and is **currently on Devnet**. +**V2** optimizes compute unit consumption by up to 70%. When using V2 trees, RPC requests automatically choose the proof mechanism. diff --git a/learn/core-concepts/transaction-lifecycle.mdx b/learn/core-concepts/transaction-lifecycle.mdx index 3b257dc7..f234959d 100644 --- a/learn/core-concepts/transaction-lifecycle.mdx +++ b/learn/core-concepts/transaction-lifecycle.mdx @@ -138,7 +138,7 @@ The Solana program executing the state transition _**Data**_** -> **_**Data'**_ - `validity proof`: 128-byte ZK proof that verifies the current account hash exists in the state tree -See this [guide to update a compressed account](/compressed-pdas/guides/how-to-update-compressed-accounts). +See this [guide to update a compressed account](/pda/compressed-pdas/guides/how-to-update-compressed-accounts). diff --git a/learn/light-token-standard.mdx b/learn/light-token-standard.mdx index 3327c50b..1c944842 100644 --- a/learn/light-token-standard.mdx +++ b/learn/light-token-standard.mdx @@ -1,6 +1,6 @@ --- -title: Core Concepts to the Light Token Program (Beta) -sidebarTitle: Core Concepts (Light Token) +title: Core concepts of the Light Token program (Beta) +sidebarTitle: Core Concepts Light Token description: The Light Token Program is a high performance token program that reduces the cost of account creations by 200x, while being more CU efficient than SPL on hot paths. keywords: ["light token standard on solana", "token 2022 on solana", "token extensions on solana", "spl token on solana", "rent free tokens on solana"] --- diff --git a/learn/overview.mdx b/learn/overview.mdx new file mode 100644 index 00000000..9e4bedf2 --- /dev/null +++ b/learn/overview.mdx @@ -0,0 +1,55 @@ +--- +title: Overview of core concepts +sidebarTitle: Overview +description: Learn about Light Token and ZK Compression Core. +keywords: ["zk compression on solana", "scalable solana infrastructure", "compressed accounts on solana", "privacy on solana", "zk on solana", "shielded transactions on solana"] +--- + + +## What is Light Token? + +Light token is a high-performance token standard that is functionally equivalent to SPL, but stores mint and token accounts more efficiently. This reduces account creation cost while being more CU efficient than SPL on hot paths. + + + + + + + + +## What is ZK Compression? + +ZK Compression is a Solana account primitive that lets you create tokens and PDAs without rent-exemption with L1 performance and security. +The Light Token Program uses ZK Compression under the hood. + +Storage cost of Solana accounts are reduced by combining generalized state compression and zero-knowledge proofs. + + + + State compression stores account data on the Solana ledger instead of in millions of on-chain accounts. Only a small fingerprint of all accounts is stored on-chain for cryptographic integrity. Using Light Protocol, programs can use the account data inside Solana's virtual machine as if it were stored on-chain. + + + + The protocol uses 128 byte zero-knowledge proofs (validity proofs) to verify the integrity of + the compressed accounts. By default, this is all done under the hood. You can fetch validity + proofs from RPC providers that support ZK Compression. + + + + \ No newline at end of file diff --git a/light-token/cookbook/approve-revoke.mdx b/light-token/cookbook/approve-revoke.mdx index ef6cad7d..d939d82e 100644 --- a/light-token/cookbook/approve-revoke.mdx +++ b/light-token/cookbook/approve-revoke.mdx @@ -28,6 +28,10 @@ import RevokeActionCode from "/snippets/code-snippets/light-token/approve-revoke import RevokeInstructionCode from "/snippets/code-snippets/light-token/approve-revoke/rust-client/revoke-instruction.mdx"; import ApproveAnchorProgramCode from "/snippets/code-snippets/light-token/approve/anchor-program/full-example.mdx"; import RevokeAnchorProgramCode from "/snippets/code-snippets/light-token/revoke/anchor-program/full-example.mdx"; +import AgentSkillGeneric from "/snippets/setup/agent-skill-generic.mdx"; +import ApproveRevokeAiPrompt from "/snippets/ai-prompts/ts-cookbook/approve-revoke.mdx"; +import RustApproveRevokeAiPrompt from "/snippets/ai-prompts/rust-cookbook/approve-revoke.mdx"; +import ProgramApproveRevokeAiPrompt from "/snippets/ai-prompts/program-cookbook/approve-revoke.mdx"; 1. Approve grants a delegate permission to transfer up to a specified amount of tokens from your account. * Each token account can have only one delegate at a time. @@ -35,6 +39,8 @@ import RevokeAnchorProgramCode from "/snippets/code-snippets/light-token/revoke/ 2. Revoke removes all delegate permissions from a Light Token account. 3. Only the token account owner can approve or revoke delegates. + + @@ -71,6 +77,8 @@ import RevokeAnchorProgramCode from "/snippets/code-snippets/light-token/revoke/ [here](https://github.com/Lightprotocol/examples-light-token/tree/main/typescript-client/actions). + + ### Approve a delegate @@ -88,6 +96,11 @@ import RevokeAnchorProgramCode from "/snippets/code-snippets/light-token/revoke/ + + + + + @@ -118,6 +131,8 @@ import RevokeAnchorProgramCode from "/snippets/code-snippets/light-token/revoke/ + + ### Prerequisites @@ -159,8 +174,15 @@ import RevokeAnchorProgramCode from "/snippets/code-snippets/light-token/revoke/ + + + + + + + Find [a full code example at the end](#full-code-example). @@ -286,6 +308,11 @@ revoke_cpi.invoke_signed(&[signer_seeds])?; + + + + + diff --git a/light-token/cookbook/burn.mdx b/light-token/cookbook/burn.mdx index 8496e376..c7a7cde0 100644 --- a/light-token/cookbook/burn.mdx +++ b/light-token/cookbook/burn.mdx @@ -16,12 +16,17 @@ import { import RustInstructionCode from "/snippets/code-snippets/light-token/burn/rust-client/instruction.mdx"; import BurnCheckedRustInstructionCode from "/snippets/code-snippets/light-token/burn-checked/rust-client/instruction.mdx"; import AnchorProgramCode from "/snippets/code-snippets/light-token/burn/anchor-program/full-example.mdx"; +import AgentSkillGeneric from "/snippets/setup/agent-skill-generic.mdx"; +import RustBurnAiPrompt from "/snippets/ai-prompts/rust-cookbook/burn.mdx"; +import ProgramBurnAiPrompt from "/snippets/ai-prompts/program-cookbook/burn.mdx"; 1. Burn permanently destroys tokens by reducing the balance in a token account. 2. Burned tokens are removed from circulation and decreases the supply tracked on the mint account. 3. Only the token account owner (or approved delegate) can burn tokens. + + @@ -35,6 +40,8 @@ Compare to SPL: language="rust" /> + + ### Prerequisites @@ -58,8 +65,15 @@ Compare to SPL: + + + + + + + Find [a full code example at the end](#full-code-example). @@ -122,6 +136,11 @@ BurnCpi { + + + + + diff --git a/light-token/cookbook/close-token-account.mdx b/light-token/cookbook/close-token-account.mdx index 4ef0caaa..54da981a 100644 --- a/light-token/cookbook/close-token-account.mdx +++ b/light-token/cookbook/close-token-account.mdx @@ -17,6 +17,9 @@ import { } from "/snippets/code-samples/code-compare-snippets.jsx"; import RustInstructionCode from "/snippets/code-snippets/light-token/close-token-account/rust-client/instruction.mdx"; import AnchorProgramCode from "/snippets/code-snippets/light-token/close-token-account/anchor-program/full-example.mdx"; +import AgentSkillGeneric from "/snippets/setup/agent-skill-generic.mdx"; +import RustCloseTokenAccountAiPrompt from "/snippets/ai-prompts/rust-cookbook/close-token-account.mdx"; +import ProgramCloseTokenAccountAiPrompt from "/snippets/ai-prompts/program-cookbook/close-token-account.mdx"; 1. Closing a Light Token account transfers remaining lamports to a destination account and the rent sponsor can reclaim sponsored rent. 2. Light token accounts can be closed by the owner. @@ -27,6 +30,8 @@ closes the account and preserves the balance as compressed token account when th The account is reinstated in flight with the same state the next time it is accessed. + + @@ -42,6 +47,8 @@ Compare to SPL: language="rust" /> + + ### Prerequisites @@ -66,8 +73,15 @@ Compare to SPL: + + + + + + + Find [a full code example at the end](#full-code-example). @@ -129,6 +143,11 @@ CloseAccountCpi { + + + + + diff --git a/light-token/cookbook/create-ata.mdx b/light-token/cookbook/create-ata.mdx index fc52f275..185aae42 100644 --- a/light-token/cookbook/create-ata.mdx +++ b/light-token/cookbook/create-ata.mdx @@ -27,6 +27,11 @@ import RustActionCode from "/snippets/code-snippets/light-token/create-ata/rust- import RustInstructionCode from "/snippets/code-snippets/light-token/create-ata/rust-client/instruction.mdx"; import AnchorProgramCode from "/snippets/code-snippets/light-token/create-ata/anchor-program/full-example.mdx"; import AnchorMacroCode from "/snippets/code-snippets/light-token/create-ata/anchor-macro/full-example.mdx"; +import AgentSkillGeneric from "/snippets/setup/agent-skill-generic.mdx"; +import CreateAtaAiPrompt from "/snippets/ai-prompts/ts-cookbook/create-ata.mdx"; +import RustCreateAtaAiPrompt from "/snippets/ai-prompts/rust-cookbook/create-ata.mdx"; +import ProgramCreateAtaCpiAiPrompt from "/snippets/ai-prompts/program-cookbook/create-ata-cpi.mdx"; +import ProgramCreateAtaMacrosAiPrompt from "/snippets/ai-prompts/program-cookbook/create-ata-macros.mdx"; 1. Associated Light Token accounts can hold token balances of light, SPL, or Token 2022 mints. 2. Light-ATAs are on-chain accounts like SPL ATA's, but the light token program sponsors the rent-exemption cost for you. @@ -35,6 +40,8 @@ import AnchorMacroCode from "/snippets/code-snippets/light-token/create-ata/anch + + @@ -55,6 +62,8 @@ Compare to SPL: [here](https://github.com/Lightprotocol/light-protocol/blob/main/js/compressed-token/src/v3/actions/create-ata-interface.ts). + + @@ -73,6 +82,11 @@ Compare to SPL: + + + + + @@ -90,6 +104,8 @@ Compare to SPL: language="rust" /> + + @@ -118,11 +134,18 @@ Compare to SPL: + + + + + + + Compare to SPL: @@ -212,8 +235,15 @@ CreateAssociatedAccountCpi { + + + + + + + Compare to SPL: @@ -297,6 +327,11 @@ pub ata: UncheckedAccount<'info>, + + + + + diff --git a/light-token/cookbook/create-mint.mdx b/light-token/cookbook/create-mint.mdx index 2cb1be99..431a819b 100644 --- a/light-token/cookbook/create-mint.mdx +++ b/light-token/cookbook/create-mint.mdx @@ -40,6 +40,11 @@ import RustInstructionCode from "/snippets/code-snippets/light-token/create-mint import AnchorProgramCode from "/snippets/code-snippets/light-token/create-mint/anchor-program/full-example.mdx"; import AnchorMacroCode from "/snippets/code-snippets/light-token/create-mint/anchor-macro/full-example.mdx"; import CompressibleRentExplained from "/snippets/compressible-rent-explained.mdx"; +import AgentSkillGeneric from "/snippets/setup/agent-skill-generic.mdx"; +import CreateMintAiPrompt from "/snippets/ai-prompts/ts-cookbook/create-mint.mdx"; +import RustCreateMintAiPrompt from "/snippets/ai-prompts/rust-cookbook/create-mint.mdx"; +import ProgramCreateMintCpiAiPrompt from "/snippets/ai-prompts/program-cookbook/create-mint-cpi.mdx"; +import ProgramCreateMintMacrosAiPrompt from "/snippets/ai-prompts/program-cookbook/create-mint-macros.mdx"; 1. Mint accounts uniquely represent a token on Solana and store its global metadata. 2. Light mints are on-chain accounts like SPL mints, but the light token program sponsors the rent-exemption cost for you. @@ -50,6 +55,8 @@ import CompressibleRentExplained from "/snippets/compressible-rent-explained.mdx + + @@ -75,6 +82,8 @@ Compare to SPL: [here](https://github.com/Lightprotocol/light-protocol/blob/0c4e2417b2df2d564721b89e18d1aad3665120e7/js/compressed-token/src/v3/actions/create-mint-interface.ts). + + @@ -98,6 +107,11 @@ Compare to SPL: + + + + + ### Add Interface PDA to SPL / Token 2022 mints @@ -153,7 +167,7 @@ Pass `TOKEN_2022_PROGRAM_ID` to create a Token-2022 mint with an interface PDA i `CreateMint` creates an on-chain mint account that can optionally include token metadata. The instruction also writes a compressed mint address to the address Merkle tree, which preserves the mint state when the on-chain account is compressed. -Compare to SPL: +Compare to SPL: + + ### Prerequisites @@ -190,12 +206,19 @@ Compare to SPL: + + + + + + + Compare to SPL: @@ -278,9 +301,9 @@ let params = CreateMintParams { The address of the mint account is stored in an address Merkle tree - , which is maintained by the protocol. + , which is maintained by the protocol. The client passes a validity proof that proves the mint address does not - exist yet. + exist yet. @@ -288,7 +311,7 @@ let params = CreateMintParams { ### System Accounts -Include system accounts such as the Light System Program +Include system accounts such as the Light System Program to verify the proof and write the mint address to the address tree. @@ -410,9 +433,16 @@ CreateMintCpi::new( + + + + + + + Compare to SPL: @@ -537,6 +567,11 @@ pub mint: UncheckedAccount<'info>, + + + + + diff --git a/light-token/cookbook/create-token-account.mdx b/light-token/cookbook/create-token-account.mdx index 8620b4bb..5d6e4280 100644 --- a/light-token/cookbook/create-token-account.mdx +++ b/light-token/cookbook/create-token-account.mdx @@ -22,14 +22,20 @@ import { import RustInstructionCode from "/snippets/code-snippets/light-token/create-token-account/rust-client/instruction.mdx"; import AnchorProgramCode from "/snippets/code-snippets/light-token/create-token-account/anchor-program/full-example.mdx"; import AnchorMacroCode from "/snippets/code-snippets/light-token/create-token-account/anchor-macro/full-example.mdx"; +import AgentSkillGeneric from "/snippets/setup/agent-skill-generic.mdx"; +import RustCreateTokenAccountAiPrompt from "/snippets/ai-prompts/rust-cookbook/create-token-account.mdx"; +import ProgramCreateTokenAccountCpiAiPrompt from "/snippets/ai-prompts/program-cookbook/create-token-account-cpi.mdx"; +import ProgramCreateTokenAccountMacrosAiPrompt from "/snippets/ai-prompts/program-cookbook/create-token-account-macros.mdx"; 1. Light token accounts are Solana accounts that hold token balances of light, SPL, or Token 2022 mints. -2. Light token accounts are on-chain accounts like SPL ATA’s, but the light token program sponsors the rent-exemption cost for you. +2. Light token accounts are on-chain accounts like SPL ATA's, but the light token program sponsors the rent-exemption cost for you. + + @@ -45,6 +51,8 @@ Compare to SPL: language="rust" /> + + ### Prerequisites @@ -68,12 +76,19 @@ Compare to SPL: + + + + + + + Compare to SPL: @@ -155,8 +170,15 @@ CreateTokenAccountCpi { + + + + + + + Compare to SPL: @@ -244,6 +266,11 @@ pub vault: UncheckedAccount<'info>, + + + + + diff --git a/light-token/cookbook/freeze-thaw.mdx b/light-token/cookbook/freeze-thaw.mdx index 3b555c2d..f74b2935 100644 --- a/light-token/cookbook/freeze-thaw.mdx +++ b/light-token/cookbook/freeze-thaw.mdx @@ -19,6 +19,9 @@ import FreezeInstructionCode from "/snippets/code-snippets/light-token/freeze-th import ThawInstructionCode from "/snippets/code-snippets/light-token/freeze-thaw/rust-client/thaw-instruction.mdx"; import FreezeAnchorProgramCode from "/snippets/code-snippets/light-token/freeze/anchor-program/full-example.mdx"; import ThawAnchorProgramCode from "/snippets/code-snippets/light-token/thaw/anchor-program/full-example.mdx"; +import AgentSkillGeneric from "/snippets/setup/agent-skill-generic.mdx"; +import RustFreezeThawAiPrompt from "/snippets/ai-prompts/rust-cookbook/freeze-thaw.mdx"; +import ProgramFreezeThawAiPrompt from "/snippets/ai-prompts/program-cookbook/freeze-thaw.mdx"; 1. Freeze prevents all transfers or token burns from a specific Light Token account. 2. Once frozen, the account cannot send tokens, receive tokens, or be closed until it is thawed. @@ -26,6 +29,8 @@ import ThawAnchorProgramCode from "/snippets/code-snippets/light-token/thaw/anch 4. Only the freeze authority (set at mint creation) can freeze or thaw accounts. 5. If the freeze authority is revoked (set to null) on the mint account, tokens can never be frozen. + + @@ -54,6 +59,8 @@ import ThawAnchorProgramCode from "/snippets/code-snippets/light-token/thaw/anch + + ### Prerequisites @@ -89,8 +96,15 @@ import ThawAnchorProgramCode from "/snippets/code-snippets/light-token/thaw/anch + + + + + + + Find [a full code example at the end](#full-code-example). @@ -212,6 +226,11 @@ ThawCpi { + + + + + diff --git a/light-token/cookbook/load-ata.mdx b/light-token/cookbook/load-ata.mdx index 57a63441..73fd2f19 100644 --- a/light-token/cookbook/load-ata.mdx +++ b/light-token/cookbook/load-ata.mdx @@ -8,6 +8,7 @@ keywords: ["load ata on solana", "get token balance for wallets"] import FullSetup from "/snippets/setup/full-setup.mdx"; import ActionCode from "/snippets/code-snippets/light-token/load-ata/action.mdx"; import InstructionCode from "/snippets/code-snippets/light-token/load-ata/instruction.mdx"; +import AgentSkillGeneric from "/snippets/setup/agent-skill-generic.mdx"; 1. `loadAta` unifies tokens from multiple sources to a single ATA: * Compressed tokens (cold Light Tokens) -> Decompresses -> light ATA @@ -22,6 +23,8 @@ import InstructionCode from "/snippets/code-snippets/light-token/load-ata/instru Find the source code [here](https://github.com/Lightprotocol/light-protocol/blob/main/js/compressed-token/src/v3/actions/load-ata.ts). + + ### Unify Tokens to Light-ATA Balance diff --git a/light-token/cookbook/mint-to.mdx b/light-token/cookbook/mint-to.mdx index 2b707075..86f323fc 100644 --- a/light-token/cookbook/mint-to.mdx +++ b/light-token/cookbook/mint-to.mdx @@ -24,11 +24,17 @@ import InstructionCode from "/snippets/code-snippets/light-token/mint-to/instruc import RustActionCode from "/snippets/code-snippets/light-token/mint-to/rust-client/action.mdx"; import RustInstructionCode from "/snippets/code-snippets/light-token/mint-to/rust-client/instruction.mdx"; import AnchorProgramCode from "/snippets/code-snippets/light-token/mint-to/anchor-program/full-example.mdx"; +import AgentSkillGeneric from "/snippets/setup/agent-skill-generic.mdx"; +import MintToAiPrompt from "/snippets/ai-prompts/ts-cookbook/mint-to.mdx"; +import RustMintToAiPrompt from "/snippets/ai-prompts/rust-cookbook/mint-to.mdx"; +import ProgramMintToAiPrompt from "/snippets/ai-prompts/program-cookbook/mint-to.mdx"; 1. Mint To creates new tokens of a mint and deposits them to a specified token account. 2. Before we can mint any tokens, we need an initialized mint account (SPL, Token 2022 or Light) for which we hold the mint authority. + + @@ -51,6 +57,8 @@ Compare to SPL: [here](https://github.com/Lightprotocol/light-protocol/blob/0c4e2417b2df2d564721b89e18d1aad3665120e7/js/compressed-token/src/v3/actions/mint-to-interface.ts). + + ### Mint Tokens to Light Token Account @@ -68,6 +76,11 @@ Compare to SPL: + + + + + @@ -85,6 +98,8 @@ Compare to SPL: language="rust" /> + + ### Prerequisites @@ -112,8 +127,15 @@ Compare to SPL: + + + + + + + Find [a full code example at the end](#full-code-example). @@ -182,6 +204,11 @@ MintToCpi { + + + + + diff --git a/light-token/cookbook/transfer-checked.mdx b/light-token/cookbook/transfer-checked.mdx index 6e783d05..0c906f7e 100644 --- a/light-token/cookbook/transfer-checked.mdx +++ b/light-token/cookbook/transfer-checked.mdx @@ -11,14 +11,21 @@ import TokenClientPrerequisites from "/snippets/light-token-guides/light-token-c import RustActionCode from "/snippets/code-snippets/light-token/transfer-checked/rust-client/action.mdx"; import RustInstructionCode from "/snippets/code-snippets/light-token/transfer-checked/rust-client/instruction.mdx"; import AnchorProgramCode from "/snippets/code-snippets/light-token/transfer-checked/anchor-program/full-example.mdx"; +import AgentSkillGeneric from "/snippets/setup/agent-skill-generic.mdx"; +import RustTransferCheckedAiPrompt from "/snippets/ai-prompts/rust-cookbook/transfer-checked.mdx"; +import ProgramTransferCheckedAiPrompt from "/snippets/ai-prompts/program-cookbook/transfer-checked.mdx"; 1. TransferChecked validates that the decimals parameter matches the mint's decimals. 2. Use for Light→Light transfers when you need decimal verification. 3. For transfers involving SPL or Token 2022 accounts, use [Transfer Interface](/light-token/cookbook/transfer-interface) instead. + + + + ### Prerequisites @@ -46,8 +53,15 @@ import AnchorProgramCode from "/snippets/code-snippets/light-token/transfer-chec + + + + + + + Find [a full code example at the end](#full-code-example). @@ -113,6 +127,11 @@ TransferCheckedCpi { + + + + + diff --git a/light-token/cookbook/transfer-interface.mdx b/light-token/cookbook/transfer-interface.mdx index a315c4c1..c07144c2 100644 --- a/light-token/cookbook/transfer-interface.mdx +++ b/light-token/cookbook/transfer-interface.mdx @@ -21,6 +21,11 @@ import InstructionCode from "/snippets/code-snippets/light-token/transfer-interf import RustActionCode from "/snippets/code-snippets/light-token/transfer-interface/rust-client/action.mdx"; import RustInstructionCode from "/snippets/code-snippets/light-token/transfer-interface/rust-client/instruction.mdx"; import AnchorProgramCode from "/snippets/code-snippets/light-token/transfer-interface/anchor-program/full-example.mdx"; +import CreateAndTransferCode from "/snippets/code-snippets/light-token/transfer-interface/anchor-program/create-and-transfer-example.mdx"; +import AgentSkillGeneric from "/snippets/setup/agent-skill-generic.mdx"; +import TransferInterfaceAiPrompt from "/snippets/ai-prompts/ts-cookbook/transfer-interface.mdx"; +import RustTransferInterfaceAiPrompt from "/snippets/ai-prompts/rust-cookbook/transfer-interface.mdx"; +import ProgramTransferInterfaceAiPrompt from "/snippets/ai-prompts/program-cookbook/transfer-interface.mdx"; @@ -55,6 +60,8 @@ import AnchorProgramCode from "/snippets/code-snippets/light-token/transfer-inte
+ + @@ -75,6 +82,8 @@ Compare to SPL: [here](https://github.com/Lightprotocol/light-protocol/blob/main/js/compressed-token/src/v3/actions/transfer-interface.ts). + + @@ -93,6 +102,11 @@ Compare to SPL: + + + + + @@ -108,6 +122,8 @@ Use the unified `TransferInterface` to transfer tokens between token accounts (S language="rust" /> + + ### Prerequisites @@ -119,7 +135,7 @@ Use the unified `TransferInterface` to transfer tokens between token accounts (S ### Transfer Interface -The example transfers +The example transfers 1. SPL token -> Light Token, 2. Light Token -> Light Token, and 3. Light Token -> SPL token. @@ -139,10 +155,17 @@ The example transfers + + + + + + + Find [a full code example at the end](#full-code-example). @@ -200,7 +223,10 @@ TransferInterfaceCpi::new( -# Full Code Example +# Full code example + + + View the [source code](https://github.com/Lightprotocol/light-protocol/blob/main/sdk-libs/token-sdk/src/instruction/transfer_interface.rs) and [full example](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/transfer-interface) with shared test utilities. @@ -210,6 +236,26 @@ TransferInterfaceCpi::new( + + +Uses the `#[light_account(init, associated_token::...)]` macro to create the destination ATA during the transfer. + + + View the [full example](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/create-and-transfer) with test utilities. + + + + + + + + + + + + + + # Next Steps diff --git a/light-token/cookbook/wrap-unwrap.mdx b/light-token/cookbook/wrap-unwrap.mdx index e8b38e21..2b432e67 100644 --- a/light-token/cookbook/wrap-unwrap.mdx +++ b/light-token/cookbook/wrap-unwrap.mdx @@ -15,6 +15,9 @@ import UnwrapInstructionCode from "/snippets/code-snippets/light-token/unwrap/in import WrapRustActionCode from "/snippets/code-snippets/light-token/wrap/rust-client/action.mdx"; import UnwrapRustActionCode from "/snippets/code-snippets/light-token/unwrap/rust-client/action.mdx"; import TokenClientPrerequisites from "/snippets/light-token-guides/light-token-client-prerequisites.mdx"; +import AgentSkillGeneric from "/snippets/setup/agent-skill-generic.mdx"; +import WrapUnwrapAiPrompt from "/snippets/ai-prompts/ts-cookbook/wrap-unwrap.mdx"; +import RustWrapUnwrapAiPrompt from "/snippets/ai-prompts/rust-cookbook/wrap-unwrap.mdx"; - **Wrap**: Move tokens from SPL/T22 account → Light Token ATA (hot balance) - **Unwrap**: Move tokens from Light Token ATA (hot balance) → SPL/T22 account @@ -26,9 +29,13 @@ import TokenClientPrerequisites from "/snippets/light-token-guides/light-token-c [unwrap.ts](https://github.com/Lightprotocol/light-protocol/blob/0c4e2417b2df2d564721b89e18d1aad3665120e7/js/compressed-token/src/v3/actions/unwrap.ts) + + + + @@ -70,12 +77,19 @@ import TokenClientPrerequisites from "/snippets/light-token-guides/light-token-c + + + + + + + @@ -128,6 +142,11 @@ import TokenClientPrerequisites from "/snippets/light-token-guides/light-token-c + + + + + diff --git a/light-token/defi/programs-pinocchio.mdx b/light-token/defi/programs-pinocchio.mdx index 01fc1aed..61f988ac 100644 --- a/light-token/defi/programs-pinocchio.mdx +++ b/light-token/defi/programs-pinocchio.mdx @@ -3,6 +3,9 @@ title: "Pinocchio Programs" description: "Build high-performance DeFi programs with rent-free accounts using Pinocchio" --- +import AgentSkillDefiProgram from "/snippets/setup/agent-skill-defi-program.mdx"; +import DefiPinocchioAiPrompt from "/snippets/ai-prompts/anchor-programs/defi-pinocchio.mdx"; + The Light-SDK sponsors rent-exemption for your PDAs, token accounts, and mints. Your program logic stays the same. | | Before | After | @@ -22,10 +25,16 @@ The Light-SDK sponsors rent-exemption for your PDAs, token accounts, and mints. If you use Anchor instead of Pinocchio, see [Program Integration](./programs). --- + + + Complete pinocchio Swap reference implementation: [pinocchio-swap](https://github.com/Lightprotocol/examples-light-token/tree/simplify-trait/pinocchio/swap) + + + ## Step 1: Dependencies ```toml @@ -286,6 +295,12 @@ pub fn process( ``` + + + + + + --- ## Client SDK diff --git a/light-token/defi/programs.mdx b/light-token/defi/programs.mdx index 719c5099..c171dc49 100644 --- a/light-token/defi/programs.mdx +++ b/light-token/defi/programs.mdx @@ -3,6 +3,9 @@ title: "Program Integration" description: "Build high-performance DeFi programs with rent-free accounts" --- +import AgentSkillDefiProgram from "/snippets/setup/agent-skill-defi-program.mdx"; +import DefiAnchorAiPrompt from "/snippets/ai-prompts/anchor-programs/defi-anchor.mdx"; + The Light-SDK sponsors rent-exemption for your PDAs, token accounts, and mints. Your program logic stays the same. | | Before | After | @@ -25,20 +28,25 @@ macro-generated. If you don't use Anchor, see the [Pinocchio Programs](./programs-pinocchio) guide. --- + + + You can find a complete rent-free AMM reference implementation [here](https://github.com/Lightprotocol/cp-swap-reference). + + + ## Step 1: Dependencies ```toml [dependencies] -light-sdk = { version = "0.18.0", features = ["anchor", "v2", "cpi-context"] } -light-sdk-macros = { version = "0.18.0" } -light-token = { version = "0.3.0", features = ["anchor"] } - -light-anchor-spl = { version = "0.31" } # TokenInterface uses light_token::ID +light-sdk = { version = "0.19.0", features = ["anchor", "v2", "cpi-context"] } +light-sdk-macros = "0.19.0" +light-token = { version = "0.4.0", features = ["anchor"] } +light-anchor-spl = "0.31" # TokenInterface uses light_token::ID anchor-lang = "0.31" ``` @@ -344,6 +352,11 @@ pub fn process_initialize_pool(ctx: Context, params: InitializeP + + + + + --- diff --git a/light-token/defi/routers.mdx b/light-token/defi/routers.mdx index e6258e2f..9d24ca69 100644 --- a/light-token/defi/routers.mdx +++ b/light-token/defi/routers.mdx @@ -3,6 +3,9 @@ title: "Router Integration" description: "Add support for rent-free AMMs on Solana." --- +import AgentSkillDefiRouter from "/snippets/setup/agent-skill-defi-router.mdx"; +import RoutersAiPrompt from "/snippets/ai-prompts/defi/routers.mdx"; + Your existing quoting, routing, and swap logic stays the same. The only addition: when a market has cold accounts, detect them, and prepend load instructions before the swap. @@ -16,6 +19,11 @@ The only addition: when a market has cold accounts, detect them, and prepend loa --- + + + + + ## Detecting cold accounts Add a cache for cold accounts. This can be independent from your regular account cache. @@ -137,7 +145,7 @@ pub trait LightProgramInterface { ```toml [dependencies] -light-client = {version = "0.18.0", features = ["v2"]} +light-client = { version = "0.19.0", features = ["v2"] } # AMM SDK that implements LightProgramInterface (provided by the AMM team) example-amm-sdk = "0.1" @@ -305,3 +313,10 @@ API is in Beta and subject to change. Questions or need hands-on support? [Telegram](https://t.me/swen_light) | [email](mailto:support@lightprotocol.com) | [Discord](https://discord.com/invite/7cJ8BhAXhu) + + + + + + + diff --git a/light-token/examples/client.mdx b/light-token/examples/client.mdx index a0c89492..dd935794 100644 --- a/light-token/examples/client.mdx +++ b/light-token/examples/client.mdx @@ -5,7 +5,12 @@ description: "TypeScript and Rust client examples for light-token SDK." --- import ClientExamplesTable from "/snippets/overview-tables/light-token-client-examples-table.mdx"; +import AgentSkillGeneric from "/snippets/setup/agent-skill-generic.mdx"; Find all examples on Github: [examples-light-token](https://github.com/Lightprotocol/examples-light-token) + + + + diff --git a/light-token/examples/program.mdx b/light-token/examples/program.mdx index d447d23c..2cc58ce0 100644 --- a/light-token/examples/program.mdx +++ b/light-token/examples/program.mdx @@ -5,7 +5,12 @@ description: "Anchor program examples for light-token CPI." --- import ProgramExamplesTable from "/snippets/overview-tables/light-token-program-examples-table.mdx"; +import AgentSkillGeneric from "/snippets/setup/agent-skill-generic.mdx"; Find all examples on Github: [examples-light-token](https://github.com/Lightprotocol/examples-light-token) + + + + diff --git a/light-token/faq.mdx b/light-token/faq.mdx index 548c55e3..638ad500 100644 --- a/light-token/faq.mdx +++ b/light-token/faq.mdx @@ -134,6 +134,13 @@ Coming soon: DM us [@lightprotocol on X (Twitter)](http://x.com/lightprotocol) or [Discord](https://discord.com/invite/rpddh53TeG). + + + ### Get Started diff --git a/light-token/quickstart.mdx b/light-token/quickstart.mdx index 135038d6..d0ecf983 100644 --- a/light-token/quickstart.mdx +++ b/light-token/quickstart.mdx @@ -1,12 +1,15 @@ --- title: Quickstart -description: Mint tokens to a Light-ATA in under 3 minutes. +description: Mint SPL tokens, wrap to Light Token, and transfer in under 3 minutes. sidebarTitle: Quickstart keywords: ["create tokens on solana tutorial", "mint tokens on solana guide", "spl token quickstart for developers", "token sdk for solana apps"] --- import FullSetup from "/snippets/setup/full-setup.mdx"; -import MintToAction from "/snippets/code-snippets/light-token/mint-to/action.mdx"; +import MintSplAndWrapAction from "/snippets/code-snippets/light-token/mint-spl-and-wrap/action.mdx"; +import AgentSkillGeneric from "/snippets/setup/agent-skill-generic.mdx"; + + @@ -18,29 +21,21 @@ import MintToAction from "/snippets/code-snippets/light-token/mint-to/action.mdx -## Mint Tokens to Light-ATA +## Mint SPL tokens, convert to Light Token and Transfer - + # Next Steps - - Guides for dedicated use cases - - - Step-by-step recipes + Find answers to frequently answered questions. - + diff --git a/light-token/toolkits/for-payments.mdx b/light-token/toolkits/for-payments.mdx index bc1cae9b..6c0c3c27 100644 --- a/light-token/toolkits/for-payments.mdx +++ b/light-token/toolkits/for-payments.mdx @@ -1,12 +1,15 @@ --- title: "Toolkit for Stablecoin Payments" -sidebarTitle: "For Stablecoin Payments" -description: "Guide to integrate light-token APIs with comparison to SPL." +sidebarTitle: "Integration Guide" +description: "Guide to integrate light-token APIs for stablecoin payments with comparison to SPL." keywords: ["stablecoin payments for enterprises", "infrastructure for stablecoin payments on solana", "payment rails for stablecoins on solana", "usdc payments for merchants on solana", "payment infrastructure for fintechs", "micropayments for apps on solana", "token extensions for payment companies", "rent free tokens for payment apps"] --- import { CodeCompare } from "/snippets/jsx/code-compare.jsx"; import ToolkitsSetup from "/snippets/setup/toolkits-setup.mdx"; +import RegisterSplMint from "/snippets/setup/register-spl-mint.mdx"; +import AgentSkillPayments from "/snippets/setup/agent-skill-payments.mdx"; +import PaymentsAiPrompt from "/snippets/ai-prompts/toolkits/payments.mdx"; 1. The light-token API matches the SPL-token API almost entirely, and extends their functionality to include the light token program in addition to the SPL-token and Token-2022 programs. 2. Your users use the same stablecoins, just stored more efficiently. @@ -64,6 +67,11 @@ import ToolkitsSetup from "/snippets/setup/toolkits-setup.mdx"; [here](https://github.com/Lightprotocol/examples-light-token/tree/main/toolkits/payments-and-wallets). + + + + + ## Setup @@ -89,74 +97,15 @@ import { const rpc = createRpc(RPC_ENDPOINT); ``` -### One-time: Register an Existing SPL Mint + -For existing SPL mints (e.g. USDC), register the SPL interface once. This creates the omnibus PDA that holds SPL tokens when wrapped to light-token. +### Receive Payments -Find a full code example [here](https://github.com/Lightprotocol/examples-light-token/blob/main/toolkits/payments-and-wallets/register-spl-mint.ts). +Find a full code example [here](https://github.com/Lightprotocol/examples-light-token/blob/main/toolkits/payments-and-wallets/receive.ts). -Check if the interface already exists: - -```typescript -import { getSplInterfaceInfos } from "@lightprotocol/compressed-token"; - -try { - const infos = await getSplInterfaceInfos(rpc, mint); - const exists = infos.some((i) => i.isInitialized); - console.log("Interface exists:", exists); -} catch { - console.log("No interface registered for this mint."); -} -``` - -Register: - - - - -```typescript -import { Transaction, sendAndConfirmTransaction } from "@solana/web3.js"; -import { LightTokenProgram } from "@lightprotocol/compressed-token"; -import { TOKEN_PROGRAM_ID } from "@solana/spl-token"; - -const ix = await LightTokenProgram.createSplInterface({ - feePayer: payer.publicKey, - mint, - tokenProgramId: TOKEN_PROGRAM_ID, -}); - -const tx = new Transaction().add(ix); -await sendAndConfirmTransaction(rpc, tx, [payer]); -``` - - - - -```typescript -import { createSplInterface } from "@lightprotocol/compressed-token"; - -await createSplInterface(rpc, payer, mint); -``` - - - - - - -Use `createMintInterface` with `TOKEN_PROGRAM_ID` to create a new SPL mint and register the interface in one transaction: - -```typescript -import { createMintInterface } from "@lightprotocol/compressed-token/unified"; -import { TOKEN_PROGRAM_ID } from "@solana/spl-token"; - -const { mint } = await createMintInterface( - rpc, payer, payer, null, 9, undefined, undefined, TOKEN_PROGRAM_ID -); -``` - - +Load creates the associated token account (ATA) if needed and loads any compressed state into it. Share the ATA address with the sender. **About loading**: Light tokens reduce account rent ~200x by auto-compressing inactive @@ -166,14 +115,6 @@ atomic transaction with your regular transfer. APIs return `TransactionInstructi loop handles the rare multi-transaction case automatically. -### Receive Payments - - -Find a full code example [here](https://github.com/Lightprotocol/examples-light-token/blob/main/toolkits/payments-and-wallets/receive.ts). - - -Load creates the associated token account (ATA) if needed and loads any compressed state into it. Share the ATA address with the sender. - @@ -553,3 +494,9 @@ await unwrap(rpc, payer, splAta, owner, mint, amount); + + + + + + diff --git a/light-token/toolkits/for-privy.mdx b/light-token/toolkits/for-privy.mdx new file mode 100644 index 00000000..2c71f8ba --- /dev/null +++ b/light-token/toolkits/for-privy.mdx @@ -0,0 +1,224 @@ +--- +title: "Light-Token with Privy Wallets" +sidebarTitle: "Sign with Privy Wallet" +description: "Integrate light-token with Privy embedded wallets for rent-free token accounts and transfers." +keywords: ["privy solana", "privy light token", "embedded wallet light token", "rent-free tokens privy"] +--- +import ToolkitsSetup from "/snippets/setup/toolkits-setup.mdx"; +import RegisterSplMint from "/snippets/setup/register-spl-mint.mdx"; +import AgentSkillPayments from "/snippets/setup/agent-skill-payments.mdx"; +import TransferNodejs from "/snippets/code-snippets/privy/transfer/nodejs.mdx"; +import TransferReact from "/snippets/code-snippets/privy/transfer/react.mdx"; +import WrapNodejs from "/snippets/code-snippets/privy/wrap/nodejs.mdx"; +import WrapReact from "/snippets/code-snippets/privy/wrap/react.mdx"; +import UnwrapNodejs from "/snippets/code-snippets/privy/unwrap/nodejs.mdx"; +import UnwrapReact from "/snippets/code-snippets/privy/unwrap/react.mdx"; +import BalancesNodejs from "/snippets/code-snippets/privy/balances/nodejs.mdx"; +import BalancesReact from "/snippets/code-snippets/privy/balances/react.mdx"; +import TransactionHistoryNodejs from "/snippets/code-snippets/privy/transaction-history/nodejs.mdx"; +import TransactionHistoryReact from "/snippets/code-snippets/privy/transaction-history/react.mdx"; +import PrivyAiPrompt from "/snippets/ai-prompts/wallets/privy.mdx"; + +| Creation Cost | SPL | light-token | +| :---------------- | :------------------ | :------------------- | +| **Token Account** | ~2,000,000 lamports | ~**11,000** lamports | + +Privy handles user authentication and wallet management. You build transactions with light-token and Privy signs them: + +1. Authenticate with Privy +2. Build unsigned transaction +3. Sign transaction using Privy's wallet provider +4. Send signed transaction to RPC + +## What you will implement + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SPLLight
[**Transfer**](#full-code-examples)createTransferInstruction()createTransferInterfaceInstructions()
[**Wrap from SPL**](#full-code-examples)N/AcreateWrapInstruction()
[**Unwrap to SPL**](#full-code-examples)N/AcreateUnwrapInstructions()
[**Get Balance**](#get-balances)getAccount()getAtaInterface()
[**Tx History**](#get-transaction-history)getSignaturesForAddress()getSignaturesForOwnerInterface()
+ + + + + + + +### Prerequisites + + + +Connect to an RPC endpoint that supports ZK Compression (Helius, Triton): + +```typescript +import { createRpc } from "@lightprotocol/stateless.js"; + +import { + createTransferInterfaceInstructions, + createWrapInstruction, + createUnwrapInstructions, + getAssociatedTokenAddressInterface, + getAtaInterface, +} from "@lightprotocol/compressed-token/unified"; + +const rpc = createRpc(RPC_ENDPOINT); +``` + + + + +## Sign with Privy + + +Find complete examples on GitHub: [Node.js](https://github.com/Lightprotocol/examples-light-token/tree/main/privy/nodejs) and [React](https://github.com/Lightprotocol/examples-light-token/tree/main/privy/react). + + + + + +Transfer light-tokens between wallets. Auto-loads cold (compressed) light-token, SPL or +Token-2022 balance before sending. + + +**About loading:** Light tokens reduce account rent ~200x by auto-compressing inactive accounts. +Before any action, the SDK detects compressed state and adds instructions to load it back on-chain. +This almost always fits in a single atomic transaction with your regular transfer. +APIs return `TransactionInstruction[][]` so the same loop handles the rare multi-transaction case +automatically. + + + + + + + + + + + + + + + +Wrap SPL or Token-2022 tokens into a light-token associated token account. + + + + + + + + + + + + + + +Unwrap light-token balance to SPL or Token-2022. Use unwrap to interact with applications that only support SPL/Token-2022. + + + + + + + + + + + + + + + + + +## Show Balance + +Query token balances to show a unified balance of SOL, +Light, SPL, and Token-2022. + +```typescript +import { + getAssociatedTokenAddressInterface, + getAtaInterface, +} from "@lightprotocol/compressed-token/unified"; + +const ata = getAssociatedTokenAddressInterface(mint, owner); +const account = await getAtaInterface(rpc, ata, owner, mint); +console.log(account.parsed.amount); +``` + + + + + + + + + + + + +## Get Transaction History + +Fetch light-token transaction history for an owner. + +```typescript +import { createRpc } from "@lightprotocol/stateless.js"; + +const result = await rpc.getSignaturesForOwnerInterface(owner); +console.log(result.signatures); // Merged + deduplicated +console.log(result.solana); // On-chain txs only +console.log(result.compressed); // Compressed txs only +``` + + + + + + + + + + + + + + + + + + + + diff --git a/light-token/toolkits/for-streaming-mints.mdx b/light-token/toolkits/for-streaming-mints.mdx index 9ac85a1d..3986df83 100644 --- a/light-token/toolkits/for-streaming-mints.mdx +++ b/light-token/toolkits/for-streaming-mints.mdx @@ -6,6 +6,8 @@ keywords: ["streaming mint accounts solana", "laserstream light mint", "grpc min --- import FindClosedAccounts from '/snippets/code-snippets/streaming/find-closed-accounts.mdx'; +import AgentSkillStreaming from "/snippets/setup/agent-skill-streaming.mdx"; +import StreamingMintsAiPrompt from "/snippets/ai-prompts/streaming/mints.mdx"; | Event | Description | |:------|:------------| @@ -19,6 +21,11 @@ This guide is for teams building custom data pipelines (aggregators, market make If you just need account lookups, use [`get_account_interface`](/light-token/defi/routers) instead. + + + + + ## Architecture Light mints are Solana accounts owned by the Light Token Program. The streaming @@ -251,3 +258,9 @@ pub struct AdditionalMetadata { href="/light-token/toolkits/for-streaming-tokens" horizontal /> + + + + + + diff --git a/light-token/toolkits/for-streaming-pdas.mdx b/light-token/toolkits/for-streaming-pdas.mdx index ed68074e..adc746e7 100644 --- a/light-token/toolkits/for-streaming-pdas.mdx +++ b/light-token/toolkits/for-streaming-pdas.mdx @@ -6,12 +6,16 @@ keywords: ["streaming compressible pdas solana", "laserstream pda indexing", "gr visibility: "hidden" --- +import AgentSkillStreaming from "/snippets/setup/agent-skill-streaming.mdx"; + Programs using the Light SDK expose standardized instruction discriminators for `compress_accounts_idempotent` and `decompress_accounts_idempotent`. Programs that don't implement these discriminators are not indexable with this approach. + + ## Architecture Two per-program gRPC subscriptions. Nothing else. diff --git a/light-token/toolkits/for-streaming-tokens.mdx b/light-token/toolkits/for-streaming-tokens.mdx index fc0bd7c3..eb11290c 100644 --- a/light-token/toolkits/for-streaming-tokens.mdx +++ b/light-token/toolkits/for-streaming-tokens.mdx @@ -6,12 +6,19 @@ keywords: ["streaming token accounts solana", "laserstream light token", "grpc t --- import FindClosedAccounts from '/snippets/code-snippets/streaming/find-closed-accounts.mdx'; +import AgentSkillStreaming from "/snippets/setup/agent-skill-streaming.mdx"; +import StreamingTokensAiPrompt from "/snippets/ai-prompts/streaming/tokens.mdx"; This guide is for teams building custom data pipelines (aggregators, market makers). If you just need account lookups, use [`get_account_interface`](/light-token/defi/routers) instead. + + + + + ## Architecture Light token accounts share the same base layout as SPL Token (165 bytes), so you can @@ -258,3 +265,9 @@ Source: [`light-token-interface`](https://github.com/Lightprotocol/light-protoco href="/light-token/toolkits/for-streaming-mints" horizontal /> + + + + + + diff --git a/light-token/toolkits/for-wallets.mdx b/light-token/toolkits/for-wallets.mdx index 99fac62f..03745245 100644 --- a/light-token/toolkits/for-wallets.mdx +++ b/light-token/toolkits/for-wallets.mdx @@ -1,12 +1,14 @@ --- -title: "Toolkit for Wallet Applications" -sidebarTitle: "For Wallets" +title: "Light Token Integration Guide for Wallet Applications" +sidebarTitle: "Integration Guide" description: "Guide for Wallet Applications to add Light-token support." keywords: ["wallet infrastructure on solana", "scalable wallet infrastructure on solana", "token wallet for developers", "rent free tokens for wallets"] --- import { CodeCompare } from "/snippets/jsx/code-compare.jsx"; import ToolkitsSetup from "/snippets/setup/toolkits-setup.mdx"; +import AgentSkillPayments from "/snippets/setup/agent-skill-payments.mdx"; +import WalletsAiPrompt from "/snippets/ai-prompts/toolkits/wallets.mdx"; 1. The Light-token API matches the SPL-token API almost entirely, and extends their functionality to include the light token program in addition to the SPL-token and Token-2022 programs. 2. Your users hold and receive tokens of the same mints, just stored more efficiently. @@ -64,6 +66,11 @@ import ToolkitsSetup from "/snippets/setup/toolkits-setup.mdx"; [here](https://github.com/Lightprotocol/examples-light-token/tree/main/toolkits/payments-and-wallets). + + + + + ## Setup @@ -425,3 +432,9 @@ await unwrap(rpc, payer, splAta, owner, mint, amount); + + + + + + diff --git a/light-token/welcome.mdx b/light-token/welcome.mdx index a2bbc397..d67202cd 100644 --- a/light-token/welcome.mdx +++ b/light-token/welcome.mdx @@ -1,22 +1,13 @@ --- title: The Light Token Program -sidebarTitle: Introduction +sidebarTitle: Overview description: Light token is a high-performance token standard that reduces the cost of mint and token accounts by 200x. keywords: ["rent free tokens on solana", "rent free solana accounts", "spl token alternative for developers", "token 2022 alternative for solana", "infrastructure for stablecoin payments on solana", "scalable solana infrastructure", "token infrastructure for fintechs", "scalable infrastructure for solana apps"] --- -import GuidesTable from "/snippets/overview-tables/compressed-tokens-guides-table.mdx"; -import AdvancedGuidesTable from "/snippets/overview-tables/compressed-tokens-advanced-guides-table.mdx"; -import SetupEnvironment from "/snippets/setup/setup-environment-tabs.mdx"; -import InstallDependencies from "/snippets/setup/install-dependencies-codegroup.mdx"; -import { LightTokenVsSplCalculator } from "/snippets/jsx/light-token-vs-spl-calculator.jsx"; -import { CompressibleRentCalculator } from "/snippets/jsx/compressible-rent-calculator.jsx"; -import { RentLifecycleVisualizer } from "/snippets/jsx/rent-lifecycle-visualizer.jsx"; -import CompressibleRentExplained from "/snippets/compressible-rent-explained.mdx"; -import CompressibleDefaultRentConfig from "/snippets/compressible-default-rent-config.mdx"; -import IntegrateLightTokenGuidesTable from "/snippets/overview-tables/integrate-light-token-guides-table.mdx"; import CookbookGuidesTable from "/snippets/overview-tables/cookbook-guides-table.mdx"; import WelcomePageInstall from "/snippets/setup/welcome-page-install.mdx"; +import SdkReference from "/snippets/overview-tables/sdk-reference.mdx"; **Note: This page is for the new Light Token Program Beta.** For production use today, use @@ -64,15 +55,13 @@ import WelcomePageInstall from "/snippets/setup/welcome-page-install.mdx"; ### Get Started - - - + @@ -80,21 +69,74 @@ import WelcomePageInstall from "/snippets/setup/welcome-page-install.mdx"; - Build rent-free AMMs and DeFi programs with minimal code changes. + Build rent-free AMMs and DeFi programs. - Add support for rent-free AMMs to your aggregator or router. + Add support for rent-free AMMs to your aggregator. + + + High-performance DeFi programs with Pinocchio. + + + +## Payments + + + + Guide to integrate light-token APIs with comparison to SPL. + + + Prevent onchain instructions from being executed more than once. + + + +## Wallets + + + + Guide for Wallet Applications to let users display and swap light-tokens. + + + Add light-tokens to Privy embedded wallets. -## Integration Toolkits +## Data Streaming - + + + Stream mint events from the network in real-time. + + + Stream token events from the network in real-time. + + ## Cookbook +## Examples + +### Client + +| | | +| :--- | :--- | +| [**TypeScript**](/light-token/examples/client#typescript) | Actions and instructions for all token operations | +| [**Rust**](/light-token/examples/client#rust) | Actions and instructions for all token operations | + +### Program + +| | | +| :--- | :--- | +| [**Examples**](/light-token/examples/program#examples) | AMM reference, CPI create-and-transfer, Pinocchio swap | +| [**Macros**](/light-token/examples/program#macros) | Counter PDA, ATA, mint, and token account creation | +| [**Instructions**](/light-token/examples/program#instructions) | All CPI instructions: approve, burn, close, freeze, mint-to, transfer, and more | + +## SDK Reference + + + # Next Steps \ No newline at end of file diff --git a/client-library/client-guide.mdx b/pda/compressed-pdas/guides/client-guide.mdx similarity index 98% rename from client-library/client-guide.mdx rename to pda/compressed-pdas/guides/client-guide.mdx index deb82b16..68358fd4 100644 --- a/client-library/client-guide.mdx +++ b/pda/compressed-pdas/guides/client-guide.mdx @@ -9,8 +9,7 @@ keywords: ["compressed pda client", "light protocol sdk"] import SystemAccountsList from '/snippets/accounts-list/compressed-pdas-system-accounts-list.mdx'; import TypescriptClient from '/snippets/code-snippets/create/typescript-client.mdx'; import RustClient from '/snippets/code-snippets/create/rust-client.mdx'; - -ZK Compression provides Rust and Typescript clients to interact with compressed accounts and tokens on Solana. +import ClientGuideAiPrompt from '/snippets/ai-prompts/cpi-programs/client-guide.mdx'; @@ -109,6 +108,8 @@ ZK Compression provides Rust and Typescript clients to interact with compressed # Get Started + + ## Setup @@ -1074,6 +1075,11 @@ let instruction = Instruction { + + + + + # Full Code Examples @@ -1103,7 +1109,7 @@ Find all [full code examples with Rust and TypeScript tests here](https://github - **burn** - Permanently delete a compressed account (it cannot be initialized again). -For help with debugging, see the [Error Cheatsheet](../resources/error-cheatsheet/) and [AskDevin](https://deepwiki.com/Lightprotocol/light-protocol/3.1-javascripttypescript-sdks). +For help with debugging, see the [Error Cheatsheet](/resources/error-cheatsheet) and [AskDevin](https://deepwiki.com/Lightprotocol/light-protocol/3.1-javascripttypescript-sdks). # Next Steps @@ -1112,7 +1118,7 @@ For help with debugging, see the [Error Cheatsheet](../resources/error-cheatshee title="Get an overview to Compressed PDA guides and build a program." icon="chevron-right" color="#0066ff" - href="/compressed-pdas/guides" + href="/pda/compressed-pdas/guides" horizontal > diff --git a/compressed-pdas/guides/how-to-burn-compressed-accounts.mdx b/pda/compressed-pdas/guides/how-to-burn-compressed-accounts.mdx similarity index 93% rename from compressed-pdas/guides/how-to-burn-compressed-accounts.mdx rename to pda/compressed-pdas/guides/how-to-burn-compressed-accounts.mdx index 9ae93264..05b2a02f 100644 --- a/compressed-pdas/guides/how-to-burn-compressed-accounts.mdx +++ b/pda/compressed-pdas/guides/how-to-burn-compressed-accounts.mdx @@ -9,6 +9,7 @@ import CompressedPdasSystemAccountsList from '/snippets/accounts-list/compressed import DevelopmentEnvironmentSetup from '/snippets/setup/development-environment-setup.mdx'; import AnchorProgram from '/snippets/code-snippets/burn/anchor-program.mdx'; import NativeProgram from '/snippets/code-snippets/burn/native-program.mdx'; +import CpiBurnAiPrompt from '/snippets/ai-prompts/cpi-programs/burn.mdx'; Compressed accounts are permanently burned via CPI to the Light System Program. @@ -19,7 +20,7 @@ Burning a compressed account * A burned account cannot be reinitialized. -Find [full code examples at the end](/compressed-pdas/guides/how-to-burn-compressed-accounts#full-code-example) for Anchor and native Rust. +Find [full code examples at the end](/pda/compressed-pdas/guides/how-to-burn-compressed-accounts#full-code-example) for Anchor and native Rust. # Implementation Guide @@ -38,6 +39,8 @@ Here is the complete flow to burn compressed accounts: + + @@ -237,6 +240,11 @@ LightSystemProgramCpi::new_cpi(LIGHT_CPI_SIGNER, instruction_data.proof) * `invoke(light_cpi_accounts)` calls the Light System Program with `CpiAccounts`. + + + + + # Full Code Example @@ -247,7 +255,7 @@ The example programs below implement all steps from this guide. -For help with debugging, see the [Error Cheatsheet](../../resources/error-cheatsheet/). +For help with debugging, see the [Error Cheatsheet](/resources/error-cheatsheet). @@ -275,14 +283,14 @@ Find the source code [here](https://github.com/Lightprotocol/program-examples/tr title="Build a client for your program" icon="chevron-right" color="#0066ff" - href="/client-library/client-guide" + href="/pda/compressed-pdas/guides/client-guide" horizontal /> diff --git a/compressed-pdas/guides/how-to-close-compressed-accounts.mdx b/pda/compressed-pdas/guides/how-to-close-compressed-accounts.mdx similarity index 92% rename from compressed-pdas/guides/how-to-close-compressed-accounts.mdx rename to pda/compressed-pdas/guides/how-to-close-compressed-accounts.mdx index dc547c26..78484ff9 100644 --- a/compressed-pdas/guides/how-to-close-compressed-accounts.mdx +++ b/pda/compressed-pdas/guides/how-to-close-compressed-accounts.mdx @@ -9,6 +9,7 @@ import CompressedPdasSystemAccountsList from '/snippets/accounts-list/compressed import DevelopmentEnvironmentSetup from '/snippets/setup/development-environment-setup.mdx'; import AnchorProgram from '/snippets/code-snippets/close/anchor-program.mdx'; import NativeProgram from '/snippets/code-snippets/close/native-program.mdx'; +import CpiCloseAiPrompt from '/snippets/ai-prompts/cpi-programs/close.mdx'; Compressed accounts are closed via CPI to the Light System Program. @@ -16,10 +17,10 @@ Closing a compressed account * consumes the existing account hash, and * produces a new account hash with zero values to mark it as closed. -* A closed compressed account [can be reinitialized](/compressed-pdas/guides/how-to-reinitialize-compressed-accounts). +* A closed compressed account [can be reinitialized](/pda/compressed-pdas/guides/how-to-reinitialize-compressed-accounts). -Find [full code examples at the end](/compressed-pdas/guides/how-to-close-compressed-accounts#full-code-example) for Anchor and native Rust. +Find [full code examples at the end](/pda/compressed-pdas/guides/how-to-close-compressed-accounts#full-code-example) for Anchor and native Rust. # Implementation Guide @@ -38,6 +39,8 @@ Here is the complete flow to close compressed accounts: + + @@ -243,6 +246,11 @@ LightSystemProgramCpi::new_cpi(LIGHT_CPI_SIGNER, instruction_data.proof) * `invoke()` calls the Light System Program with `CpiAccounts`. + + + + + # Full Code Example @@ -254,7 +262,7 @@ Make sure you have your developer environment set up first. -For help with debugging, see the [Error Cheatsheet](../../resources/error-cheatsheet/). +For help with debugging, see the [Error Cheatsheet](/resources/error-cheatsheet). @@ -282,14 +290,14 @@ Find the source code [here](https://github.com/Lightprotocol/program-examples/tr title="Build a client for your program" icon="chevron-right" color="#0066ff" - href="/client-library/client-guide" + href="/pda/compressed-pdas/guides/client-guide" horizontal /> diff --git a/compressed-pdas/guides/how-to-create-compressed-accounts.mdx b/pda/compressed-pdas/guides/how-to-create-compressed-accounts.mdx similarity index 95% rename from compressed-pdas/guides/how-to-create-compressed-accounts.mdx rename to pda/compressed-pdas/guides/how-to-create-compressed-accounts.mdx index 32533423..44bc30be 100644 --- a/compressed-pdas/guides/how-to-create-compressed-accounts.mdx +++ b/pda/compressed-pdas/guides/how-to-create-compressed-accounts.mdx @@ -8,17 +8,16 @@ import CompressedPdasSystemAccountsList from '/snippets/accounts-list/compressed import DevelopmentEnvironmentSetup from '/snippets/setup/development-environment-setup.mdx'; import AnchorProgram from '/snippets/code-snippets/create/anchor-program.mdx'; import NativeProgram from '/snippets/code-snippets/create/native-program.mdx'; +import CpiCreateAiPrompt from '/snippets/ai-prompts/cpi-programs/create.mdx'; Compressed accounts and addresses are created via CPI to the Light System Program. * Compressed and regular Solana accounts share the same functionality and are fully composable. * A compressed account has two identifiers: the account hash and its address (optional). In comparison, regular Solana accounts are identified by their address. * The account hash is not persistent and changes with every write to the account. -* For Solana PDA like behavior your compressed account needs an address as persistent identifier.\ - Fungible state like [compressed token accounts](/compressed-tokens/guides/create-compressed-token-accounts) do not need addresses. - +* For Solana PDA like behavior your compressed account needs an address as persistent identifier. -Find [full code examples at the end](/compressed-pdas/guides/how-to-create-compressed-accounts#full-code-example) for Anchor and native Rust. +Find [full code examples at the end](/pda/compressed-pdas/guides/how-to-create-compressed-accounts#full-code-example) for Anchor and native Rust. # Implementation Guide @@ -37,6 +36,8 @@ Here is the complete flow: + + @@ -387,6 +388,11 @@ LightSystemProgramCpi::new_cpi(LIGHT_CPI_SIGNER, instruction_data.proof) * `invoke(light_cpi_accounts)` calls the Light System Program with `CpiAccounts.` + + + + + # Full Code Example @@ -397,7 +403,7 @@ The example programs below implement all steps from this guide. -For help with debugging, see the [Error Cheatsheet](../../resources/error-cheatsheet/). +For help with debugging, see the [Error Cheatsheet](/resources/error-cheatsheet). @@ -425,14 +431,14 @@ Find the source code [here](https://github.com/Lightprotocol/program-examples/tr title="Build a client for your program" icon="chevron-right" color="#0066ff" - href="/client-library/client-guide" + href="/pda/compressed-pdas/guides/client-guide" horizontal /> diff --git a/compressed-pdas/guides/how-to-create-nullifier-pdas.mdx b/pda/compressed-pdas/guides/how-to-create-nullifier-pdas.mdx similarity index 96% rename from compressed-pdas/guides/how-to-create-nullifier-pdas.mdx rename to pda/compressed-pdas/guides/how-to-create-nullifier-pdas.mdx index 63f10de2..aeca922b 100644 --- a/compressed-pdas/guides/how-to-create-nullifier-pdas.mdx +++ b/pda/compressed-pdas/guides/how-to-create-nullifier-pdas.mdx @@ -1,9 +1,12 @@ --- title: Create Nullifier PDAs +sidebarTitle: Nullifiers description: Create rent-free nullifier PDAs to prevent duplicate actions. keywords: ["nullifiers on solana", "prevent double spending", "compressed pdas", "rent-free nullifiers"] --- +import NullifiersAiPrompt from "/snippets/ai-prompts/toolkits/nullifiers.mdx"; + For some use cases, such as sending payments, you might want to prevent your onchain instruction from being executed more than once. @@ -21,6 +24,9 @@ We also deployed a reference implementation to public networks so you can get st For the usage example source code, see here: [create_nullifier.rs](https://github.com/Lightprotocol/examples-light-token/blob/main/rust-client/actions/create_nullifier.rs#L25) + + + ## How It Works 1. Derives PDA from `["nullifier", id]` seeds (where `id` is your unique identifier, e.g. a nonce, uuid, hash of signature, etc.) @@ -195,4 +201,10 @@ Note that this is a reference implementation. Feel free to fork the program as y Questions or need support? [Telegram](https://t.me/swen_light) | [email](mailto:support@lightprotocol.com) | [Discord](https://discord.com/invite/7cJ8BhAXhu) - \ No newline at end of file + + + + + + + \ No newline at end of file diff --git a/compressed-pdas/guides/how-to-reinitialize-compressed-accounts.mdx b/pda/compressed-pdas/guides/how-to-reinitialize-compressed-accounts.mdx similarity index 93% rename from compressed-pdas/guides/how-to-reinitialize-compressed-accounts.mdx rename to pda/compressed-pdas/guides/how-to-reinitialize-compressed-accounts.mdx index c49b22e7..a5776fda 100644 --- a/compressed-pdas/guides/how-to-reinitialize-compressed-accounts.mdx +++ b/pda/compressed-pdas/guides/how-to-reinitialize-compressed-accounts.mdx @@ -9,6 +9,7 @@ import CompressedPdasSystemAccountsList from '/snippets/accounts-list/compressed import DevelopmentEnvironmentSetup from '/snippets/setup/development-environment-setup.mdx'; import AnchorProgram from '/snippets/code-snippets/reinit/anchor-program.mdx'; import NativeProgram from '/snippets/code-snippets/reinit/native-program.mdx'; +import CpiReinitAiPrompt from '/snippets/ai-prompts/cpi-programs/reinitialize.mdx'; Compressed accounts are reinitialized via CPI to the Light System Program. @@ -18,7 +19,7 @@ An empty compressed account can be reinitialized * to create a new account hash at the same address with new values. -Find [full code examples at the end](/compressed-pdas/guides/how-to-reinitialize-compressed-accounts#full-code-example) for Anchor and native Rust. +Find [full code examples at the end](/pda/compressed-pdas/guides/how-to-reinitialize-compressed-accounts#full-code-example) for Anchor and native Rust. # Implementation Guide @@ -37,6 +38,8 @@ Here is the complete flow to reinitialize compressed accounts: + + @@ -229,6 +232,11 @@ LightSystemProgramCpi::new_cpi(LIGHT_CPI_SIGNER, instruction_data.proof) * `invoke(light_cpi_accounts)` calls the Light System Program with `CpiAccounts`. + + + + + # Full Code Example @@ -239,7 +247,7 @@ The counter programs below implement all steps from this guide. -For help with debugging, see the [Error Cheatsheet](../../resources/error-cheatsheet/). +For help with debugging, see the [Error Cheatsheet](/resources/error-cheatsheet). @@ -267,14 +275,14 @@ Find the source code [here](https://github.com/Lightprotocol/program-examples/tr title="Build a client for your program" icon="chevron-right" color="#0066ff" - href="/client-library/client-guide" + href="/pda/compressed-pdas/guides/client-guide" horizontal /> diff --git a/compressed-pdas/guides/how-to-update-compressed-accounts.mdx b/pda/compressed-pdas/guides/how-to-update-compressed-accounts.mdx similarity index 94% rename from compressed-pdas/guides/how-to-update-compressed-accounts.mdx rename to pda/compressed-pdas/guides/how-to-update-compressed-accounts.mdx index 92cc7986..96d8fb87 100644 --- a/compressed-pdas/guides/how-to-update-compressed-accounts.mdx +++ b/pda/compressed-pdas/guides/how-to-update-compressed-accounts.mdx @@ -9,6 +9,7 @@ import CompressedPdasSystemAccountsList from '/snippets/accounts-list/compressed import DevelopmentEnvironmentSetup from '/snippets/setup/development-environment-setup.mdx'; import AnchorProgram from '/snippets/code-snippets/update/anchor-program.mdx'; import NativeProgram from '/snippets/code-snippets/update/native-program.mdx'; +import CpiUpdateAiPrompt from '/snippets/ai-prompts/cpi-programs/update.mdx'; Compressed accounts are updated via CPI to the Light System Program. @@ -19,7 +20,7 @@ The update of a compressed account follows a UTXO pattern, unlike regular Solana * The existing account hash is nullified to prevent double spending. -Find [full code examples at the end](/compressed-pdas/guides/how-to-update-compressed-accounts#full-code-example) for Anchor and native Rust. +Find [full code examples at the end](/pda/compressed-pdas/guides/how-to-update-compressed-accounts#full-code-example) for Anchor and native Rust. # Implementation Guide @@ -38,6 +39,8 @@ Here is the complete flow: + + @@ -246,6 +249,11 @@ LightSystemProgramCpi::new_cpi(LIGHT_CPI_SIGNER, instruction_data.proof) * `invoke(light_cpi_accounts)` calls the Light System Program with `CpiAccounts`. + + + + + # Full Code Example @@ -256,7 +264,7 @@ The example programs below implement all steps from this guide. -For help with debugging, see the [Error Cheatsheet](../../resources/error-cheatsheet/). +For help with debugging, see the [Error Cheatsheet](/resources/error-cheatsheet). @@ -284,14 +292,14 @@ Find the source code [here](https://github.com/Lightprotocol/program-examples/tr title="Build a client for your program" icon="chevron-right" color="#0066ff" - href="/client-library/client-guide" + href="/pda/compressed-pdas/guides/client-guide" horizontal /> diff --git a/compressed-pdas/overview.mdx b/pda/compressed-pdas/overview.mdx similarity index 61% rename from compressed-pdas/overview.mdx rename to pda/compressed-pdas/overview.mdx index 75c410a7..fab64ad2 100644 --- a/compressed-pdas/overview.mdx +++ b/pda/compressed-pdas/overview.mdx @@ -1,36 +1,99 @@ --- title: Overview & Program Template -description: Compressed PDAs provide full functionality of accounts at PDAs, without rent-exemption per account. -keywords: ["rent free program derived addresses", "rent free pda accounts", "compressed pda on solana", "infrastructure for depins on solana", "scalable solana infrastructure", "stake accounts for depins", "cost efficient stake accounts", "scalable reward distribution on solana"] +description: Compressed PDAs provide full composability and functionality of accounts at PDAs, without rent-exemption per account. Suited for accounts where each user or entity gets their own PDA and state is infrequently accessed. +keywords: ["user state", "app state", "node acounts", "depin accounts", "stake accounts", "not shared state or config or pool accounts", "rent free program derived addresses", "rent free pda accounts", "compressed pda on solana", "infrastructure for depins on solana", "scalable solana infrastructure", "stake accounts for depins", "cost efficient stake accounts", "scalable reward distribution on solana"] --- import ProgramExamplesTable from '/snippets/overview-tables/program-examples-table.mdx'; import DevelopmentEnvironmentSetup from '/snippets/setup/development-environment-setup.mdx'; +import CompressedPdasGuidesTable from '/snippets/overview-tables/compressed-pdas-guides-table.mdx'; +import SdkReferenceCompressedPdas from '/snippets/overview-tables/sdk-reference-compressed-pdas.mdx'; | Creation | Regular PDA Account | Compressed PDA | | :------------- | :--------------------- | :---------------------- | | 100-byte PDA | ~1,600,000 lamports | 15,000 lamports | -Compressed PDAs are derived using a specific program address and seed, like regular PDAs. Custom programs invoke the Light System program to create and update accounts, instead of the System program. +Compressed PDAs are derived using a specific program address and seed, like regular PDAs. +Custom programs invoke the Light System program +to create and update compressed accounts, instead of the System program. +Compressed PDAs are compressed accounts with an address. -#### Compressed PDAs at a Glance - - - - Create accounts at program-derived addresses without upfront rent exempt balance. - - - Persistent unique identification and program ownership. - - - CPI support between compressed and regular PDAs. - - - -# Start Building + +Compressed PDAs are suited for: +- Per-user state (profiles, preferences, credentials) +- DePIN node accounts and stake accounts +- Nullifiers to prevent an on-chain instruction from +being executed twice (little implementation overhead and useful e.g. for [payments](/pda/compressed-pdas/guides/how-to-create-nullifier-pdas) or [ZK programs](zk/overview)) +- App state that is written to and read from infrequently + +For DeFi pools, vaults, shared state, pool accounts, or config accounts, use [Light-PDA](/pda/light-pda/overview) with minimal code changes. + -Developing with compressed PDAs works similar to regular PDAs and involves minimal setup: + + +
+ + ![](/images/Untitled.png) + +
+
+ + ![](/images/image-22.png) + +
+ + +
+ + ![](/images/Untitled-1.png) + +
+
+ + ![](/images/image-20.png) + +
+ + +
+ + ![](/images/Untitled-4.png) + +
+
+ + ![](/images/image-23.png) + +
+ + +
+ + ![](/images/program-reinit-1.png) + +
+
+ + ![](/images/program-reinit.png) + +
+ + +
+ + ![](/images/program-burn-1.png) + +
+
+ + ![](/images/program-burn.png) + +
+ + + +# Start Building with the Program Template @@ -174,10 +237,17 @@ Caused by: +## Guides + + + ## Program Examples +## SDK Reference + + # Next Steps @@ -185,6 +255,6 @@ Caused by: title="Build a client for your program." icon="chevron-right" color="#0066ff" - href="/client-library/client-guide" + href="/pda/compressed-pdas/guides/client-guide" horizontal /> diff --git a/pda/compressed-pdas/program-examples.mdx b/pda/compressed-pdas/program-examples.mdx new file mode 100644 index 00000000..e47944f1 --- /dev/null +++ b/pda/compressed-pdas/program-examples.mdx @@ -0,0 +1,67 @@ +--- +title: Program Examples +description: Program example repository for compressed accounts with tests. +--- + +## Airdrop claim reference implementations + +- **Basic**: [**simple-claim**](https://github.com/Lightprotocol/program-examples/tree/main/airdrop-implementations/simple-claim) - Distributes compressed tokens that get decompressed to SPL on claim with cliff. +- **Advanced**: [**merkle-distributor**](https://github.com/Lightprotocol/program-examples/tree/main/airdrop-implementations/distributor) - Distributes SPL tokens, uses compressed PDAs to track claims with linear vesting, partial claims and clawback. Based on Jito Merkle distributor and optimized with rent-free PDAs. + + +For simple client-side distribution visit [this example](https://github.com/Lightprotocol/example-token-distribution). + + +## Basic operations + +- **create** - Initialize a new compressed account + - [Anchor](https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor/create) | [Native](https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/native/programs/create) +- **update** - Modify data in an existing compressed account + - [Anchor](https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor/update) | [Native](https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/native/programs/update) +- **close** - Clear account data and preserve its address + - [Anchor](https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor/close) | [Native](https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/native/programs/close) +- **reinit** - Reinitialize a closed account with the same address + - [Anchor](https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor/reinit) | [Native](https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/native/programs/reinit) +- **burn** - Permanently delete a compressed account + - [Anchor](https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor/burn) | [Native](https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/native/programs/burn) + +## Nullifier program + +[**nullifier-program**](https://github.com/Lightprotocol/nullifier-program) - For some use cases, such as sending payments, you might want to prevent your onchain instruction from being executed more than once. Creates a rent-free PDA derived from an id. If the id has been used before, the PDA already exists, causing the instruction to fail. + +SDK: [`light-nullifier-program`](https://docs.rs/light-nullifier-program) | [Example client usage](https://github.com/Lightprotocol/examples-light-token/blob/main/rust-client/actions/create_nullifier.rs) + +## Counter program + +Full compressed account lifecycle (create, increment, decrement, reset, close): + +- [**counter/anchor**](https://github.com/Lightprotocol/program-examples/tree/main/counter/anchor) - Anchor program with Rust and TypeScript tests +- [**counter/native**](https://github.com/Lightprotocol/program-examples/tree/main/counter/native) - Native Solana program with `light-sdk` and Rust tests +- [**counter/pinocchio**](https://github.com/Lightprotocol/program-examples/tree/main/counter/pinocchio) - Pinocchio program with `light-sdk-pinocchio` and Rust tests + +## Create-and-update program + +[**create-and-update**](https://github.com/Lightprotocol/program-examples/tree/main/create-and-update) - Create a new compressed account and update an existing compressed account with a single validity proof in one instruction. + +## Create-and-read program + +[**read-only**](https://github.com/Lightprotocol/program-examples/tree/main/read-only) - Create a new compressed account and read it onchain. + +## Compare program with Solana vs compressed accounts + +[**account-comparison**](https://github.com/Lightprotocol/program-examples/tree/main/account-comparison) - Compare compressed vs regular Solana accounts. + +## ZK programs + +- [**zk-id**](https://github.com/Lightprotocol/program-examples/tree/main/zk/zk-id) - Identity verification using Groth16 proofs. Issuers create credentials; users prove ownership without revealing the credential. +- [**nullifier**](https://github.com/Lightprotocol/program-examples/tree/main/zk/nullifier) - Simple program to create nullifiers for ZK programs. + +## Next steps + + \ No newline at end of file diff --git a/compressed-pdas/solana-attestation-service.mdx b/pda/compressed-pdas/solana-attestation-service.mdx similarity index 60% rename from compressed-pdas/solana-attestation-service.mdx rename to pda/compressed-pdas/solana-attestation-service.mdx index ab14417b..61f21254 100644 --- a/compressed-pdas/solana-attestation-service.mdx +++ b/pda/compressed-pdas/solana-attestation-service.mdx @@ -1,7 +1,6 @@ --- title: "Solana Attestation Service (Devnet)" -description: "Build compressed attestations on Solana using ZK Compression. Currently undergoing audit." -url: "https://github.com/solana-foundation/solana-attestation-service/tree/a8fb187978ecea0b165e63767c7e6b1c036e7b52/examples/typescript/attestation-flow-guides" +description: " Credential system for KYC verification, professional badges, and compliance credentials in minutes. Currently undergoing audit." keywords: ["solana attestation service", "attestations for identity verification", "on-chain attestations solana", "identity verification on solana"] --- diff --git a/pda/light-pda/overview.mdx b/pda/light-pda/overview.mdx new file mode 100644 index 00000000..49053100 --- /dev/null +++ b/pda/light-pda/overview.mdx @@ -0,0 +1,212 @@ +--- +title: "Light PDA" +description: "Create Solana PDA accounts with sponsored rent-exemption and minimal code changes. Suited for DeFi pools, vaults, shared state, pool accounts, or config accounts." +--- + +import FullCounterExample from '/snippets/code-snippets/light-token/counter/anchor-macro/full-example.mdx'; +import AgentSkillGeneric from "/snippets/setup/agent-skill-generic.mdx"; +import LightPdaAiPrompt from "/snippets/ai-prompts/anchor-programs/light-pda.mdx"; + +| Creation Cost | Regular PDA | Light-PDA | +|------------------|----------------------|-----------------| +| 100-byte account | ~1,600,000 lamports | ~11,500 lamports | + +A Light-PDA is a standard Solana PDA. Seeds, bump derivation, and +`invoke_signed` work the same way. Your instruction handlers for reads, +updates, and closes don't change. + +## What changes + +Audit overhead is minimal as your program logic is mostly untouched. The rest is macro-generated. + +| Area | Change | +|------|--------| +| State struct | Derive `LightAccount`, add `compression_info: CompressionInfo` | +| Accounts struct | Derive `LightAccounts`, add `#[light_account]` on init accounts | +| Program module | Add `#[light_program]` above `#[program]` | +| Instructions (reads, updates, closes) | No program changes. Client prepends a load instruction if account is cold. | + +--- + + + + + + +## Step 1: Dependencies + +```toml +[dependencies] +light-account = { version = "0.20.0", features = ["anchor"] } +light-sdk = { version = "0.20.0", features = ["anchor", "v2", "cpi-context"] } +anchor-lang = "0.31" +``` + +## Step 2: State struct + +Add `compression_info` field and derive `LightAccount`: + +```rust +use light_account::{CompressionInfo, LightAccount}; + +#[derive(Default, Debug, InitSpace, LightAccount)] +#[account] +pub struct Counter { + /// Add this: + pub compression_info: CompressionInfo, + + pub owner: Pubkey, + pub count: u64, +} +``` + +## Step 3: Program module + +Add `#[light_program]` above `#[program]`. Define the CPI signer constant with your program ID: + +```rust +use light_account::{derive_light_cpi_signer, light_program, CpiSigner}; + +pub const LIGHT_CPI_SIGNER: CpiSigner = + derive_light_cpi_signer!("YourProgramId11111111111111111111111111111111"); + +#[light_program] +#[program] +pub mod counter { + use super::*; + + pub fn create_counter<'info>( + ctx: Context<'_, '_, '_, 'info, CreateCounter<'info>>, + params: CreateCounterParams, + ) -> Result<()> { + ctx.accounts.counter.owner = ctx.accounts.owner.key(); + ctx.accounts.counter.count = params.count; + Ok(()) + } + + /// Standard Anchor — no Light-specific changes. + pub fn increment(ctx: Context) -> Result<()> { + ctx.accounts.counter.count = ctx.accounts.counter.count.checked_add(1).unwrap(); + Ok(()) + } + + /// Standard Anchor — no Light-specific changes. + pub fn close_counter(_ctx: Context) -> Result<()> { + Ok(()) + } +} +``` + +## Step 4: Accounts struct + +Derive `LightAccounts` on your `Accounts` struct and add `#[light_account(...)]` next to `#[account(...)]`. + +Only the `init` struct derives `LightAccounts`. The increment and close structs +are standard Anchor: + +```rust +use light_account::{CreateAccountsProof, LightAccounts}; + +#[derive(AnchorSerialize, AnchorDeserialize, Clone)] +pub struct CreateCounterParams { + pub create_accounts_proof: CreateAccountsProof, + pub count: u64, +} + +#[derive(Accounts, LightAccounts)] +#[instruction(params: CreateCounterParams)] +pub struct CreateCounter<'info> { + #[account(mut)] + pub fee_payer: Signer<'info>, + + /// CHECK: Read-only, used for PDA derivation. + pub owner: AccountInfo<'info>, + + /// CHECK: Validated by Light Protocol CPI. + pub compression_config: AccountInfo<'info>, + + /// CHECK: PDA rent sponsor for compression rent reimbursement. + #[account(mut)] + pub pda_rent_sponsor: AccountInfo<'info>, + + #[account( + init, + payer = fee_payer, + space = 8 + ::INIT_SPACE, + seeds = [COUNTER_SEED, owner.key().as_ref()], + bump, + )] + #[light_account(init)] + pub counter: Account<'info, Counter>, + + pub system_program: Program<'info, System>, +} +``` + +## Full Example + + + + +View counter example on Github: [counter](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-macros/counter) + + + + + + + + +--- + +## How it works + +The SDK sponsors rent-exemption so you +don't pay the full rent-exempt balance upfront. After extended inactivity, the account +compresses to cold state and returns the rent-exempt balance to the rent +sponsor. Clients call `create_load_instructions` to load a cold account back +on-chain when it's needed again. Your program only ever interacts with hot accounts. + +| | Hot (active) | Cold (inactive) | +|---|---|---| +| Storage | On-chain | Compressed | +| Latency/CU | No change | +load instruction | +| Your program code | No change | No change | + +## FAQ + + When creating an +account for the first time, the SDK provides a proof that the account doesn't +exist in the cold address space. The SVM already verifies this for the onchain +space. Both address spaces are checked before creation, preventing re-init +attacks, even if the account is currently cold. + + +Miners (Forester nodes) compress accounts that have been inactive for an extended period of time (when their virtual rent balance drops below threshold). +In practice, having to load cold accounts should be rare. The common path (hot) has no extra overhead and does not increase CU or txn size. + + + +When accounts compress after extended inactivity, the on-chain rent-exemption is released back +to the rent sponsor. This creates a revolving lifecycle: active "hot" accounts hold a +rent-exempt lamports balance, inactive "cold" accounts release it back. The +rent sponsor must be derived from the program owner. For all mint, ATA, and +token accounts, the Light Token Program is the rent sponsor. For your own program-owned PDAs, the SDK derives a rent sponsor address automatically. + + + +**Hot path (e.g. reads, updates, closes):** No. Active accounts do not add CU overhead to your instructions. + +**First time init + loading cold accounts:** Yes, adds up to 15k-400k CU, +depending on number and type of accounts being initialized or loaded. + + +--- + + +API is in Beta and subject to change. + +Questions or need hands-on support? [Telegram](https://t.me/swen_light) | [email](mailto:support@lightprotocol.com) | [Discord](https://discord.com/invite/7cJ8BhAXhu) + + + diff --git a/pda/overview.mdx b/pda/overview.mdx new file mode 100644 index 00000000..5995342d --- /dev/null +++ b/pda/overview.mdx @@ -0,0 +1,44 @@ +--- +title: "PDA accounts" +sidebarTitle: "Overview" +description: "Overview to Light-PDAs (Solana accounts with sponsored rent-exemption) and compressed PDAs (compressed accounts without rent-exemption)." +--- +import CompressibleRentExplained from "/snippets/compressible-rent-explained.mdx"; + +## Light-PDA + +Light-PDAs are Solana PDAs with sponsored rent-exemption and can be implemented with minimal code changes to your existing Solana program. +Your program logic stays mostly untouched, which keeps audit overhead minimal. + +| | Regular PDA | Light-PDA | +|------------------|----------------------|-----------------| +| 100-byte account | ~1,600,000 lamports | ~11,500 lamports | + +> Use Light-PDA for DeFi pools, vaults, config, and any shared program state. + + + + + + + +--- + +## Advanced: Compressed PDA + +Compressed PDAs are compressed accounts with an address. +Programs invoke the Light System program to create and update compressed accounts, instead of the System program. +Fully compatible with existing Solana programs, but requires custom logic. + +| | Regular PDA | Compressed PDA | +|------------------|----------------------|-----------------| +| 100-byte account | ~1,600,000 lamports | 15,000 lamports | + +> Use for accounts where each user or entity gets their own PDA and state is infrequently accessed: +> - Per-user state (profiles, preferences, credentials) +> - DePIN node accounts and stake accounts +> - Nullifiers to prevent an on-chain instruction from +> being executed twice (little implementation overhead and useful e.g. for [payments](/pda/compressed-pdas/guides/how-to-create-nullifier-pdas) or [ZK programs](zk/overview)) +> - App state that is written to and read from infrequently + + \ No newline at end of file diff --git a/quickstart.mdx b/quickstart.mdx deleted file mode 100644 index f02837fa..00000000 --- a/quickstart.mdx +++ /dev/null @@ -1,101 +0,0 @@ ---- -title: Quickstart -description: Create your first compressed tokens in under 5 minutes. -sidebarTitle: Quickstart -keywords: ["zk compression quickstart", "compressed accounts tutorial", "solana compression guide"] ---- - -import FullSetup from "/snippets/setup/full-setup.mdx"; - - - - -## Prerequisites - - - - - -## Mint Compressed Tokens - -```typescript -// 1. Load wallet and connect to Localnet -// 2. Create SPL mint with SPL interface via createMint() -// 3. Mint compressed tokens to recipient account via mintTo() -// 4. Verify compressed token balance via getCompressedTokenAccountsByOwner - -import { createRpc } from "@lightprotocol/stateless.js"; -import { createMint, mintTo } from "@lightprotocol/compressed-token"; -import { Keypair } from "@solana/web3.js"; -import { readFileSync } from "fs"; -import { homedir } from "os"; - -// Step 1: Load wallet from filesystem -const payer = Keypair.fromSecretKey( - new Uint8Array(JSON.parse(readFileSync(`${homedir()}/.config/solana/id.json`, "utf8"))) -); - -// Connect to local test-validator -const RPC_ENDPOINT = "http://localhost:8899"; -const COMPRESSION_ENDPOINT = "http://localhost:8784"; -const PROVER_ENDPOINT = "http://localhost:3001"; -const connection = createRpc(RPC_ENDPOINT, COMPRESSION_ENDPOINT, PROVER_ENDPOINT); - -const main = async () => { - try { - // Step 2: Create SPL mint with SPL interface - console.log("\nCreating SPL mint with SPL interface for compression"); - const { mint, transactionSignature } = await createMint( - connection, - payer, - payer.publicKey, // mintAuthority - 9 - ); - - console.log(`Mint address: ${mint.toBase58()}`); - console.log( - `Create mint transaction: https://explorer.solana.com/tx/${transactionSignature}?cluster=custom&customUrl=http://localhost:8899` - ); - - // Step 3: Mint compressed tokens to recipient account - console.log("\nMinting compressed token..."); - const mintAmount = 1000000000; // mintAmount with decimals - const mintToTxId = await mintTo( - connection, - payer, - mint, // SPL mint with SPL interface for compression - payer.publicKey, // recipient.publicKey - payer, // mintAuthority - mintAmount - ); - - console.log(`Compressed Token minted ${mintAmount / 1e9} token`); - console.log( - `Transaction: https://explorer.solana.com/tx/${mintToTxId}?cluster=custom&customUrl=http://localhost:8899` - ); - - // Step 4: Verify compressed token balance via getCompressedTokenAccountsByOwner - const tokenAccounts = await connection.getCompressedTokenAccountsByOwner( - payer.publicKey, - { mint } // SPL mint with SPL interface for compression - ); - } catch (error: any) { - console.error("Error:", error.message); - } -}; - -main().catch(console.error); -``` - - - - -# Next Steps - - diff --git a/references/migration-v1-to-v2.mdx b/references/migration-v1-to-v2.mdx index f89b9580..fececb7c 100644 --- a/references/migration-v1-to-v2.mdx +++ b/references/migration-v1-to-v2.mdx @@ -335,6 +335,6 @@ const remainingAccounts = PackedAccounts.newWithSystemAccountsV2(systemAccountCo title="Program examples" icon="chevron-right" color="#0066ff" - href="/compressed-pdas/program-examples" + href="/pda/compressed-pdas/program-examples" horizontal /> diff --git a/references/security.mdx b/references/security.mdx index 2cba2a01..4b7e1fe8 100644 --- a/references/security.mdx +++ b/references/security.mdx @@ -10,18 +10,24 @@ Light Protocol is hosting a [bug bounty program](https://immunefi.com/bug-bounty ### Security Audits -The Light protocol on-chain programs were audited by independent security firms Neodyme, OtterSec, Accretion, and Zellic. - -- [Accretion audit report](https://github.com/Lightprotocol/light-protocol/blob/main/audits/accretion_v1_update_audit.pdf) (January '25) -- [Zellic audit report](https://github.com/Lightprotocol/light-protocol/blob/main/audits/zellic_v1_audit.pdf) (September '24) -- [Neodyme audit report](https://github.com/Lightprotocol/light-protocol/blob/main/audits/neodyme_v1_audit.pdf) (August '24) -- [OtterSec audit report](https://github.com/Lightprotocol/light-protocol/blob/main/audits/ottersec_v1_audit.pdf) (July '24) - -A complete list of 3rd party audits can be found [here](https://github.com/Lightprotocol/light-protocol/tree/main/audits). +The Light protocol on-chain programs were audited by independent security firms Certora, OtterSec, Accretion, HashCloak, Neodyme, and Zellic. + +| Firm | Scope | Date | Report | +| :--- | :--- | :--- | :--- | +| **Certora** | Light Token | December '25 | [View](https://github.com/Lightprotocol/light-protocol/blob/main/audits/certora_2025-12_light-token.pdf) | +| **OtterSec** | CPI Context Refactor | December '25 | [View](https://github.com/Lightprotocol/light-protocol/blob/main/audits/ottersec_2025-12_cpi-context-refactor.pdf) | +| **Accretion** | ZK Compression v2 | June '25 | [View](https://github.com/Lightprotocol/light-protocol/blob/main/audits/accretion_2025-06_zkcompression-v2.pdf) | +| **OtterSec** | Batched Merkle Trees | June '25 | [View](https://github.com/Lightprotocol/light-protocol/blob/main/audits/ottersec_2025-06_batched-merkle-trees.pdf) | +| **HashCloak** | Compressed Token & ZK Compression v2 | March '25 | [View](https://github.com/Lightprotocol/light-protocol/blob/main/audits/hashcloak_2025-03_compressed-token-update-and-zkcompression-v2.pdf) | +| **OtterSec** | Zerocopy | March '25 | [View](https://github.com/Lightprotocol/light-protocol/blob/main/audits/ottersec_2025-03_zerocopy.pdf) | +| **Accretion** | Compressed Token Program Update | January '25 | [View](https://github.com/Lightprotocol/light-protocol/blob/main/audits/accretion_2025-01_compressed-token-program-update.pdf) | +| **Zellic** | ZK Compression v1 | September '24 | [View](https://github.com/Lightprotocol/light-protocol/blob/main/audits/zellic_2024-09_zkcompression-v1.pdf) | +| **Neodyme** | ZK Compression v1 | August '24 | [View](https://github.com/Lightprotocol/light-protocol/blob/main/audits/neodyme_2024-08_zkcompression-v1.pdf) | +| **OtterSec** | ZK Compression v1 | August '24 | [View](https://github.com/Lightprotocol/light-protocol/blob/main/audits/ottersec_2024-08_zkcompression-v1.pdf) | ### Groth16 Circuit Security -The ZK Compression circuit was formally verified by Reilabs. See the report [here](https://github.com/Lightprotocol/light-protocol/blob/main/audits/reilabs_circuits_formal_verification_report.pdf). +The ZK Compression circuit was formally verified by Reilabs. See the report [here](https://github.com/Lightprotocol/light-protocol/blob/main/audits/reilabs_2024-08_circuits_formal_verification_report.pdf). Information about the Trusted Setup Ceremony for the groth16 circuits is [here](https://github.com/Lightprotocol/gnark-mt-setup/blob/main/README.md). diff --git a/references/terminology.mdx b/references/terminology.mdx index f97ab783..c84525e2 100644 --- a/references/terminology.mdx +++ b/references/terminology.mdx @@ -1,8 +1,11 @@ --- title: "Terminology" -description: "Overview to terminology related to ZK Compression and Solana" +description: "Overview of terminology related to ZK Compression, Light Token, and Solana" --- +import CompressibleRentExplained from "/snippets/compressible-rent-explained.mdx"; +import CompressibleVsSolanaRent from "/snippets/compressible-vs-solana-rent.mdx"; + ## Account An entry in the Solana ledger that holds data or executable program code, stored on chain. @@ -15,11 +18,36 @@ There are different kinds of accounts, including ## Account Compression Program -Light Protocol's program that implements state and address trees for ZK Compression. The program provides the underlying Merkle tree infrastructure used by the Light System Program to manage compressed account state transitions. +Light Protocol's program that implements state and address trees for ZK Compression. The Light System Program uses the Account Compression Program's Merkle tree infrastructure to store compressed account state transitions. - - **Source**: https://github.com/Lightprotocol/light-protocol/tree/main/programs/account-compression - +> **Program ID**: `compr6CUsB5m2jS4Y3831ztGSTnDpnKJTKS95d64XVq` | [Source](https://github.com/Lightprotocol/light-protocol/tree/main/programs/account-compression) + +## Account Compression Authority + +A PDA that signs CPI calls from the Light System Program to the Account Compression Program. Derived from the Light System Program ID with seed `b'cpi_authority'`. + +> **Address**: `HZH7qSLcpAeDqCopVU4e5XkhT9j3JFsQiq8CmruY3aru` + +## Agent skills + +Folders of instructions, scripts, and resources that AI agents can discover and use to build on Light Protocol more accurately and efficiently. +Light Protocol provides agent skills for rent-free Solana development: Light-PDA, token and mint accounts. +Skills for compressed PDAs and more are in development. + +| Use case | Skill | +|----------|-------| +| Build DeFi programs (AMMs, vaults, lending) with Anchor or Pinocchio | [defi-program](https://github.com/Lightprotocol/skills/tree/main/skills/defi-program) | +| Integrate rent-free markets into routers and aggregators | [defi-router](https://github.com/Lightprotocol/skills/tree/main/skills/defi-router) | +| Stream account state via Laserstream gRPC | [data-streaming](https://github.com/Lightprotocol/skills/tree/main/skills/data-streaming) | +| Wallets and payment flows with Light Token. Optional nullifier to prevent your on-chain instruction from being executed more than once. | [payments-and-wallets](https://github.com/Lightprotocol/skills/tree/main/skills/payments-and-wallets) | +| Airdrops, DePIN, token distribution | [airdrop](https://github.com/Lightprotocol/skills/tree/main/skills/airdrop) | +| Anti-double-spend nullifiers for privacy-preserving ZK programs | [zk-nullifier](https://github.com/Lightprotocol/skills/tree/main/skills/zk-nullifier) | +| Testing programs and clients on localnet, devnet, mainnet | [testing](https://github.com/Lightprotocol/skills/tree/main/skills/testing) | +| Help with debugging and questions via DeepWiki MCP | [ask-mcp](https://github.com/Lightprotocol/skills/tree/main/skills/ask-mcp) | + +Built on [Anthropic's Skills](https://github.com/anthropics/skills) and the [Agent Skills Specification](https://agentskills.io). + +> [Source Code](https://github.com/Lightprotocol/skills) | [Claude plugin](https://github.com/Lightprotocol/skills/tree/main/.claude-plugin) | [OpenClaw plugin](https://github.com/Lightprotocol/skills/blob/main/openclaw.plugin.json) ## Address tree @@ -32,59 +60,61 @@ Two address tree versions are currently supported: - **V1 address trees**: Height 26 (~67 million addresses) - **V2 batched address trees**: Height 40 (~1 trillion addresses), optimizing compute unit consumption by up to 70%. V2 is currently on Devnet. -## [Client](https://solana.com/docs/core/transactions#client) - -A computer program that accesses the Solana server network [cluster](https://solana.com/docs/core/transactions#cluster). +| Version | Address Tree | Address Queue | +|:--------|:-------------|:--------------| +| V2 | `amt2kaJA14v3urZbZvnc5v2np8jqvc4Z8zDep5wbtzx` | — | +| V1 (deprecated) | `amt1Ayt45jfbdw5YSo7iz6WZxUmnZsQTYXy82hVwyC2` | `aq1S9z4reTSQAdgWHGD2zDaS39sjGrAxbR31vxJ2F4F` | -## [**Cluster**](https://solana.com/docs/references/terminology#cluster) +## Address queue -A set of [validators](https://solana.com/docs/references/terminology#validator) maintaining a single [ledger](https://solana.com/docs/references/terminology#ledger). - -## Compressed PDA +A queue used in V1 address trees to buffer new addresses before Forester nodes insert them into the address tree. V2 address trees do not use a separate queue. -Compressed accounts at Program Derived Addresses. +> **Address (V1)**: `aq1S9z4reTSQAdgWHGD2zDaS39sjGrAxbR31vxJ2F4F` -## Compressed account +## [Client](https://solana.com/docs/core/transactions#client) -A data structure that holds arbitrary data, represented as a 32-byte hash stored in a leaf of a state Merkle tree. Compressed accounts do not require a rent exempt balance upon creation. +A computer program that accesses the Solana server network [cluster](https://solana.com/docs/core/transactions#cluster). -## Compressed Account hash +## [Cluster](https://solana.com/docs/references/terminology#cluster) -A 32-byte identifier uniquely that represents a compressed account's state, stored in a state tree. +A set of [validators](https://solana.com/docs/references/terminology#validator) maintaining a single [ledger](https://solana.com/docs/references/terminology#ledger). -## Token mint +## Cold account -An SPL token mint uniquely represents a token on the Solana network and stores global metadata about the token, including `mint_authority`, `supply`, and `decimals`. +A Light Token account, Light Token mint, or Light-PDA that has been compressed after extended inactivity. The account's state is cryptographically preserved on the Solana ledger as a compressed account. On-chain lookups return `is_initialized: false`. Clients call `create_load_instructions` to reinstate the account. -SPL tokens can be compressed if the mint has an SPL Interface PDA set up. Anyone can create an SPL interface for any given SPL mint. +## Compressible account -## SPL Interface (omnibus account) +A Solana account (Light Token account, Light Token mint, or Light-PDA) that automatically compresses when its rent balance drops below threshold. Forester nodes execute the compression. The account can be loaded back when accessed again. -An SPL token account (the SPL Interface PDA) that holds SPL tokens corresponding to compressed tokens in circulation. Tokens are deposited during compression and withdrawn during decompression; the account is owned by the Light Token Program's CPI authority PDA. +## Compressed account -## Concurrency +A data structure that holds arbitrary data, represented as a 32-byte hash stored in a leaf of a state Merkle tree. Compressed accounts do not require a rent exempt balance upon creation. -The ability to process multiple Merkle tree update requests simultaneously without invalidating each other, as long as they don't modify the same leaf. +## Compressed account hash -Concurrency in ZK Compression allows parallel operations on different tree leaves without requiring locks. +A 32-byte identifier that uniquely represents a compressed account's state, stored in a state tree. -## Compressed Token +## Compressed PDA -An SPL token in compressed form. Compressed tokens do not require an associated token account per holder. +Compressed accounts with an address stored in an address Merkle tree. +Full Solana PDA functionality and composability without rent-exemption. -## Compressed Token account +> [Docs](/pda/compressed-pdas/overview) -An account type in the Light Token Program to store information about an individual's ownership of a specific token (mint). Compressed token accounts do not require a rent exempt balance upon creation. +## Compressed token -## Light Token Program +An SPL token stored as a compressed account hash in a state tree. Compressed tokens incur no rent and do not require a token account per holder. -Light Protocol's SPL-compatible token program that enables compression and decompression of token accounts. The program enforces SPL token layout standards and allows for arbitrary transitions between compressed and regular format. +> [Docs](/compressed-tokens/overview) -## [**Compute units**](https://solana.com/docs/references/terminology#compute-units) +## Compressed token account -The smallest unit of measure for consumption of computational resources of the transactions on the Solana blockchain. +A compressed account that stores a token balance for a specific mint. +Compressed token accounts do not require a rent exempt balance upon creation. +Compressed token accounts are compressed accounts that do not need an address. -## [**Compute unit budget**](https://solana.com/docs/references/terminology#compute-budget) +## [Compute unit budget](https://solana.com/docs/references/terminology#compute-budget) The maximum number of [compute units](https://solana.com/docs/references/terminology#compute-units) consumed per transaction. @@ -98,15 +128,29 @@ The total amount of compute units that all transactions in a single Solana block The maximum compute units that can be used to modify a single account within a block - the _write lock limit -_ is currently set at 12 million CU. +## [Compute units](https://solana.com/docs/references/terminology#compute-units) + +The smallest unit of measure for consumption of computational resources of the transactions on the Solana blockchain. + ## [Cross-program invocation (CPI)](https://solana.com/docs/core/transactions#cross-program-invocation-cpi) A call from one [program](https://solana.com/docs/core/transactions#onchain-program) to another. For more information, see [calling between programs](https://solana.com/docs/core/cpi). +## CPI context account + +An account passed in transactions that stores intermediate CPI state for compressed account operations. Each state tree has a dedicated CPI context account. + +Addresses are listed under the state tree entry. + +## CPI signer + +A PDA that signs CPI calls from your program to the Light System Program. Verified by the Light System Program during CPI. Derived from your program ID using `derive_light_cpi_signer`. + ## Decompression -The process of converting a compressed to a regular Solana account. SPL tokens are withdrawn from the SPL Interface PDA to an Associated Token Account and compressed token accounts are invalidated. +The process of converting a compressed account to a regular Solana account. For token decompression, SPL tokens are released from the SPL interface PDA to an associated token account, and the compressed token account is invalidated. ## Forester node / Forester @@ -118,19 +162,23 @@ A zero-knowledge SNARK that produces constant-size proofs using bilinear pairing ZK Compression uses Groth16 to generate 128 byte validity proofs to verify compressed account state transitions against the on-chain root. -## [**Hash**](https://solana.com/docs/references/terminology#hash) +## [Hash](https://solana.com/docs/references/terminology#hash) A hash is a digital fingerprint of a sequence of bytes representing arbitrary data, while requiring far less storage space than the original data. +## Hot account + +A Light Token account, Light Token mint, or Light-PDA that is active on-chain with a rent-exempt balance. Programs interact only with hot accounts. Clients call `create_load_instructions` to reinstate cold accounts before use. + ## Indexer -A service that tracks state changes of compressed accounts on the Solana ledger and provides RPC APIs for querying compressed accounts and generating validity proofs. +A service that tracks state changes of compressed accounts on the Solana ledger. The indexer exposes RPC APIs for querying compressed accounts and generating validity proofs. The ZK Compression indexer is named Photon and is maintained by Helius Labs. **Source**: https://github.com/helius-labs/photon -## [**Instruction**](https://solana.com/docs/references/terminology#instruction) +## [Instruction](https://solana.com/docs/references/terminology#instruction) A call to invoke a specific [instruction handler](https://solana.com/docs/references/terminology#instruction-handler) in a [program](https://solana.com/docs/references/terminology#program). @@ -142,32 +190,78 @@ For example, compressed accounts are created or updated with the `InvokeCpiInstr The numerical position (u32) of a compressed account within a state tree, used for Merkle proof generation. +## Ledger + +The ledger is an immutable historical record of all Solana transactions signed by clients since the genesis block. + +A helpful analogy to differentiate Solana ledger and state: + +- Ledger is the entire bank statement history. +- State is the current account balance, derived from all transactions in the bank statement history. + +## Light-PDA + +A Solana PDA with sponsored rent-exemption. Programs create Light-PDAs using Anchor `#[account(init)]` with `#[light_account(init)]`. Compresses automatically after extended inactivity; clients load the account back when it's accessed again. Program logic does not change for reads, updates, or closes. Only the init instruction and state struct require additions. + +> [Docs](/pda/light-pda/overview) | [Overview](/pda/overview) | [Example](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-macros/counter) + ## Light System Program ZK Compression's core program that validates compressed account state transitions by verifying validity proofs and managing compressed state changes. The program enforces compressed account layout with ownership and sum checks, and is invoked to create and write to compressed accounts and PDAs. -**Source**: https://github.com/Lightprotocol/light-protocol/tree/main/programs/system +> **Program ID**: `SySTEM1eSU2p4BGQfQpimFEWWSC1XDFeun3Nqzz3rT7` | [Source](https://github.com/Lightprotocol/light-protocol/tree/main/programs/system) -## **Ledger** +## Light Token -The ledger is an immutable historical record of all Solana transactions signed by clients since the genesis block. +A token standard that reduces the cost of mint and token accounts by 200x compared to SPL. Functionally equivalent to SPL but stores accounts more efficiently. The Light Token SDK API is a superset of the SPL-token API. -A helpful analogy to differentiate Solana ledger and state: +Light Token accounts exist in two states: hot (active on-chain) and cold (compressed after inactivity). The Light Token Program sponsors rent-exemption for account creation. -- Ledger is the entire bank statement history. -- State is the current account balance, derived from all transactions in the bank statement history. +Different from ZK Compression, interactions with Light Token accounts do not require a validity proof for interactions. +ZK Compression is used under the hood for inactive token accounts (cold state). -## Merkle tree +> [Docs](/light-token/welcome) | [Example](https://github.com/Lightprotocol/examples-light-token) -A tree data structure to allow for cryptographic verification of the integrity of all leaves in a tree. +## Light Token account -Each leaf on a Merkle tree is a hash of that leaf's data. A Merkle tree compresses data by hashing pairs of data repeatedly into a single root hash, starting from the lowest level. Only this root hash is stored on chain. On Solana, this process is called state compression. +A Solana account that holds a token balance for a specific mint (SPL, Token 2022, or Light Token). The Light Token Program sponsors the rent-exemption cost. Follows the same layout as SPL token accounts. Compresses automatically after extended inactivity and can be loaded back when accessed. -## Merkle tree account +> [Docs](/light-token/cookbook/create-token-account) | [Example](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/create-token-account) -The public key of the on-chain Merkle tree account used in ZK Compression. This identifier references the state tree that stores compressed account hashes. +## Light Token associated token account + +An associated token account created by the Light Token Program. The address is deterministically derived from the owner's address, Light Token Program ID, and mint address. Holds token balances of SPL, Token 2022, or Light Token mints with sponsored rent-exemption. + +> [Docs](/light-token/cookbook/create-ata) | [Example](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/create-associated-token-account) + +## Light Token mint + +An on-chain mint account owned by the Light Token Program. Functionally equivalent to an SPL mint but with sponsored rent-exemption. Stores a compressed address in an address Merkle tree at creation to preserve mint state when the account compresses. + +> [Docs](/light-token/cookbook/create-mint) | [Example](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/create-mint) | [Source Code](https://github.com/Lightprotocol/light-protocol/blob/main/sdk-libs/token-sdk/src/instruction/create_mint.rs) + +## Light Token Program + +Light Protocol's SPL-compatible token program. The Light Token Program compresses and decompresses token accounts, sponsors rent-exemption, and enforces SPL token layout standards. + +> **Program ID**: `cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m` | [Source](https://github.com/Lightprotocol/light-protocol/tree/main/programs/compressed-token) + +## Load associated token account + +Reinstates a compressed account back to active on-chain state. `loadAta` unifies token balances from compressed tokens, SPL, and Token 2022 into a single Light Token associated token account. Returns `null` if there's nothing to load (idempotent). Creates the associated token account if it doesn't exist. + +> [Docs](/light-token/cookbook/load-ata) | [Source Code](https://github.com/Lightprotocol/light-protocol/blob/0c4e2417b2df2d564721b89e18d1aad3665120e7/js/compressed-token/src/v3/actions/load-ata.ts) + +## Lookup table + +A Solana [address lookup table](https://solana.com/docs/advanced/lookup-tables) that reduces transaction size by referencing accounts by index instead of full public key. Light Protocol provides pre-initialized lookup tables covering program IDs and protocol accounts. + +| Network | Address | +|:--------|:--------| +| Mainnet | `9NYFyEqPkyXUhkerbGHXUXkvb4qpzeEdHuGpgbgpH1NJ` | +| Devnet | `qAJZMgnQJ8G6vA3WRcjD9Jan1wtKkaCFWLWskxJrR5V` | ## Merkle proof @@ -175,57 +269,98 @@ A cryptographic proof consisting of sibling node hashes required to verify that ZK Compression encodes Merkle proofs into zero-knowledge proofs (validity proofs). These verify compressed account operations with a constant 128-byte size without exposing the underlying variable-size Merkle proof data. +## Merkle tree + +A tree data structure to allow for cryptographic verification of the integrity of all leaves in a tree. + +Each leaf on a Merkle tree is a hash of that leaf's data. A Merkle tree compresses data by hashing pairs of data repeatedly into a single root hash, starting from the lowest level. Only this root hash is stored on chain. On Solana, this process is called state compression. + +## Merkle tree account + +The public key of the on-chain Merkle tree account used in ZK Compression. This identifier references the state tree that stores compressed account hashes. + ## Nullification The process of marking compressed accounts as spent to prevent double-spending. When compressed accounts are used as inputs in transactions, their previous states are invalidated by inserting their hashes into nullifier queues. Forester nodes process these queues to permanently update the corresponding Merkle tree leaves, ensuring each compressed account state can only be used once. +## Nullifier + +A nullifier is a unique identifier used to prevent an event from being executed more than once. It acts as a one-way, irreversible proof that a specific resource (such as a payment, note, token, or vote) has already been consumed. To implement nullifiers we need a data structure that ensures every nullifier is only created once and never deleted. On Solana a straight forward way to implement nullifiers is to create a PDA account with the nullifier as seed. + +The documentation provides two implementations with rent-free PDA accounts: + +**Nullifier PDA** — For use cases such as sending payments, where you want to prevent your on-chain instruction from being executed more than once. The nullifier program utility creates a rent-free PDA derived from id. If the id has been used before, the PDA already exists, causing the instruction to fail. + +| | | +|---|---| +| **Program ID** | `NFLx5WGPrTHHvdRNsidcrNcLxRruMC92E4yv7zhZBoT` | +| **Source code** | [github.com/Lightprotocol/nullifier-program](https://github.com/Lightprotocol/nullifier-program/) | +| **Rust SDK** | [light-nullifier-program](https://crates.io/crates/light-nullifier-program) | +| **TypeScript SDK** | [@lightprotocol/nullifier-program](https://www.npmjs.com/package/@lightprotocol/nullifier-program) | + +> [Docs](/pda/compressed-pdas/guides/how-to-create-nullifier-pdas) | [Skill](https://github.com/Lightprotocol/skills/tree/main/skills/payments-and-wallets) | [Example](https://github.com/Lightprotocol/examples-light-token/blob/main/rust-client/actions/create_nullifier.rs) + +**ZK nullifier** — For ZK or privacy-preserving programs on Solana to prevent double-spending. Can be integrated with minimal code changes. + +> [Docs](/zk/overview) | [Skill](https://github.com/Lightprotocol/skills/tree/main/skills/zk-nullifier) | [Example](https://github.com/Lightprotocol/program-examples/tree/main/zk/zk-nullifier) + ## Nullifier queue A queue where compressed accounts hashes used as input for transactions are temporarily stored to prevent double spending. A Forester node empties the queue by inserting queue elements into a state Merkle tree. -## [**Program**](https://solana.com/docs/references/terminology#onchain-program) +## Output queue -Programs run executable code similar to smart contracts on other blockchains with optimizations specific to Solana. +A queue in V2 state trees that buffers compressed account state changes before Forester nodes incorporate them into the state tree. Replaces the nullifier queue used in V1 state trees. -Solana programs key characteristics include: - -- Solana programs are stateless and do not store state internally. Separate accounts store state for programs to execute on, such as program, user or token data. This makes Solana's account model [different from Ethereum's](https://solana.com/news/evm-to-svm). -- Programs are typically written in Rust. -- Programs interpret the [instructions](https://solana.com/docs/references/terminology#instruction) sent inside of each [transaction](https://solana.com/docs/references/terminology#transaction) to read and modify accounts over which it has control, hence update state. +Addresses are listed under the state tree entry. ## Parallelism The ability of the SVM to execute multiple transactions simultaneously, as long as they modify different regular and/or compressed accounts. -## [**Program derived addresses (PDA)**](https://solana.com/docs/references/terminology#program-derived-account-pda) +## Poseidon hash -PDAs are special account addresses derived deterministically using optional seeds, a bump seed, and a program ID. +A cryptographic hash function optimized for zero-knowledge proof systems that works natively with finite field arithmetic. -They are off the Ed25519 curve, meaning they have no private key. The PDA itself, once derived, is 32 bytes, matching a regular public key. +The Poseidon hash is designed to minimize computational complexity in ZK circuits. ZK Compression uses Poseidon hashes to generate the account hashes stored as leaves in state trees. -## [**Prioritization fee**](https://solana.com/docs/references/terminology#prioritization-fee) +## [Prioritization fee](https://solana.com/docs/references/terminology#prioritization-fee) An additional fee user can specify in the compute budget [instruction](https://solana.com/docs/references/terminology#instruction) to prioritize their [transactions](https://solana.com/docs/references/terminology#transaction). The priority fee is derived from the compute unit limit and the compute unit price. The price per compute unit set by the user in micro-lamports (1 lamport = 1,000,000 micro-lamports), rounded up to the nearest lamport. -## Poseidon hash +## [Program](https://solana.com/docs/references/terminology#onchain-program) -A cryptographic hash function optimized for zero-knowledge proof systems that works natively with finite field arithmetic. +Programs run executable code similar to smart contracts on other blockchains with optimizations specific to Solana. -The Poseidon hash is designed to minimize computational complexity in ZK circuits. ZK Compression uses Poseidon hashes to generate the account hashes stored as leaves in state trees. +Solana programs key characteristics include: + +- Solana programs are stateless and do not store state internally. Separate accounts store state for programs to execute on, such as program, user or token data. This makes Solana's account model [different from Ethereum's](https://solana.com/news/evm-to-svm). +- Programs are typically written in Rust. +- Programs interpret the [instructions](https://solana.com/docs/references/terminology#instruction) sent inside of each [transaction](https://solana.com/docs/references/terminology#transaction) to read and modify accounts over which it has control, hence update state. + +## [Program derived addresses (PDA)](https://solana.com/docs/references/terminology#program-derived-account-pda) + +PDAs are special account addresses derived deterministically using optional seeds, a bump seed, and a program ID. + +They are off the Ed25519 curve, meaning they have no private key. The PDA itself, once derived, is 32 bytes, matching a regular public key. ## Proof verification The on-chain process of validating zero-knowledge proofs to confirm the correctness of compressed account state transitions. +## Registered Program PDA + +A PDA that grants a program access control to the Account Compression Program. Required as an account in transactions that modify compressed state. + ## Rent A fee paid in SOL for the creation of [Accounts](https://solana.com/docs/references/terminology#account) to store data on the blockchain, tied to account size. When accounts do not have enough balance to pay rent, they may be Garbage Collected. -## [**Rent exempt**](https://solana.com/docs/references/terminology#rent-exempt) +## [Rent exempt](https://solana.com/docs/references/terminology#rent-exempt) An account that maintains a minimum lamport balance proportional to the amount of data stored on the account. @@ -239,6 +374,14 @@ The minimum balance is paid by the creator and is calculated as follows: Minimum Rent Balance = 2 × 0.00000348 SOL/byte/year × Account Size (Bytes) ``` +## Rent sponsorship + + + + + + + ## Remote Procedure Calls (RPC) A bridge between users (or applications) and the blockchain to facilitate interactions and data retrieval. @@ -250,22 +393,28 @@ The [ZK Compression RPC API](https://www.zkcompression.com/developers/json-rpc-m here](/api-reference/json-rpc-methods/overview). -## [**Smart contract**](https://solana.com/docs/references/terminology#smart-contract) +## [Smart contract](https://solana.com/docs/references/terminology#smart-contract) Smart contracts on Solana are called programs with key characteristics and optimizations. -## Solana Account Model +## Solana account model The native framework to store and manage data on the Solana blockchain. -Solana's Account Model separates program logic from state to optimize for parallel and faster transactions. Separate accounts store state for programs to execute on, such as program, user or token data. This makes Solana's Account Model [different from Ethereum's](https://solana.com/news/evm-to-svm). +Solana's account model separates program logic from state to optimize for parallel and faster transactions. Separate accounts store state for programs to execute on, such as program, user or token data. This makes Solana's account model [different from Ethereum's](https://solana.com/news/evm-to-svm). -ZK Compression extends Solana's Account Model with Compressed Accounts. +ZK Compression extends Solana's account model with compressed accounts. -## [**Solana Program Library (SPL)**](https://solana.com/docs/references/terminology#solana-program-library-spl) +## [Solana Program Library (SPL)](https://solana.com/docs/references/terminology#solana-program-library-spl) A [library of programs](https://spl.solana.com/) on Solana such as spl-token that facilitates tasks such as creating and using tokens. +## SPL interface PDA + +A PDA owned by the Light Token Program's CPI authority that holds SPL tokens corresponding to compressed tokens and Light Token balances in circulation. Each SPL interface PDA is associated with a specific mint. + +> **Address**: `GXtd2izAiMJPwMEjfgTRH3d7k9mjn4Jq3JrWFv9gySYy` + ## State A snapshot representing the current status of all accounts and programs on Solana. @@ -274,6 +423,23 @@ The state is derived from the ledger by sequentially applying every transaction. State is kept in RAM by validators for transaction validation. +## State compression + +A process to lower the amount of data stored on chain using Merkle trees. + +The process of state compression involves the following steps: + +1. Millions of accounts are compressed into a 'fingerprint' - the Merkle tree root hash +2. This 'fingerprint' is stored in one Solana account +3. The account history is stored on the Solana ledger +4. The latest compressed data is fetched from an indexer +5. To verify the data, recompute the hashes and compare the final hash to the on chain root hash + + + Learn more [on generalized state compression + here](https://solana.com/developers/courses/state-compression/generalized-state-compression). + + ## State root The root hash of a Merkle tree that serves as a cryptographic fingerprint representing all compressed accounts in the tree. @@ -291,34 +457,26 @@ Two state tree versions with different proof mechanisms are currently supported: - **V1 state trees**: Always require the full 128-byte validity proof. With a depth of 26, a single V1 state tree stores approximately 67 million compressed accounts. - **V2 batched state trees**: Support `prove_by_index` optimization that verifies account existence with one byte instead of 128 bytes, optimizing compute unit consumption by up to 70%. -## State compression - -A process to lower the amount of data stored on chain using Merkle trees. - -The process of state compression involves the following steps: - -1. Millions of accounts are compressed into a 'fingerprint' - the Merkle tree root hash -2. This 'fingerprint' is stored in one Solana account -3. The account history is stored on the Solana ledger -4. The latest compressed data is fetched from an indexer -5. To verify the data, recompute the hashes and compare the final hash to the on chain root hash - - - Learn more [on generalized state compression - here](https://solana.com/developers/courses/state-compression/generalized-state-compression). - +| Instance | State Tree | Output Queue | CPI Context | +|:---------|:-----------|:-------------|:------------| +| V2 #1 | `bmt1LryLZUMmF7ZtqESaw7wifBXLfXHQYoE4GAmrahU` | `oq1na8gojfdUhsfCpyjNt6h4JaDWtHf1yQj4koBWfto` | `cpi15BoVPKgEPw5o8wc2T816GE7b378nMXnhH3Xbq4y` | +| V2 #2 | `bmt2UxoBxB9xWev4BkLvkGdapsz6sZGkzViPNph7VFi` | `oq2UkeMsJLfXt2QHzim242SUi3nvjJs8Pn7Eac9H9vg` | `cpi2yGapXUR3As5SjnHBAVvmApNiLsbeZpF3euWnW6B` | +| V2 #3 | `bmt3ccLd4bqSVZVeCJnH1F6C8jNygAhaDfxDwePyyGb` | `oq3AxjekBWgo64gpauB6QtuZNesuv19xrhaC1ZM1THQ` | `cpi3mbwMpSX8FAGMZVP85AwxqCaQMfEk9Em1v8QK9Rf` | +| V2 #4 | `bmt4d3p1a4YQgk9PeZv5s4DBUmbF5NxqYpk9HGjQsd8` | `oq4ypwvVGzCUMoiKKHWh4S1SgZJ9vCvKpcz6RT6A8dq` | `cpi4yyPDc4bCgHAnsenunGA8Y77j3XEDyjgfyCKgcoc` | +| V2 #5 | `bmt5yU97jC88YXTuSukYHa8Z5Bi2ZDUtmzfkDTA2mG2` | `oq5oh5ZR3yGomuQgFduNDzjtGvVWfDRGLuDVjv9a96P` | `cpi5ZTjdgYpZ1Xr7B1cMLLUE81oTtJbNNAyKary2nV6` | +| V1 | `smt2rJAFdyJJupwMKAqTNAJwvjhmiZ4JYGZmbVRw1Ho` | `nfq2hgS7NYemXsFaFUCe3EMXSDSfnZnAe27jC6aPP1X` | `cpi2cdhkH5roePvcudTgUL8ppEBfTay1desGh8G8QxK` | ## Token account A token account is an account type in Solana's Token Programs that stores information about an individual's ownership of a specific token (mint). Each token account is associated with a single mint and tracks details like the token balance and owner. -## [**Token mint**](https://solana.com/docs/references/terminology#token-mint) +## [Token mint](https://solana.com/docs/references/terminology#token-mint) A [mint account](https://solana.com/docs/tokens/basics/create-mint) is an account type in Solana's Token Programs that can produce (or 'mint') tokens. -Different tokens are distinguished by their unique token mint addresses. Token mints uniquely represents a token on the network and stores global metadata about the token, including the `mint_authority`, supply, and decimals. +Different tokens are distinguished by their unique token mint addresses. Token mints uniquely represent a token on the network and store global metadata about the token, including the `mint_authority`, supply, and decimals. SPL tokens can be compressed if the mint has an SPL interface PDA. -## [**Transaction**](https://solana.com/docs/references/terminology#transaction) +## [Transaction](https://solana.com/docs/references/terminology#transaction) One or more [instructions](https://solana.com/docs/references/terminology#instruction) signed by a [client](https://solana.com/docs/references/terminology#client) using one or more [keypairs](https://solana.com/docs/references/terminology#keypair) and executed atomically with only two possible outcomes: success or failure. @@ -332,7 +490,13 @@ The _validity proof_ is - constant 128 byte in size (other than Merkle proofs with varying proof size), fitting well in Solana's 1232 byte transaction limit - verified against the respective on chain fingerprint to ensure the provided data was previously emitted -- provided and generated by indexers that support the [ZK Compression RPC API](https://www.zkcompression.com/developers/json-rpc-methods) which extend Solana's [JSON RPC API](https://solana.com/docs/rpc) to interact with compressed accounts. . +- provided and generated by indexers that support the [ZK Compression RPC API](https://www.zkcompression.com/developers/json-rpc-methods) which extend Solana's [JSON RPC API](https://solana.com/docs/rpc) to interact with compressed accounts. + +## Wrap and Unwrap SPL, Token-2022, and Light Token Accounts + +**Wrap** moves tokens from an SPL or Token 2022 account into a Light Token associated token account. **Unwrap** moves tokens from a Light Token associated token account back to an SPL or Token 2022 account. Use wrap/unwrap to interact with applications that only support SPL or Token 2022. + +> [Docs](/light-token/cookbook/wrap-unwrap) | [Source Code](https://github.com/Lightprotocol/light-protocol/blob/0c4e2417b2df2d564721b89e18d1aad3665120e7/js/compressed-token/src/v3/actions/wrap.ts) ## Zero-knowledge proof (ZKP) @@ -343,12 +507,6 @@ ZK Compression uses a Groth16 SNARK zk proof - for its constant _validity_ proof size, to ensures the integrity of many compressed accounts, not for private or confidential transactions, and - to store data in zk friendly data structures. Applications on Solana can prove custom off chain computations over zk compressed state (native zk compute). -## ZK-SNARK - -Zero-Knowledge Succinct Non-Interactive Arguments of Knowledge, a cryptographic proof system that enables proving knowledge of information without revealing the information itself. - -zk-SNARKs produce constant-size proofs that can be verified efficiently without interaction between prover and verifier. ZK Compression uses the Groth16 zk-SNARK construction to generate validity proofs for compressed account state transitions. - ## ZK Compression A generalized compression framework to compress and verify arbitrary data with zero-knowledge proofs, to @@ -356,3 +514,12 @@ A generalized compression framework to compress and verify arbitrary data with z - enable the Compressed Account Model, the rent-free equivalent to Solana's Account Model, - solve Solana's state growth problem, and - build a foundation for native zk compute. + +The Light Token program uses ZK Compression under the hood for inactive token accounts (cold state). +A Light Token account, Light Token mint, or Light-PDA that has been compressed after extended inactivity. The account’s state is cryptographically preserved on the Solana ledger as a compressed account. On-chain lookups return is_initialized: false. Clients call create_load_instructions to reinstate the account. + +## ZK-SNARK + +Zero-Knowledge Succinct Non-Interactive Arguments of Knowledge. A cryptographic proof system where a prover demonstrates knowledge of information without revealing the information itself. + +zk-SNARKs produce constant-size proofs that can be verified efficiently without interaction between prover and verifier. ZK Compression uses the Groth16 zk-SNARK construction to generate validity proofs for compressed account state transitions. diff --git a/render_canvas.py b/render_canvas.py new file mode 100644 index 00000000..28e470ff --- /dev/null +++ b/render_canvas.py @@ -0,0 +1,345 @@ +#!/usr/bin/env python3 +""" +Centered-Column Logos with Symmetric Gradient Bands — Refined +Renders the composition spec to PNG using Pillow. +""" + +from PIL import Image, ImageDraw, ImageFont, ImageFilter +import math +import os + +# ── Canvas ────────────────────────────────────────────────────────────────── +W, H = 1054, 734 +BG = (0xF4, 0xF1, 0xEC) + +canvas = Image.new("RGBA", (W, H), (*BG, 255)) + +FONT_DIR = "/home/tilo/.claude/skills/canvas-design/canvas-fonts" + + +# ── Helpers ───────────────────────────────────────────────────────────────── + +def hex_to_rgba(h, opacity=1.0): + h = h.lstrip("#") + r, g, b = int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16) + return (r, g, b, int(min(1.0, max(0.0, opacity)) * 255)) + + +def lerp_color(c0, c1, t): + """Linear interpolate between two RGBA tuples.""" + return tuple(int(c0[i] + (c1[i] - c0[i]) * t) for i in range(4)) + + +def gradient_color_at(t, stops): + """Get interpolated RGBA at position t (0..1) along gradient stops.""" + if t <= stops[0]["pos"]: + return hex_to_rgba(stops[0]["color"], stops[0]["opacity"]) + if t >= stops[-1]["pos"]: + return hex_to_rgba(stops[-1]["color"], stops[-1]["opacity"]) + + for i in range(len(stops) - 1): + s0, s1 = stops[i], stops[i + 1] + if s0["pos"] <= t <= s1["pos"]: + lt = (t - s0["pos"]) / max(s1["pos"] - s0["pos"], 1e-9) + c0 = hex_to_rgba(s0["color"], s0["opacity"]) + c1 = hex_to_rgba(s1["color"], s1["opacity"]) + return lerp_color(c0, c1, lt) + + return hex_to_rgba(stops[-1]["color"], stops[-1]["opacity"]) + + +def draw_gradient_band(img, x, y, w, h, stops, angle_deg, global_opacity=0.92): + """Draw a horizontal linear gradient band with per-pixel precision.""" + band = Image.new("RGBA", (w, h), (0, 0, 0, 0)) + pixels = band.load() + + for px_x in range(w): + t = px_x / max(w - 1, 1) + if angle_deg == 180: + t = 1.0 - t + + r, g, b, a = gradient_color_at(t, stops) + a = int(a * global_opacity) + col = (r, g, b, a) + + for px_y in range(h): + pixels[px_x, px_y] = col + + # Subtle blur per spec + band = band.filter(ImageFilter.GaussianBlur(radius=0.5)) + img.paste(band, (x, y), band) + + +def draw_dashed_line(draw, x0, y0, x1, y1, color, dash_on=6, dash_off=10, width=1): + """Draw a dashed line segment.""" + dx = x1 - x0 + dy = y1 - y0 + length = math.sqrt(dx * dx + dy * dy) + if length < 1: + return + ux, uy = dx / length, dy / length + pos = 0.0 + drawing = True + while pos < length: + seg = dash_on if drawing else dash_off + seg = min(seg, length - pos) + if drawing: + sx = x0 + ux * pos + sy = y0 + uy * pos + ex = x0 + ux * (pos + seg) + ey = y0 + uy * (pos + seg) + draw.line([(sx, sy), (ex, ey)], fill=color, width=width) + pos += seg + drawing = not drawing + + +# ── Grid Overlay ──────────────────────────────────────────────────────────── + +def draw_grid(img): + draw = ImageDraw.Draw(img) + ml, mt, mr, mb = 26, 26, 26, 26 + rows, cols = 6, 6 + color = (0xBD, 0xB7, 0xAE, int(0.55 * 255)) + + left, right = ml, W - mr + top, bottom = mt, H - mb + iw = right - left + ih = bottom - top + + for i in range(rows + 1): + y = top + int(i * ih / rows) + draw_dashed_line(draw, left, y, right, y, color) + + for i in range(cols + 1): + x = left + int(i * iw / cols) + draw_dashed_line(draw, x, top, x, bottom, color) + + # Center guides (these land on grid lines for 6x6, but spec says show them) + cx, cy = W // 2, H // 2 + draw_dashed_line(draw, cx, top, cx, bottom, color) + draw_dashed_line(draw, left, cy, right, cy, color) + + +# ── Gradient Band Stops ───────────────────────────────────────────────────── + +band_stops = [ + {"pos": 0.0, "color": "#A9C4F2", "opacity": 0.95}, + {"pos": 0.55, "color": "#B6CDF4", "opacity": 0.85}, + {"pos": 0.78, "color": "#E58F86", "opacity": 0.85}, + {"pos": 1.0, "color": "#F4F1EC", "opacity": 0.0}, +] + + +def draw_bands(img): + draw_gradient_band(img, 96, 206, 408, 246, band_stops, angle_deg=0, global_opacity=0.92) + draw_gradient_band(img, 550, 206, 408, 246, band_stops, angle_deg=180, global_opacity=0.92) + + +# ── White Tiles ───────────────────────────────────────────────────────────── + +def draw_tiles(img): + draw = ImageDraw.Draw(img) + draw.rectangle([456, 92, 456 + 141, 92 + 141], fill=(255, 255, 255, 255)) + draw.rectangle([456, 442, 456 + 141, 442 + 141], fill=(255, 255, 255, 255)) + + +# ── Logo X Mark (refined) ────────────────────────────────────────────────── + +def draw_x_mark(img): + """Stylized X with sharp terminals — refined with anti-aliased rendering.""" + # Render at 4x then downscale for clean anti-aliasing + scale = 4 + mark_w, mark_h = 84, 92 + big_w, big_h = mark_w * scale, mark_h * scale + + big = Image.new("RGBA", (big_w, big_h), (0, 0, 0, 0)) + draw = ImageDraw.Draw(big) + + stroke_w = 14 * scale + hw = stroke_w / 2 + + # Diagonal 1: top-left to bottom-right + d_len = math.sqrt(big_w ** 2 + big_h ** 2) + ux, uy = big_w / d_len, big_h / d_len + px, py = -uy, ux + + x0, y0 = 0, 0 + x1, y1 = big_w, big_h + + draw.polygon([ + (x0 + px * hw, y0 + py * hw), + (x0 - px * hw, y0 - py * hw), + (x1 - px * hw, y1 - py * hw), + (x1 + px * hw, y1 + py * hw), + ], fill=(0x11, 0x11, 0x11, 255)) + + # Diagonal 2: top-right to bottom-left + x2, y2 = big_w, 0 + x3, y3 = 0, big_h + ux2, uy2 = -big_w / d_len, big_h / d_len + px2, py2 = -uy2, ux2 + + draw.polygon([ + (x2 + px2 * hw, y2 + py2 * hw), + (x2 - px2 * hw, y2 - py2 * hw), + (x3 - px2 * hw, y3 - py2 * hw), + (x3 + px2 * hw, y3 + py2 * hw), + ], fill=(0x11, 0x11, 0x11, 255)) + + # Downscale with high-quality resampling + mark = big.resize((mark_w, mark_h), Image.LANCZOS) + img.paste(mark, (486, 118), mark) + + +# ── Connector Group (refined) ────────────────────────────────────────────── + +def draw_connector(img): + """Center connector: white slot, twin red bars, gradient bridge.""" + # White slot + slot = Image.new("RGBA", (44, 206), (255, 255, 255, 255)) + img.paste(slot, (505, 234), slot) + + # Red bars — render at 2x for cleaner blur edges + def make_red_bar(): + scale = 2 + bw, bh = 18 * scale, 198 * scale + bar = Image.new("RGBA", (bw, bh), hex_to_rgba("#E08A83", 0.9)) + bar = bar.filter(ImageFilter.GaussianBlur(radius=1.0 * scale)) + # Apply 0.85 opacity + pixels = bar.load() + for x in range(bw): + for y in range(bh): + r, g, b, a = pixels[x, y] + pixels[x, y] = (r, g, b, int(a * 0.85)) + return bar.resize((18, 198), Image.LANCZOS) + + bar_l = make_red_bar() + bar_r = make_red_bar() + img.paste(bar_l, (492, 238), bar_l) + img.paste(bar_r, (544, 238), bar_r) + + # Horizontal bridge with gradient + bridge_w, bridge_h = 70, 58 + bridge_stops = [ + {"pos": 0.0, "color": "#E08A83", "opacity": 0.75}, + {"pos": 0.5, "color": "#B59AD0", "opacity": 0.85}, + {"pos": 1.0, "color": "#E08A83", "opacity": 0.75}, + ] + + bridge = Image.new("RGBA", (bridge_w, bridge_h), (0, 0, 0, 0)) + pixels = bridge.load() + for px_x in range(bridge_w): + t = px_x / max(bridge_w - 1, 1) + r, g, b, a = gradient_color_at(t, bridge_stops) + a = int(a * 0.9) # global opacity + for px_y in range(bridge_h): + pixels[px_x, px_y] = (r, g, b, a) + + bridge = bridge.filter(ImageFilter.GaussianBlur(radius=0.6)) + img.paste(bridge, (492, 310), bridge) + + +# ── Starburst Mark (refined — soft rounded spokes) ───────────────────────── + +def draw_starburst(img): + """Radial starburst with 13 rounded spokes, soft ends. Rendered at 4x.""" + scale = 4 + box_size = 64 + big_size = box_size * scale + cx = big_size // 2 + cy = big_size // 2 + + big = Image.new("RGBA", (big_size, big_size), (0, 0, 0, 0)) + draw = ImageDraw.Draw(big) + + color = hex_to_rgba("#C77456", 1.0) + num_spokes = 13 + outer_r = 28 * scale + inner_r = 9 * scale + spoke_half_w_base = 4.0 * scale + spoke_half_w_tip = 1.8 * scale + + # Central disk + draw.ellipse( + [cx - inner_r, cy - inner_r, cx + inner_r, cy + inner_r], + fill=color, + ) + + # Spokes as smooth tapered shapes + for i in range(num_spokes): + angle = (2 * math.pi * i) / num_spokes - math.pi / 2 + + cos_a = math.cos(angle) + sin_a = math.sin(angle) + perp_x = -sin_a + perp_y = cos_a + + # Base point (just inside the disk edge) + base_dist = inner_r * 0.65 + bx = cx + cos_a * base_dist + by = cy + sin_a * base_dist + + # Tip point + tx = cx + cos_a * outer_r + ty = cy + sin_a * outer_r + + # Mid point for curvature + mid_dist = (base_dist + outer_r) * 0.55 + mx = cx + cos_a * mid_dist + my = cy + sin_a * mid_dist + + # Draw spoke as a polygon with tapered width + # Base width -> mid width -> tip width + mid_half = spoke_half_w_base * 0.7 + + poly = [ + (bx + perp_x * spoke_half_w_base, by + perp_y * spoke_half_w_base), + (mx + perp_x * mid_half, my + perp_y * mid_half), + (tx + perp_x * spoke_half_w_tip, ty + perp_y * spoke_half_w_tip), + (tx - perp_x * spoke_half_w_tip, ty - perp_y * spoke_half_w_tip), + (mx - perp_x * mid_half, my - perp_y * mid_half), + (bx - perp_x * spoke_half_w_base, by - perp_y * spoke_half_w_base), + ] + draw.polygon(poly, fill=color) + + # Rounded tip: small circle at spoke end + tip_r = spoke_half_w_tip * 1.1 + draw.ellipse( + [tx - tip_r, ty - tip_r, tx + tip_r, ty + tip_r], + fill=color, + ) + + # Downscale for anti-aliased smoothness + mark = big.resize((box_size, box_size), Image.LANCZOS) + img.paste(mark, (495, 485), mark) + + +# ── Assemble (correct z-order) ────────────────────────────────────────────── + +# 1. Gradient bands (lowest) +draw_bands(canvas) + +# 2. Grid overlay (above bands, below tiles) +draw_grid(canvas) + +# 3. White tiles (above bands) +draw_tiles(canvas) + +# 4. Connector (sits between tiles, above bands) +draw_connector(canvas) + +# 5. Logo marks (topmost) +draw_x_mark(canvas) +draw_starburst(canvas) + +# ── Export ─────────────────────────────────────────────────────────────────── + +out_path = "/home/tilo/Workspace/docs-main-reorder/symmetric-convergence.png" + +# Flatten RGBA to RGB against the background +flat = Image.new("RGB", (W, H), BG) +flat.paste(canvas, (0, 0), canvas) +flat.save(out_path, "PNG", dpi=(144, 144)) + +print(f"Saved: {out_path}") +print(f"Size: {W}x{H}px") diff --git a/resources/addresses-and-urls.mdx b/resources/addresses-and-urls.mdx index c7f3308e..ad27ccf6 100644 --- a/resources/addresses-and-urls.mdx +++ b/resources/addresses-and-urls.mdx @@ -174,20 +174,19 @@ main(); # Next Steps -Start building with Compressed Tokens or PDAs diff --git a/resources/anchor-constraints.mdx b/resources/anchor-constraints.mdx new file mode 100644 index 00000000..cbb19cca --- /dev/null +++ b/resources/anchor-constraints.mdx @@ -0,0 +1,194 @@ +--- +title: "Anchor Constraints LightAccount" +description: "Syntax reference for #[light_account] constraints with sponsored rent-exemption." +--- + +- [`#[light_account(init)]`](#light_accountinit) creates a PDA +- [`#[light_account(init, token::...)]`](#light_accountinit-token) creates a token account via CPI +- [`#[light_account(init, associated_token::...)]`](#light_accountinit-associated_token) creates an ATA via CPI +- [`#[light_account(init, mint::...)]`](#light_accountinit-mint) creates a mint via CPI +- [Required accounts](#required-accounts) per account type + +Place `#[light_account]` below standard Anchor `#[account]` on the same field. +Anchor handles seeds, space, and payer; LightAccount handles rent-free creation. + +--- + +### `#[light_account(init)]` + +Creates a rent-free PDA. No additional parameters — uses Anchor `#[account]` seeds and space. + +**attribute** + +``` +#[light_account(init)] +``` + +```rust +#[account( // ← Anchor: seeds, space, payer + init, + payer = fee_payer, + space = 8 + ::INIT_SPACE, + seeds = [COUNTER_SEED, owner.key().as_ref()], + bump, +)] +#[light_account(init)] // ← Light: register for rent-free creation +pub counter: Account<'info, Counter>, +``` + +Examples: [Github](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-macros/counter) + +--- + +### `#[light_account(init, token::...)]` + +Creates a rent-free token account via CPI to the Light Token program. The account type is `UncheckedAccount` because Light Token program initializes it via CPI. + +**attribute** + +``` +#[light_account(init, + token::authority = , + token::mint = , + token::owner = , + token::bump = +)] +``` + +```rust +#[account( + mut, + seeds = [VAULT_SEED, mint.key().as_ref()], + bump, +)] +#[light_account(init, + token::authority = [VAULT_SEED, self.mint.key()], + token::mint = mint, + token::owner = vault_authority, + token::bump = params.vault_bump +)] +pub vault: UncheckedAccount<'info>, +``` + +Examples: [Github](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-macros/create-token-account) + +--- + +### `#[light_account(init, associated_token::...)]` + +Creates a rent-free associated token account via CPI. + +**attribute** + +``` +#[light_account(init, + associated_token::authority = , + associated_token::mint = , + associated_token::bump = +)] +``` + +```rust +#[account(mut)] +#[light_account(init, + associated_token::authority = associated_token_account_owner, + associated_token::mint = associated_token_account_mint, + associated_token::bump = params.associated_token_account_bump +)] +pub associated_token_account: UncheckedAccount<'info>, +``` + +Examples: [Github](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-macros/create-associated-token-account) + +--- + +### `#[light_account(init, mint::...)]` + +Creates a rent-free mint via CPI. + +**attribute (required)** + +``` +#[light_account(init, mint, + mint::signer = , + mint::authority = , + mint::decimals = , + mint::seeds = , +)] +``` + +**attribute (optional)** + +``` +mint::bump = +mint::freeze_authority = +mint::authority_seeds = +mint::name = // requires symbol + uri +mint::symbol = // requires name + uri +mint::uri = // requires name + symbol +mint::update_authority = // requires name, symbol, uri +mint::additional_metadata = // requires name, symbol, uri +``` + +```rust +#[account(mut)] +#[light_account(init, mint, + mint::signer = mint_signer, + mint::authority = fee_payer, + mint::decimals = 9, + mint::seeds = &[MINT_SIGNER_SEED, self.authority.to_account_info().key.as_ref()], +)] +pub mint: UncheckedAccount<'info>, +``` + + + +```rust +#[account(mut)] +#[light_account(init, mint, + mint::signer = mint_signer, + mint::authority = fee_payer, + mint::decimals = 9, + mint::seeds = &[MINT_SIGNER_SEED, self.authority.to_account_info().key.as_ref()], + mint::bump = params.mint_signer_bump, + mint::name = params.name.clone(), + mint::symbol = params.symbol.clone(), + mint::uri = params.uri.clone(), + mint::update_authority = authority, + mint::additional_metadata = params.additional_metadata.clone() +)] +pub mint: UncheckedAccount<'info>, +``` + + + +Examples: [Github](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-macros/create-mint) + +--- + +## Required accounts + +Add these to your `init` struct alongside the fields above. The `LightAccounts` derive macro appends additional protocol accounts to the instruction at runtime — you don't add those manually. + + + + +| Account | Description | +|:-|:-| +| `compression_config` | Per-program PDA. Stores rent sponsor address and compression settings. Initialize once via `InitializeRentFreeConfig`. | +| `pda_rent_sponsor` | Per-program PDA. Receives rent-exemption lamports when accounts compress. Must be mutable. | +| `system_program` | Solana System Program. Transfers lamports for rent-exemption. | + + + + +| Account | Description | +|:-|:-| +| `light_token_compressible_config` | Protocol PDA. Stores rent-config for Light Token accounts. | +| `light_token_rent_sponsor` | Protocol PDA. Holds the lamport pool that sponsors rent-exemption. Reclaims lamports when accounts compress. | +| `light_token_program` | Light Token program. CPI target for token, ATA, and mint creation. | +| `light_token_cpi_authority` | Signer PDA. Authorizes CPI calls from your program to the Light Token program. | +| `system_program` | Solana System Program. Transfers lamports for rent-exemption. | + + + \ No newline at end of file diff --git a/resources/cli-installation.mdx b/resources/cli-installation.mdx index b29b6b37..631a5d4b 100644 --- a/resources/cli-installation.mdx +++ b/resources/cli-installation.mdx @@ -1,6 +1,6 @@ --- -title: "CLI Installation & Commands" -description: "Steps to set up your local environment for ZK Compression development. CLI to interact with compressed accounts and compressed tokens on Solana." +title: "CLI installation & commands" +description: "Steps to set up your local environment for ZK Compression development. CLI to interact with compressed accounts and Light Tokens on Solana." keywords: ["light protocol cli", "zk compression cli"] --- @@ -24,13 +24,13 @@ The CLI will use this wallet as the default fee payer and mint authority. -### Install the ZK Compression CLI +### Install the CLI Ensure you have Node >= v20.9.0 installed on your machine. Windows users do not require WSL. -Run this single command to install the ZK Compression CLI. +Run this single command to install the CLI. ```bash npm i -g @lightprotocol/zk-compression-cli @@ -75,7 +75,7 @@ which light -### Set Up Your Environment +### Set up your environment By default, the CLI interacts with localnet. You can view the current config by running: @@ -149,7 +149,7 @@ solana address # Commands -### Create a compressed token mint +### Create a Light Token mint ```bash light create-mint @@ -170,7 +170,7 @@ FLAGS random keypair. ``` -### Mint compressed tokens to a Solana wallet +### Mint Light Tokens to a Solana wallet ```bash light mint-to --mint "YOUR_MINT_ADDRESS" --to "YOUR_WALLET_ADDRESS" --amount 4200000000 @@ -189,7 +189,7 @@ FLAGS --to= (required) Recipient address. ``` -### Transfer compressed tokens from one wallet to another +### Transfer Light Tokens from one wallet to another ```bash light transfer --mint "YOUR_MINT_ADDRESS" --to "RECIPIENT_WALLET_ADDRESS" --amount 4200000000 @@ -209,33 +209,33 @@ FLAGS ``` -### Assign native SOL to a compressed account +### Wrap SOL into compressed account ```bash -light compress-sol --amount 1000 --to "YOUR_WALLET_ADDRESS_BASE58" +light wrap-sol --amount 1000 --to "YOUR_WALLET_ADDRESS_BASE58" ``` ```bash USAGE - $ light compress-sol --to --amount + $ light wrap-sol --to --amount FLAGS - --amount= (required) Amount to compress in lamports. + --amount= (required) Amount to wrap in lamports. --to= (required) Specify the recipient address. ``` -### Decompress into native SOL +### Unwrap SOL from compressed account ```bash -light decompress-sol --amount 42 --to "YOUR_WALLET_ADDRESS_BASE58" +light unwrap-sol --amount 42 --to "YOUR_WALLET_ADDRESS_BASE58" ``` ```bash USAGE - $ light decompress-sol --to --amount + $ light unwrap-sol --to --amount FLAGS - --amount= (required) Amount to decompress in lamports. + --amount= (required) Amount to unwrap in lamports. --to= (required) Specify the recipient address. ``` @@ -243,7 +243,7 @@ FLAGS diff --git a/resources/sdks/client-development.mdx b/resources/sdks/client-development.mdx index a26c6ee7..820d8135 100644 --- a/resources/sdks/client-development.mdx +++ b/resources/sdks/client-development.mdx @@ -79,7 +79,7 @@ light-sdk = "0.16.0" title="Build your client with this guide." icon="chevron-right" color="#0066ff" - href="/client-library/client-guide" + href="/pda/compressed-pdas/guides/client-guide" horizontal > \ No newline at end of file diff --git a/resources/sdks/program-development.mdx b/resources/sdks/program-development.mdx index 7ae55b87..1b5c8b5d 100644 --- a/resources/sdks/program-development.mdx +++ b/resources/sdks/program-development.mdx @@ -50,14 +50,14 @@ Build your own program or view program examples. title="Program Guides" icon="chevron-right" color="#0066ff" - href="/compressed-pdas/guides" + href="/pda/compressed-pdas/guides" horizontal /> \ No newline at end of file diff --git a/scripts/copy-privy-snippets.sh b/scripts/copy-privy-snippets.sh index 3c368c54..0e91d602 100755 --- a/scripts/copy-privy-snippets.sh +++ b/scripts/copy-privy-snippets.sh @@ -1,21 +1,22 @@ #!/bin/bash -# Script to copy TypeScript code from Privy examples to docs/snippets/code-snippets/privy -# Wraps each file in typescript markdown code blocks +# Script to copy TypeScript code from Light Token Privy examples to docs snippets. +# Source: examples-light-token/privy/{nodejs,react} +# Output: snippets/code-snippets/privy/{operation}/{nodejs,react}.mdx -NODEJS_SRC="/home/tilo/Workspace/examples-zk-compression/privy/nodejs-privy-compressed/src" -REACT_SRC="/home/tilo/Workspace/examples-zk-compression/privy/react-privy-compressed/src/hooks" -SNIPPETS_DIR="/home/tilo/Workspace/docs/snippets/code-snippets/privy" +NODEJS_SRC="/home/tilo/Workspace/examples-light-token/privy/nodejs/src" +REACT_SRC="/home/tilo/Workspace/examples-light-token/privy/react/src/hooks" +SNIPPETS_DIR="/home/tilo/Workspace/docs-main-reorder/snippets/code-snippets/privy" # Operations to process -OPERATIONS=("transfer" "compress" "decompress" "balances" "transaction-history") +OPERATIONS=("transfer" "wrap" "unwrap" "balances" "transaction-history") -# Function to wrap TypeScript code in markdown +# Wrap TypeScript code in markdown code block, stripping "// --- main ---" runner section wrap_typescript() { local input_file="$1" local output_file="$2" echo '```typescript' > "$output_file" - cat "$input_file" >> "$output_file" + sed '/^\/\/ --- main ---$/,$d' "$input_file" >> "$output_file" echo '```' >> "$output_file" echo "Created: $output_file" } @@ -28,8 +29,8 @@ done # Process Node.js operations echo "Processing Node.js operations..." wrap_typescript "$NODEJS_SRC/transfer.ts" "$SNIPPETS_DIR/transfer/nodejs.mdx" -wrap_typescript "$NODEJS_SRC/compress.ts" "$SNIPPETS_DIR/compress/nodejs.mdx" -wrap_typescript "$NODEJS_SRC/decompress.ts" "$SNIPPETS_DIR/decompress/nodejs.mdx" +wrap_typescript "$NODEJS_SRC/wrap.ts" "$SNIPPETS_DIR/wrap/nodejs.mdx" +wrap_typescript "$NODEJS_SRC/unwrap.ts" "$SNIPPETS_DIR/unwrap/nodejs.mdx" wrap_typescript "$NODEJS_SRC/balances.ts" "$SNIPPETS_DIR/balances/nodejs.mdx" wrap_typescript "$NODEJS_SRC/get-transaction-history.ts" "$SNIPPETS_DIR/transaction-history/nodejs.mdx" @@ -37,11 +38,17 @@ wrap_typescript "$NODEJS_SRC/get-transaction-history.ts" "$SNIPPETS_DIR/transact echo "" echo "Processing React operations..." wrap_typescript "$REACT_SRC/useTransfer.ts" "$SNIPPETS_DIR/transfer/react.mdx" -wrap_typescript "$REACT_SRC/useCompress.ts" "$SNIPPETS_DIR/compress/react.mdx" -wrap_typescript "$REACT_SRC/useDecompress.ts" "$SNIPPETS_DIR/decompress/react.mdx" -wrap_typescript "$REACT_SRC/useCompressedBalances.ts" "$SNIPPETS_DIR/balances/react.mdx" +wrap_typescript "$REACT_SRC/useWrap.ts" "$SNIPPETS_DIR/wrap/react.mdx" +wrap_typescript "$REACT_SRC/useUnwrap.ts" "$SNIPPETS_DIR/unwrap/react.mdx" +wrap_typescript "$REACT_SRC/useLightTokenBalances.ts" "$SNIPPETS_DIR/balances/react.mdx" wrap_typescript "$REACT_SRC/useTransactionHistory.ts" "$SNIPPETS_DIR/transaction-history/react.mdx" +# Copy shared React helper +echo "" +echo "Processing shared helpers..." +mkdir -p "$SNIPPETS_DIR/helpers" +wrap_typescript "$REACT_SRC/signAndSendBatches.ts" "$SNIPPETS_DIR/helpers/sign-and-send-batches.mdx" + echo "" echo "Done! Created snippets in: $SNIPPETS_DIR" echo "" diff --git a/snippets/ai-prompts/anchor-program-template.mdx b/snippets/ai-prompts/anchor-program-template.mdx new file mode 100644 index 00000000..b4949b47 --- /dev/null +++ b/snippets/ai-prompts/anchor-program-template.mdx @@ -0,0 +1,57 @@ +```text +--- +description: {{OPERATION_DESCRIPTION}} +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## {{OPERATION_DESCRIPTION}} + +Context: +- Guide: https://zkcompression.com/{{PAGE_PATH}} +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: {{CRATES}} +{{EXTRA_REFS}} + +Key macros/APIs: {{KEY_MACROS}} + +### 1. Index project +- Grep `{{INDEX_GREP}}` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: existing program module, account structs, PDA seeds, token accounts, init instructions +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, migrate existing program to rent-free, add rent-free accounts to specific instructions) +- AskUserQuestion: which account types need to be rent-free? (PDAs, token accounts, ATAs, mints) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- Follow the guide's step order: {{STEP_ORDER}} +- Identify which existing structs need changes (CompressionInfo field, LightAccount derive, etc.) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add {{DEPS}}` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `{{BUILD_CMD}}` +- Bash `{{TEST_CMD}}` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/anchor-programs/defi-anchor.mdx b/snippets/ai-prompts/anchor-programs/defi-anchor.mdx new file mode 100644 index 00000000..834133b9 --- /dev/null +++ b/snippets/ai-prompts/anchor-programs/defi-anchor.mdx @@ -0,0 +1,115 @@ + +{`--- +description: Add rent-free accounts to an Anchor DeFi program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add rent-free accounts to an Anchor DeFi program + +Context: +- Guide: https://zkcompression.com/light-token/defi/programs +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-sdk (features: anchor, v2, cpi-context), light-sdk-macros, light-token (features: anchor), light-anchor-spl +- AMM reference: https://github.com/Lightprotocol/cp-swap-reference + +Key macros/APIs: #[light_program], LightAccount, LightAccounts, #[light_account(init)], CompressionInfo + +### 1. Index project +- Grep \`#\[program\]|anchor_lang|Account<|Accounts|InitSpace|seeds|init|payer\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: existing program module, account structs, PDA seeds, token accounts, init instructions +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, migrate existing program to rent-free, add rent-free accounts to specific instructions) +- AskUserQuestion: which account types need to be rent-free? (PDAs, token accounts, ATAs, mints) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- Follow the guide's step order: Dependencies → State Struct → Program Module → Accounts Struct → Instructions +- Identify which existing structs need changes (CompressionInfo field, LightAccount derive, etc.) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-sdk@0.19 --features anchor,v2,cpi-context\` and \`cargo add light-sdk-macros@0.19\` and \`cargo add light-token@0.4 --features anchor\` and \`cargo add light-anchor-spl@0.31\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`anchor build\` +- Bash \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Add rent-free accounts to an Anchor DeFi program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add rent-free accounts to an Anchor DeFi program + +Context: +- Guide: https://zkcompression.com/light-token/defi/programs +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-sdk (features: anchor, v2, cpi-context), light-sdk-macros, light-token (features: anchor), light-anchor-spl +- AMM reference: https://github.com/Lightprotocol/cp-swap-reference + +Key macros/APIs: #[light_program], LightAccount, LightAccounts, #[light_account(init)], CompressionInfo + +### 1. Index project +- Grep `#\[program\]|anchor_lang|Account<|Accounts|InitSpace|seeds|init|payer` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: existing program module, account structs, PDA seeds, token accounts, init instructions +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, migrate existing program to rent-free, add rent-free accounts to specific instructions) +- AskUserQuestion: which account types need to be rent-free? (PDAs, token accounts, ATAs, mints) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- Follow the guide's step order: Dependencies → State Struct → Program Module → Accounts Struct → Instructions +- Identify which existing structs need changes (CompressionInfo field, LightAccount derive, etc.) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-sdk@0.19 --features anchor,v2,cpi-context` and `cargo add light-sdk-macros@0.19` and `cargo add light-token@0.4 --features anchor` and `cargo add light-anchor-spl@0.31` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `anchor build` +- Bash `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/anchor-programs/defi-pinocchio.mdx b/snippets/ai-prompts/anchor-programs/defi-pinocchio.mdx new file mode 100644 index 00000000..298d309d --- /dev/null +++ b/snippets/ai-prompts/anchor-programs/defi-pinocchio.mdx @@ -0,0 +1,115 @@ + +{`--- +description: Add rent-free accounts to a Pinocchio DeFi program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add rent-free accounts to a Pinocchio DeFi program + +Context: +- Guide: https://zkcompression.com/light-token/defi/programs-pinocchio +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-account-pinocchio (features: token, std), light-token-pinocchio, pinocchio +- Swap reference: https://github.com/Lightprotocol/examples-light-token/tree/simplify-trait/pinocchio/swap + +Key macros/APIs: LightPinocchioAccount, LightProgramPinocchio, CreateTokenAccountCpi, derive_light_cpi_signer! + +### 1. Index project +- Grep \`pinocchio|entrypoint!|ProgramError|AccountInfo|process_instruction\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: existing program module, account structs, PDA seeds, token accounts, init instructions +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, migrate existing program to rent-free, add rent-free accounts to specific instructions) +- AskUserQuestion: which account types need to be rent-free? (PDAs, token accounts, ATAs, mints) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- Follow the guide's step order: Dependencies → State Struct → Program Enum → Entrypoint → Init Handler +- Identify which existing structs need changes (CompressionInfo field, LightPinocchioAccount derive, etc.) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-account-pinocchio@0.20 --features token,std\` and \`cargo add light-token-pinocchio@0.20\` and \`cargo add pinocchio@0.9\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo build-sbf\` +- Bash \`cargo test-sbf\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Add rent-free accounts to a Pinocchio DeFi program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add rent-free accounts to a Pinocchio DeFi program + +Context: +- Guide: https://zkcompression.com/light-token/defi/programs-pinocchio +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-account-pinocchio (features: token, std), light-token-pinocchio, pinocchio +- Swap reference: https://github.com/Lightprotocol/examples-light-token/tree/simplify-trait/pinocchio/swap + +Key macros/APIs: LightPinocchioAccount, LightProgramPinocchio, CreateTokenAccountCpi, derive_light_cpi_signer! + +### 1. Index project +- Grep `pinocchio|entrypoint!|ProgramError|AccountInfo|process_instruction` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: existing program module, account structs, PDA seeds, token accounts, init instructions +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, migrate existing program to rent-free, add rent-free accounts to specific instructions) +- AskUserQuestion: which account types need to be rent-free? (PDAs, token accounts, ATAs, mints) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- Follow the guide's step order: Dependencies → State Struct → Program Enum → Entrypoint → Init Handler +- Identify which existing structs need changes (CompressionInfo field, LightPinocchioAccount derive, etc.) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-account-pinocchio@0.20 --features token,std` and `cargo add light-token-pinocchio@0.20` and `cargo add pinocchio@0.9` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo build-sbf` +- Bash `cargo test-sbf` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/anchor-programs/light-pda.mdx b/snippets/ai-prompts/anchor-programs/light-pda.mdx new file mode 100644 index 00000000..45e528d3 --- /dev/null +++ b/snippets/ai-prompts/anchor-programs/light-pda.mdx @@ -0,0 +1,113 @@ + +{`--- +description: Add rent-free PDAs to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add rent-free PDAs to an Anchor program + +Context: +- Guide: https://zkcompression.com/pda/light-pda/overview +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-account (features: anchor), light-sdk (features: anchor, v2, cpi-context) +- Counter example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-macros/counter + +Key macros/APIs: #[light_program], LightAccount, LightAccounts, #[light_account(init)], CompressionInfo, CreateAccountsProof + +### 1. Index project +- Grep \`#\[program\]|anchor_lang|Account<|Accounts|InitSpace|seeds|init|payer\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: existing program module, account structs, PDA seeds, token accounts, init instructions +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, migrate existing program to rent-free, add rent-free accounts to specific instructions) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- Follow the guide's step order: Dependencies → State Struct → Program Module → Accounts Struct +- Identify which existing structs need changes (CompressionInfo field, LightAccount derive, etc.) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-account@0.20 --features anchor\` and \`cargo add light-sdk@0.20 --features anchor,v2,cpi-context\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`anchor build\` +- Bash \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Add rent-free PDAs to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add rent-free PDAs to an Anchor program + +Context: +- Guide: https://zkcompression.com/pda/light-pda/overview +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-account (features: anchor), light-sdk (features: anchor, v2, cpi-context) +- Counter example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-macros/counter + +Key macros/APIs: #[light_program], LightAccount, LightAccounts, #[light_account(init)], CompressionInfo, CreateAccountsProof + +### 1. Index project +- Grep `#\[program\]|anchor_lang|Account<|Accounts|InitSpace|seeds|init|payer` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: existing program module, account structs, PDA seeds, token accounts, init instructions +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, migrate existing program to rent-free, add rent-free accounts to specific instructions) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- Follow the guide's step order: Dependencies → State Struct → Program Module → Accounts Struct +- Identify which existing structs need changes (CompressionInfo field, LightAccount derive, etc.) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-account@0.20 --features anchor` and `cargo add light-sdk@0.20 --features anchor,v2,cpi-context` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `anchor build` +- Bash `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/cpi-program-template.mdx b/snippets/ai-prompts/cpi-program-template.mdx new file mode 100644 index 00000000..f9cf32cc --- /dev/null +++ b/snippets/ai-prompts/cpi-program-template.mdx @@ -0,0 +1,57 @@ +```text +--- +description: {{OPERATION_DESCRIPTION}} +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## {{OPERATION_DESCRIPTION}} + +Context: +- Guide: https://zkcompression.com/pda/compressed-pdas/guides/{{PAGE_SLUG}} +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-sdk (LightAccount, CpiAccounts, LightSystemProgramCpi, derive_light_cpi_signer!) +{{EXTRA_REFS}} + +Key SDK API: {{KEY_API}} + +### 1. Index project +- Grep `declare_id|#\[program\]|entrypoint!|Pubkey|AccountInfo{{EXTRA_GREP}}` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: program ID, existing instructions, account structs, framework (Anchor or native) +- Read Cargo.toml — note existing dependencies and Solana SDK version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both Anchor and Native Rust code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, add {{OP_SHORT}} to existing program, migrate from regular accounts) +- AskUserQuestion: Anchor or Native Rust framework? +- AskUserQuestion: does the program already have compressed account instructions, or is this the first one? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Dependencies → Constants → Account Struct → Instruction Data → {{OP_SPECIFIC_STEPS}} → Light System Program CPI +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps: Bash `cargo add light-sdk@0.16` (add `anchor_lang@0.31` for Anchor or `solana-program@2.2` + `borsh@0.10` for Native Rust) +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo build-sbf` or `anchor build` +- Bash `cargo test-sbf` or `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/cpi-programs/burn.mdx b/snippets/ai-prompts/cpi-programs/burn.mdx new file mode 100644 index 00000000..2ff0e795 --- /dev/null +++ b/snippets/ai-prompts/cpi-programs/burn.mdx @@ -0,0 +1,117 @@ + +{`--- +description: Build a program that permanently burns compressed accounts +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Build a program that permanently burns compressed accounts + +Context: +- Guide: https://zkcompression.com/pda/compressed-pdas/guides/how-to-burn-compressed-accounts +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-sdk (LightAccount, CpiAccounts, LightSystemProgramCpi, derive_light_cpi_signer!) +- Anchor example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor/burn +- Native Rust example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/native/programs/burn + +Key SDK API: LightAccount::new_burn() + +### 1. Index project +- Grep \`declare_id|#\[program\]|entrypoint!|Pubkey|AccountInfo|burn|destroy|permanent\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: program ID, existing instructions, account structs, framework (Anchor or native) +- Read Cargo.toml — note existing dependencies and Solana SDK version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both Anchor and Native Rust code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, add account burn to existing program, migrate from regular accounts) +- AskUserQuestion: Anchor or Native Rust framework? +- AskUserQuestion: does the program already have compressed account instructions, or is this the first one? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Dependencies → Constants → Account Struct → Instruction Data → Burn Compressed Account → Light System Program CPI +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps: Bash \`cargo add light-sdk@0.16\` (add \`anchor_lang@0.31\` for Anchor or \`solana-program@2.2\` + \`borsh@0.10\` for Native Rust) +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo build-sbf\` or \`anchor build\` +- Bash \`cargo test-sbf\` or \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Build a program that permanently burns compressed accounts +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Build a program that permanently burns compressed accounts + +Context: +- Guide: https://zkcompression.com/pda/compressed-pdas/guides/how-to-burn-compressed-accounts +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-sdk (LightAccount, CpiAccounts, LightSystemProgramCpi, derive_light_cpi_signer!) +- Anchor example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor/burn +- Native Rust example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/native/programs/burn + +Key SDK API: LightAccount::new_burn() + +### 1. Index project +- Grep `declare_id|#\[program\]|entrypoint!|Pubkey|AccountInfo|burn|destroy|permanent` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: program ID, existing instructions, account structs, framework (Anchor or native) +- Read Cargo.toml — note existing dependencies and Solana SDK version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both Anchor and Native Rust code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, add account burn to existing program, migrate from regular accounts) +- AskUserQuestion: Anchor or Native Rust framework? +- AskUserQuestion: does the program already have compressed account instructions, or is this the first one? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Dependencies → Constants → Account Struct → Instruction Data → Burn Compressed Account → Light System Program CPI +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps: Bash `cargo add light-sdk@0.16` (add `anchor_lang@0.31` for Anchor or `solana-program@2.2` + `borsh@0.10` for Native Rust) +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo build-sbf` or `anchor build` +- Bash `cargo test-sbf` or `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/cpi-programs/client-guide.mdx b/snippets/ai-prompts/cpi-programs/client-guide.mdx new file mode 100644 index 00000000..efd49d33 --- /dev/null +++ b/snippets/ai-prompts/cpi-programs/client-guide.mdx @@ -0,0 +1,127 @@ + +{`--- +description: Write client code to interact with compressed PDA programs +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Write client code to interact with compressed PDA programs + +Context: +- Guide: https://zkcompression.com/pda/compressed-pdas/guides/client-guide +- Skills and resources index: https://zkcompression.com/skill.md +- TS packages: @lightprotocol/stateless.js, @lightprotocol/compressed-token, @solana/web3.js +- Rust crates: light-client, light-sdk +- TS example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor/create/tests +- Rust example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor/create/programs/create/tests +- All operations: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor + +Key APIs: +- TS: createRpc(), deriveAddressSeedV2(), deriveAddressV2(), getValidityProofV0(), PackedAccounts, SystemAccountMetaConfig, getStateTreeInfos(), selectStateTreeInfo() +- Rust: LightClientConfig, LightClient, derive_address(), get_validity_proof(), PackedAccounts, SystemAccountMetaConfig, get_random_state_tree_info() + +### 1. Index project +- Grep \`@lightprotocol|stateless\.js|createRpc|deriveAddress|getValidityProof|PackedAccounts|light_client|light_sdk|derive_address|get_validity_proof\` across src/ +- Glob \`**/*.ts\` and \`**/*.rs\` for project structure +- Identify: RPC setup, existing compressed account operations, program ID references +- Check package.json or Cargo.toml for existing light-* dependencies +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both TypeScript and Rust code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: TypeScript or Rust? +- AskUserQuestion: what is the goal? (new client from scratch, add client calls to existing project, migrate from regular accounts) +- AskUserQuestion: which operations? (create only, full CRUD, specific subset like create + update) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Setup → Address derivation → Validity proof → PackedAccounts → Instruction data → Build instruction → Send transaction +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- For TypeScript: Bash \`npm install @lightprotocol/stateless.js @lightprotocol/compressed-token @solana/web3.js\` +- For Rust: Bash \`cargo add light-client@0.16 light-sdk@0.16\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- TypeScript: Bash \`tsc --noEmit\` + run existing test suite if present +- Rust: Bash \`cargo check\` + \`cargo test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Write client code to interact with compressed PDA programs +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Write client code to interact with compressed PDA programs + +Context: +- Guide: https://zkcompression.com/pda/compressed-pdas/guides/client-guide +- Skills and resources index: https://zkcompression.com/skill.md +- TS packages: @lightprotocol/stateless.js, @lightprotocol/compressed-token, @solana/web3.js +- Rust crates: light-client, light-sdk +- TS example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor/create/tests +- Rust example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor/create/programs/create/tests +- All operations: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor + +Key APIs: +- TS: createRpc(), deriveAddressSeedV2(), deriveAddressV2(), getValidityProofV0(), PackedAccounts, SystemAccountMetaConfig, getStateTreeInfos(), selectStateTreeInfo() +- Rust: LightClientConfig, LightClient, derive_address(), get_validity_proof(), PackedAccounts, SystemAccountMetaConfig, get_random_state_tree_info() + +### 1. Index project +- Grep `@lightprotocol|stateless\.js|createRpc|deriveAddress|getValidityProof|PackedAccounts|light_client|light_sdk|derive_address|get_validity_proof` across src/ +- Glob `**/*.ts` and `**/*.rs` for project structure +- Identify: RPC setup, existing compressed account operations, program ID references +- Check package.json or Cargo.toml for existing light-* dependencies +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both TypeScript and Rust code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: TypeScript or Rust? +- AskUserQuestion: what is the goal? (new client from scratch, add client calls to existing project, migrate from regular accounts) +- AskUserQuestion: which operations? (create only, full CRUD, specific subset like create + update) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Setup → Address derivation → Validity proof → PackedAccounts → Instruction data → Build instruction → Send transaction +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- For TypeScript: Bash `npm install @lightprotocol/stateless.js @lightprotocol/compressed-token @solana/web3.js` +- For Rust: Bash `cargo add light-client@0.16 light-sdk@0.16` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- TypeScript: Bash `tsc --noEmit` + run existing test suite if present +- Rust: Bash `cargo check` + `cargo test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/cpi-programs/close.mdx b/snippets/ai-prompts/cpi-programs/close.mdx new file mode 100644 index 00000000..e7833fac --- /dev/null +++ b/snippets/ai-prompts/cpi-programs/close.mdx @@ -0,0 +1,117 @@ + +{`--- +description: Build a program that closes compressed accounts +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Build a program that closes compressed accounts + +Context: +- Guide: https://zkcompression.com/pda/compressed-pdas/guides/how-to-close-compressed-accounts +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-sdk (LightAccount, CpiAccounts, LightSystemProgramCpi, derive_light_cpi_signer!) +- Anchor example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor/close +- Native Rust example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/native/programs/close + +Key SDK API: LightAccount::new_close() + +### 1. Index project +- Grep \`declare_id|#\[program\]|entrypoint!|Pubkey|AccountInfo|close|delete|remove\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: program ID, existing instructions, account structs, framework (Anchor or native) +- Read Cargo.toml — note existing dependencies and Solana SDK version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both Anchor and Native Rust code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, add account close to existing program, migrate from regular accounts) +- AskUserQuestion: Anchor or Native Rust framework? +- AskUserQuestion: does the program already have compressed account instructions, or is this the first one? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Dependencies → Constants → Account Struct → Instruction Data → Close Compressed Account → Light System Program CPI +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps: Bash \`cargo add light-sdk@0.16\` (add \`anchor_lang@0.31\` for Anchor or \`solana-program@2.2\` + \`borsh@0.10\` for Native Rust) +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo build-sbf\` or \`anchor build\` +- Bash \`cargo test-sbf\` or \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Build a program that closes compressed accounts +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Build a program that closes compressed accounts + +Context: +- Guide: https://zkcompression.com/pda/compressed-pdas/guides/how-to-close-compressed-accounts +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-sdk (LightAccount, CpiAccounts, LightSystemProgramCpi, derive_light_cpi_signer!) +- Anchor example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor/close +- Native Rust example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/native/programs/close + +Key SDK API: LightAccount::new_close() + +### 1. Index project +- Grep `declare_id|#\[program\]|entrypoint!|Pubkey|AccountInfo|close|delete|remove` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: program ID, existing instructions, account structs, framework (Anchor or native) +- Read Cargo.toml — note existing dependencies and Solana SDK version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both Anchor and Native Rust code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, add account close to existing program, migrate from regular accounts) +- AskUserQuestion: Anchor or Native Rust framework? +- AskUserQuestion: does the program already have compressed account instructions, or is this the first one? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Dependencies → Constants → Account Struct → Instruction Data → Close Compressed Account → Light System Program CPI +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps: Bash `cargo add light-sdk@0.16` (add `anchor_lang@0.31` for Anchor or `solana-program@2.2` + `borsh@0.10` for Native Rust) +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo build-sbf` or `anchor build` +- Bash `cargo test-sbf` or `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/cpi-programs/create.mdx b/snippets/ai-prompts/cpi-programs/create.mdx new file mode 100644 index 00000000..1dfb4799 --- /dev/null +++ b/snippets/ai-prompts/cpi-programs/create.mdx @@ -0,0 +1,117 @@ + +{`--- +description: Build a program that creates compressed accounts with addresses +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Build a program that creates compressed accounts with addresses + +Context: +- Guide: https://zkcompression.com/pda/compressed-pdas/guides/how-to-create-compressed-accounts +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-sdk (LightAccount, CpiAccounts, LightSystemProgramCpi, derive_light_cpi_signer!) +- Anchor example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor/create +- Native Rust example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/native/programs/create + +Key SDK API: LightAccount::new_init(), derive_address() + +### 1. Index project +- Grep \`declare_id|#\[program\]|entrypoint!|Pubkey|AccountInfo|seeds|init|payer|space\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: program ID, existing instructions, account structs, framework (Anchor or native) +- Read Cargo.toml — note existing dependencies and Solana SDK version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both Anchor and Native Rust code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, add account creation to existing program, migrate from regular accounts) +- AskUserQuestion: Anchor or Native Rust framework? +- AskUserQuestion: does the program already have compressed account instructions, or is this the first one? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Dependencies → Constants → Account Struct → Instruction Data → Derive Address → Address Tree Check → Initialize Account → Light System Program CPI +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps: Bash \`cargo add light-sdk@0.16\` (add \`anchor_lang@0.31\` for Anchor or \`solana-program@2.2\` + \`borsh@0.10\` for Native Rust) +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo build-sbf\` or \`anchor build\` +- Bash \`cargo test-sbf\` or \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Build a program that creates compressed accounts with addresses +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Build a program that creates compressed accounts with addresses + +Context: +- Guide: https://zkcompression.com/pda/compressed-pdas/guides/how-to-create-compressed-accounts +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-sdk (LightAccount, CpiAccounts, LightSystemProgramCpi, derive_light_cpi_signer!) +- Anchor example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor/create +- Native Rust example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/native/programs/create + +Key SDK API: LightAccount::new_init(), derive_address() + +### 1. Index project +- Grep `declare_id|#\[program\]|entrypoint!|Pubkey|AccountInfo|seeds|init|payer|space` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: program ID, existing instructions, account structs, framework (Anchor or native) +- Read Cargo.toml — note existing dependencies and Solana SDK version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both Anchor and Native Rust code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, add account creation to existing program, migrate from regular accounts) +- AskUserQuestion: Anchor or Native Rust framework? +- AskUserQuestion: does the program already have compressed account instructions, or is this the first one? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Dependencies → Constants → Account Struct → Instruction Data → Derive Address → Address Tree Check → Initialize Account → Light System Program CPI +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps: Bash `cargo add light-sdk@0.16` (add `anchor_lang@0.31` for Anchor or `solana-program@2.2` + `borsh@0.10` for Native Rust) +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo build-sbf` or `anchor build` +- Bash `cargo test-sbf` or `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/cpi-programs/reinitialize.mdx b/snippets/ai-prompts/cpi-programs/reinitialize.mdx new file mode 100644 index 00000000..0f608254 --- /dev/null +++ b/snippets/ai-prompts/cpi-programs/reinitialize.mdx @@ -0,0 +1,117 @@ + +{`--- +description: Build a program that reinitializes closed compressed accounts +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Build a program that reinitializes closed compressed accounts + +Context: +- Guide: https://zkcompression.com/pda/compressed-pdas/guides/how-to-reinitialize-compressed-accounts +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-sdk (LightAccount, CpiAccounts, LightSystemProgramCpi, derive_light_cpi_signer!) +- Anchor example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor/reinit +- Native Rust example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/native/programs/reinit + +Key SDK API: LightAccount::new_empty() + +### 1. Index project +- Grep \`declare_id|#\[program\]|entrypoint!|Pubkey|AccountInfo|reinit|empty|reset\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: program ID, existing instructions, account structs, framework (Anchor or native) +- Read Cargo.toml — note existing dependencies and Solana SDK version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both Anchor and Native Rust code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, add account reinitialization to existing program, migrate from regular accounts) +- AskUserQuestion: Anchor or Native Rust framework? +- AskUserQuestion: does the program already have compressed account instructions, or is this the first one? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Dependencies → Constants → Account Struct → Instruction Data → Reinitialize Closed Account → Light System Program CPI +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps: Bash \`cargo add light-sdk@0.16\` (add \`anchor_lang@0.31\` for Anchor or \`solana-program@2.2\` + \`borsh@0.10\` for Native Rust) +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo build-sbf\` or \`anchor build\` +- Bash \`cargo test-sbf\` or \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Build a program that reinitializes closed compressed accounts +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Build a program that reinitializes closed compressed accounts + +Context: +- Guide: https://zkcompression.com/pda/compressed-pdas/guides/how-to-reinitialize-compressed-accounts +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-sdk (LightAccount, CpiAccounts, LightSystemProgramCpi, derive_light_cpi_signer!) +- Anchor example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor/reinit +- Native Rust example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/native/programs/reinit + +Key SDK API: LightAccount::new_empty() + +### 1. Index project +- Grep `declare_id|#\[program\]|entrypoint!|Pubkey|AccountInfo|reinit|empty|reset` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: program ID, existing instructions, account structs, framework (Anchor or native) +- Read Cargo.toml — note existing dependencies and Solana SDK version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both Anchor and Native Rust code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, add account reinitialization to existing program, migrate from regular accounts) +- AskUserQuestion: Anchor or Native Rust framework? +- AskUserQuestion: does the program already have compressed account instructions, or is this the first one? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Dependencies → Constants → Account Struct → Instruction Data → Reinitialize Closed Account → Light System Program CPI +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps: Bash `cargo add light-sdk@0.16` (add `anchor_lang@0.31` for Anchor or `solana-program@2.2` + `borsh@0.10` for Native Rust) +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo build-sbf` or `anchor build` +- Bash `cargo test-sbf` or `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/cpi-programs/update.mdx b/snippets/ai-prompts/cpi-programs/update.mdx new file mode 100644 index 00000000..cbf94761 --- /dev/null +++ b/snippets/ai-prompts/cpi-programs/update.mdx @@ -0,0 +1,117 @@ + +{`--- +description: Build a program that updates compressed accounts +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Build a program that updates compressed accounts + +Context: +- Guide: https://zkcompression.com/pda/compressed-pdas/guides/how-to-update-compressed-accounts +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-sdk (LightAccount, CpiAccounts, LightSystemProgramCpi, derive_light_cpi_signer!) +- Anchor example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor/update +- Native Rust example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/native/programs/update + +Key SDK API: LightAccount::new_mut() + +### 1. Index project +- Grep \`declare_id|#\[program\]|entrypoint!|Pubkey|AccountInfo|mut|update|modify\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: program ID, existing instructions, account structs, framework (Anchor or native) +- Read Cargo.toml — note existing dependencies and Solana SDK version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both Anchor and Native Rust code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, add account update to existing program, migrate from regular accounts) +- AskUserQuestion: Anchor or Native Rust framework? +- AskUserQuestion: does the program already have compressed account instructions, or is this the first one? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Dependencies → Constants → Account Struct → Instruction Data → Update Compressed Account → Light System Program CPI +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps: Bash \`cargo add light-sdk@0.16\` (add \`anchor_lang@0.31\` for Anchor or \`solana-program@2.2\` + \`borsh@0.10\` for Native Rust) +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo build-sbf\` or \`anchor build\` +- Bash \`cargo test-sbf\` or \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Build a program that updates compressed accounts +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Build a program that updates compressed accounts + +Context: +- Guide: https://zkcompression.com/pda/compressed-pdas/guides/how-to-update-compressed-accounts +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-sdk (LightAccount, CpiAccounts, LightSystemProgramCpi, derive_light_cpi_signer!) +- Anchor example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor/update +- Native Rust example: https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/native/programs/update + +Key SDK API: LightAccount::new_mut() + +### 1. Index project +- Grep `declare_id|#\[program\]|entrypoint!|Pubkey|AccountInfo|mut|update|modify` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: program ID, existing instructions, account structs, framework (Anchor or native) +- Read Cargo.toml — note existing dependencies and Solana SDK version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both Anchor and Native Rust code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, add account update to existing program, migrate from regular accounts) +- AskUserQuestion: Anchor or Native Rust framework? +- AskUserQuestion: does the program already have compressed account instructions, or is this the first one? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Dependencies → Constants → Account Struct → Instruction Data → Update Compressed Account → Light System Program CPI +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps: Bash `cargo add light-sdk@0.16` (add `anchor_lang@0.31` for Anchor or `solana-program@2.2` + `borsh@0.10` for Native Rust) +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo build-sbf` or `anchor build` +- Bash `cargo test-sbf` or `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/defi/routers.mdx b/snippets/ai-prompts/defi/routers.mdx new file mode 100644 index 00000000..40ef313f --- /dev/null +++ b/snippets/ai-prompts/defi/routers.mdx @@ -0,0 +1,123 @@ + +{`--- +description: Integrate rent-free AMM markets into a router or aggregator +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Integrate rent-free AMM markets into a router or aggregator + +Context: +- Guide: https://zkcompression.com/light-token/defi/routers +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-client (features: v2) — provides AccountInterface, LightProgramInterface, create_load_instructions +- AMM reference: https://github.com/Lightprotocol/cp-swap-reference +- Streaming guides: https://zkcompression.com/light-token/toolkits/for-streaming-tokens + +Key APIs: create_load_instructions(), LightProgramInterface trait, get_account_interface(), get_multiple_account_interfaces(), is_cold() + +### 1. Index project +- Grep \`LightProgramInterface|create_load_instructions|AccountInterface|is_cold|get_account_interface|swap|amm|router|aggregator\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: existing routing/quoting logic, account caching, swap instruction building, streaming setup +- Read Cargo.toml — note existing dependencies and light-client version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add cold market support to existing router, build new router with rent-free market support, integrate a specific AMM SDK) +- AskUserQuestion: does the project already stream account updates, or does it fetch at swap time? +- AskUserQuestion: does the project use Jito bundles for multi-transaction swaps? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- Follow the guide's progression: Cold Account Cache → Detecting Cold Accounts → Building Swap Transactions with Load Instructions +- If streaming: add account + transaction subscriptions for the Light Token Program +- If fetch-at-swap-time: add get_multiple_account_interfaces + is_cold() check before building swap tx +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-client@0.19 --features v2\` +- Add AMM SDK dependency per the approved plan +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo check\` +- Bash \`cargo test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Integrate rent-free AMM markets into a router or aggregator +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Integrate rent-free AMM markets into a router or aggregator + +Context: +- Guide: https://zkcompression.com/light-token/defi/routers +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-client (features: v2) — provides AccountInterface, LightProgramInterface, create_load_instructions +- AMM reference: https://github.com/Lightprotocol/cp-swap-reference +- Streaming guides: https://zkcompression.com/light-token/toolkits/for-streaming-tokens + +Key APIs: create_load_instructions(), LightProgramInterface trait, get_account_interface(), get_multiple_account_interfaces(), is_cold() + +### 1. Index project +- Grep `LightProgramInterface|create_load_instructions|AccountInterface|is_cold|get_account_interface|swap|amm|router|aggregator` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: existing routing/quoting logic, account caching, swap instruction building, streaming setup +- Read Cargo.toml — note existing dependencies and light-client version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add cold market support to existing router, build new router with rent-free market support, integrate a specific AMM SDK) +- AskUserQuestion: does the project already stream account updates, or does it fetch at swap time? +- AskUserQuestion: does the project use Jito bundles for multi-transaction swaps? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- Follow the guide's progression: Cold Account Cache → Detecting Cold Accounts → Building Swap Transactions with Load Instructions +- If streaming: add account + transaction subscriptions for the Light Token Program +- If fetch-at-swap-time: add get_multiple_account_interfaces + is_cold() check before building swap tx +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-client@0.19 --features v2` +- Add AMM SDK dependency per the approved plan +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo check` +- Bash `cargo test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/privy-nodejs-compressed.mdx b/snippets/ai-prompts/privy-nodejs-compressed.mdx index 4f8df269..aaf85387 100644 --- a/snippets/ai-prompts/privy-nodejs-compressed.mdx +++ b/snippets/ai-prompts/privy-nodejs-compressed.mdx @@ -1,3 +1,81 @@ + +{`--- +argument-hint: +description: Add compressed token support to Privy Node.js app +allowed-tools: [Bash, Read, Glob, Grep, Task, mcp__deepwiki, mcp__zkcompression] +--- + +## Task: Add compressed token support to Privy Node.js app + +References: +- Privy Docs: https://docs.privy.io/recipes/solana/send-spl-tokens +- Privy Node Examples: + - SPL: https://github.com/privy-io/examples/tree/main/privy-node-starter + - Compressed: https://github.com/Lightprotocol/examples-zk-compression/tree/main/privy/nodejs-privy-compressed +- SPL vs Compressed comparison: https://github.com/Lightprotocol/examples-zk-compression/blob/main/privy/COMPARISON.md +- Compressed Token Guide for Privy Node.js: https://zkcompression.com/compressed-tokens/for-privy + +MCP: +* deepwiki https://mcp.deepwiki.com/mcp +* ZK Compression https://www.zkcompression.com/mcp + +## Workflow + +- This plan must execute without user intervention +- All questions have been resolved in planning phase +- If blocked, find alternative approach - do not stop +- Keep working until ALL todos are complete +- Use Task tool with subagents for parallel research or when stuck +- Use subagents with Read, Glob, Grep, and Deepwiki permissions when stuck +- Always assign Tasks to subagents and tell the user + +## DeepWiki fallback + +\`\`\` +mcp__deepwiki__read_wiki_structure("Lightprotocol/light-protocol"), +mcp__deepwiki__read_wiki_contents("Lightprotocol/light-protocol"), +mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") +\`\`\` + +## Quick Reference + +| Operation | SPL | Compressed | +| -------------- | ------------------------------ | ---------------------------------------------- | +| Transfer | transferChecked() | transfer() | +| Compress SPL to recipient | N/A | compress() | +| Decompress to SPL | N/A | decompress() | +| Get Balance | getAccount() | getCompressedTokenAccountsByOwner() | +| Tx History | getSignaturesForAddress() | getCompressionSignaturesForOwner() | + +### Phase 1: Index project + +\`\`\`bash +grep -r "createTransferInstruction\|getAssociatedTokenAddress\|@solana/spl-token" src/ +\`\`\` + +### Phase 2: Add dependencies + +\`\`\`bash +npm install @lightprotocol/stateless.js @lightprotocol/compressed-token +\`\`\` + +### Phase 3: Implement operations + +See Code Reference below all signed with Privy SDK. + +1. **Setup**: Connect to ZK Compression RPC (Helius, Triton) https://github.com/Lightprotocol/examples-zk-compression/blob/main/privy/nodejs-privy-compressed/src/index.ts +2. **Get Balance**: Fetch SPL and compressed token balances https://github.com/Lightprotocol/examples-zk-compression/blob/main/privy/nodejs-privy-compressed/src/compressed/balances.ts +3. **Transfer**: Send compressed tokens to another recipient, signed with Privy SDK https://github.com/Lightprotocol/examples-zk-compression/blob/main/privy/nodejs-privy-compressed/src/compressed/transfer.ts +4. **Compress**: Convert SPL to compressed tokens and send to a recipient in one instruction https://github.com/Lightprotocol/examples-zk-compression/blob/main/privy/nodejs-privy-compressed/src/compressed/compress.ts +5. **Decompress**: Convert compressed tokens back to SPL tokens for offramps https://github.com/Lightprotocol/examples-zk-compression/blob/main/privy/nodejs-privy-compressed/src/compressed/decompress.ts +6. **Tx History**: Fetch compressed token transaction history for an owner + +### Phase 4: Test + +Run the implemented functions. On failure, debug and retry. Assign always to subagents with Tasktool +`} + + ~~~~text --- argument-hint: @@ -74,4 +152,4 @@ See Code Reference below all signed with Privy SDK. Run the implemented functions. On failure, debug and retry. Assign always to subagents with Tasktool -~~~~ \ No newline at end of file +~~~~ diff --git a/snippets/ai-prompts/privy-react-compressed.mdx b/snippets/ai-prompts/privy-react-compressed.mdx index fc34cec7..edf3eabb 100644 --- a/snippets/ai-prompts/privy-react-compressed.mdx +++ b/snippets/ai-prompts/privy-react-compressed.mdx @@ -1,3 +1,81 @@ + +{`--- +argument-hint: +description: Add compressed token support to Privy React app +allowed-tools: [Bash, Read, Glob, Grep, Task, mcp__deepwiki, mcp__zkcompression] +--- + +## Task: Add compressed token support to Privy React app + +References: +- Privy Docs: https://docs.privy.io/recipes/solana/send-spl-tokens +- Privy React Examples: + - SPL: https://github.com/privy-io/examples/tree/main/privy-react-starter + - Compressed: https://github.com/Lightprotocol/examples-zk-compression/tree/main/privy/react-privy-compressed +- SPL vs Compressed comparison: https://github.com/Lightprotocol/examples-zk-compression/blob/main/privy/COMPARISON.md +- Compressed Token Guide for Privy React: https://zkcompression.com/compressed-tokens/for-privy + +MCP: +* deepwiki https://mcp.deepwiki.com/mcp +* ZK Compression https://www.zkcompression.com/mcp + +## Workflow + +- This plan must execute without user intervention +- All questions have been resolved in planning phase +- If blocked, find alternative approach - do not stop +- Keep working until ALL todos are complete +- Use Task tool with subagents for parallel research or when stuck +- Use subagents with Read, Glob, Grep, and Deepwiki permissions when stuck +- Always assign Tasks to subagents and tell the user + +## DeepWiki fallback + +\`\`\` +mcp__deepwiki__read_wiki_structure("Lightprotocol/light-protocol"), +mcp__deepwiki__read_wiki_contents("Lightprotocol/light-protocol"), +mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") +\`\`\` + +## Quick Reference + +| Operation | SPL | Compressed | +| -------------- | ------------------------------ | ---------------------------------------------- | +| Transfer | transferChecked() | transfer() | +| Compress SPL to recipient | N/A | compress() | +| Decompress to SPL | N/A | decompress() | +| Get Balance | getAccount() | getCompressedTokenAccountsByOwner() | +| Tx History | getSignaturesForAddress() | getCompressionSignaturesForOwner() | + +### Phase 1: Index project + +\`\`\`bash +grep -r "createTransferInstruction\|getAssociatedTokenAddress\|@solana/spl-token" src/ +\`\`\` + +### Phase 2: Add dependencies + +\`\`\`bash +npm install @lightprotocol/stateless.js @lightprotocol/compressed-token +\`\`\` + +### Phase 3: Implement operations + +See Code Reference below all signed with Privy SDK. + +1. **Setup**: Connect to ZK Compression RPC (Helius, Triton) https://github.com/Lightprotocol/examples-zk-compression/blob/main/privy/react-privy-compressed/src/config/rpc.ts +2. **Get Balance**: Fetch SPL and compressed token balances https://github.com/Lightprotocol/examples-zk-compression/blob/main/privy/react-privy-compressed/src/hooks/useCompressedBalances.ts +3. **Transfer**: Send compressed tokens to another recipient, signed with Privy SDK https://github.com/Lightprotocol/examples-zk-compression/blob/main/privy/react-privy-compressed/src/hooks/useTransfer.ts +4. **Compress**: Convert SPL to compressed tokens and send to a recipient in one instruction https://github.com/Lightprotocol/examples-zk-compression/blob/main/privy/react-privy-compressed/src/hooks/useCompress.ts +5. **Decompress**: Convert compressed tokens back to SPL tokens for offramps https://github.com/Lightprotocol/examples-zk-compression/blob/main/privy/react-privy-compressed/src/hooks/useDecompress.ts +6. **Tx History**: Fetch compressed token transaction history for an owner + +### Phase 4: Test + +Run the implemented functions. On failure, debug and retry. Assign always to subagents with Tasktool +`} + + ~~~~text --- argument-hint: diff --git a/snippets/ai-prompts/program-cookbook/approve-revoke.mdx b/snippets/ai-prompts/program-cookbook/approve-revoke.mdx new file mode 100644 index 00000000..d9b6f668 --- /dev/null +++ b/snippets/ai-prompts/program-cookbook/approve-revoke.mdx @@ -0,0 +1,115 @@ + +{`--- +description: Add approve and revoke CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add approve and revoke CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/approve-revoke +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (ApproveCpi, RevokeCpi) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/approve + +Key CPI structs: \`light_token::instruction::ApproveCpi\`, \`light_token::instruction::RevokeCpi\` + +### 1. Index project +- Grep \`declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|approve|revoke|delegate\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: program ID, existing instructions, account structs, delegate accounts +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both Approve and Revoke CPI code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add approve/revoke to existing program, new program from scratch, migrate from SPL approve/revoke) +- AskUserQuestion: should the owner be an external signer or a PDA? (determines invoke vs invoke_signed) +- AskUserQuestion: do you need both approve and revoke, or just one? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Build ApproveCpi/RevokeCpi structs → call .invoke() or .invoke_signed() +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token anchor-lang@0.31\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`anchor build\` +- Bash \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Add approve and revoke CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add approve and revoke CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/approve-revoke +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (ApproveCpi, RevokeCpi) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/approve + +Key CPI structs: `light_token::instruction::ApproveCpi`, `light_token::instruction::RevokeCpi` + +### 1. Index project +- Grep `declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|approve|revoke|delegate` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: program ID, existing instructions, account structs, delegate accounts +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both Approve and Revoke CPI code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add approve/revoke to existing program, new program from scratch, migrate from SPL approve/revoke) +- AskUserQuestion: should the owner be an external signer or a PDA? (determines invoke vs invoke_signed) +- AskUserQuestion: do you need both approve and revoke, or just one? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Build ApproveCpi/RevokeCpi structs → call .invoke() or .invoke_signed() +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token anchor-lang@0.31` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `anchor build` +- Bash `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/program-cookbook/burn.mdx b/snippets/ai-prompts/program-cookbook/burn.mdx new file mode 100644 index 00000000..83277207 --- /dev/null +++ b/snippets/ai-prompts/program-cookbook/burn.mdx @@ -0,0 +1,113 @@ + +{`--- +description: Add burn CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add burn CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/burn +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (BurnCpi) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/burn + +Key CPI struct: \`light_token::instruction::BurnCpi\` + +### 1. Index project +- Grep \`declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|burn|destroy|supply\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: program ID, existing instructions, account structs, token accounts +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the Program tab CPI code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add burn to existing program, new program from scratch, migrate from SPL burn) +- AskUserQuestion: should the authority be an external signer or a PDA? (determines invoke vs invoke_signed) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Build BurnCpi struct → call .invoke() or .invoke_signed() +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token anchor-lang@0.31\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`anchor build\` +- Bash \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Add burn CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add burn CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/burn +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (BurnCpi) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/burn + +Key CPI struct: `light_token::instruction::BurnCpi` + +### 1. Index project +- Grep `declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|burn|destroy|supply` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: program ID, existing instructions, account structs, token accounts +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the Program tab CPI code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add burn to existing program, new program from scratch, migrate from SPL burn) +- AskUserQuestion: should the authority be an external signer or a PDA? (determines invoke vs invoke_signed) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Build BurnCpi struct → call .invoke() or .invoke_signed() +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token anchor-lang@0.31` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `anchor build` +- Bash `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/program-cookbook/close-token-account.mdx b/snippets/ai-prompts/program-cookbook/close-token-account.mdx new file mode 100644 index 00000000..fe54be99 --- /dev/null +++ b/snippets/ai-prompts/program-cookbook/close-token-account.mdx @@ -0,0 +1,113 @@ + +{`--- +description: Add close-account CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add close-account CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/close-token-account +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (CloseAccountCpi) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/close + +Key CPI struct: \`light_token::instruction::CloseAccountCpi\` + +### 1. Index project +- Grep \`declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|close|destination|rent\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: program ID, existing instructions, account structs, token accounts +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the Program tab CPI code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add close-account to existing program, new program from scratch, migrate from SPL close_account) +- AskUserQuestion: should the owner be an external signer or a PDA? (determines invoke vs invoke_signed) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Build CloseAccountCpi struct → call .invoke() or .invoke_signed() +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token anchor-lang@0.31\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`anchor build\` +- Bash \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Add close-account CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add close-account CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/close-token-account +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (CloseAccountCpi) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/close + +Key CPI struct: `light_token::instruction::CloseAccountCpi` + +### 1. Index project +- Grep `declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|close|destination|rent` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: program ID, existing instructions, account structs, token accounts +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the Program tab CPI code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add close-account to existing program, new program from scratch, migrate from SPL close_account) +- AskUserQuestion: should the owner be an external signer or a PDA? (determines invoke vs invoke_signed) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Build CloseAccountCpi struct → call .invoke() or .invoke_signed() +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token anchor-lang@0.31` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `anchor build` +- Bash `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/program-cookbook/create-ata-cpi.mdx b/snippets/ai-prompts/program-cookbook/create-ata-cpi.mdx new file mode 100644 index 00000000..17df7a8e --- /dev/null +++ b/snippets/ai-prompts/program-cookbook/create-ata-cpi.mdx @@ -0,0 +1,113 @@ + +{`--- +description: Add create-ATA CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add create-ATA CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-ata +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (CreateAssociatedAccountCpi) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/create-associated-token-account + +Key CPI struct: \`light_token::instruction::CreateAssociatedAccountCpi\` + +### 1. Index project +- Grep \`declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|ata|associated|owner|mint\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: program ID, existing instructions, account structs, ATA derivation +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the CPI tab under Program: ATA creation with .rent_free() chain +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add create-ATA to existing program, new program from scratch, migrate from SPL create_associated_token_account) +- AskUserQuestion: should the payer be an external signer or a PDA? (determines invoke vs invoke_signed) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Build CreateAssociatedAccountCpi → .rent_free() → .invoke() or .invoke_signed() +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token anchor-lang@0.31\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`anchor build\` +- Bash \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Add create-ATA CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add create-ATA CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-ata +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (CreateAssociatedAccountCpi) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/create-associated-token-account + +Key CPI struct: `light_token::instruction::CreateAssociatedAccountCpi` + +### 1. Index project +- Grep `declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|ata|associated|owner|mint` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: program ID, existing instructions, account structs, ATA derivation +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the CPI tab under Program: ATA creation with .rent_free() chain +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add create-ATA to existing program, new program from scratch, migrate from SPL create_associated_token_account) +- AskUserQuestion: should the payer be an external signer or a PDA? (determines invoke vs invoke_signed) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Build CreateAssociatedAccountCpi → .rent_free() → .invoke() or .invoke_signed() +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token anchor-lang@0.31` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `anchor build` +- Bash `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/program-cookbook/create-ata-macros.mdx b/snippets/ai-prompts/program-cookbook/create-ata-macros.mdx new file mode 100644 index 00000000..397584fd --- /dev/null +++ b/snippets/ai-prompts/program-cookbook/create-ata-macros.mdx @@ -0,0 +1,111 @@ + +{`--- +description: Create a rent-free ATA with Anchor macros +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Create a rent-free ATA with Anchor macros + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-ata +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-sdk, light-sdk-macros, light-compressible, anchor-lang +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-macros/create-associated-token-account + +Key macros: \`#[light_program]\`, \`LightAccounts\`, \`#[light_account(init, associated_token::...)]\` + +### 1. Index project +- Grep \`#\[program\]|anchor_lang|Account<|Accounts|seeds|init|payer|ata|associated\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: existing program module, account structs, ATA patterns +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the Anchor Macros tab under Program +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, add rent-free ATA to existing program, migrate from SPL create_associated_token_account) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- Follow the guide's step order: Dependencies → Program Module (#[light_program]) → Accounts Struct (#[light_account(init, associated_token::...)]) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-sdk@0.18 --features anchor,v2,cpi-context\` and \`cargo add light-sdk-macros@0.18 light-compressible@0.1 anchor-lang@0.31\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`anchor build\` +- Bash \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Create a rent-free ATA with Anchor macros +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Create a rent-free ATA with Anchor macros + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-ata +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-sdk, light-sdk-macros, light-compressible, anchor-lang +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-macros/create-associated-token-account + +Key macros: `#[light_program]`, `LightAccounts`, `#[light_account(init, associated_token::...)]` + +### 1. Index project +- Grep `#\[program\]|anchor_lang|Account<|Accounts|seeds|init|payer|ata|associated` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: existing program module, account structs, ATA patterns +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the Anchor Macros tab under Program +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, add rent-free ATA to existing program, migrate from SPL create_associated_token_account) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- Follow the guide's step order: Dependencies → Program Module (#[light_program]) → Accounts Struct (#[light_account(init, associated_token::...)]) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-sdk@0.18 --features anchor,v2,cpi-context` and `cargo add light-sdk-macros@0.18 light-compressible@0.1 anchor-lang@0.31` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `anchor build` +- Bash `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/program-cookbook/create-mint-cpi.mdx b/snippets/ai-prompts/program-cookbook/create-mint-cpi.mdx new file mode 100644 index 00000000..1ebefe3e --- /dev/null +++ b/snippets/ai-prompts/program-cookbook/create-mint-cpi.mdx @@ -0,0 +1,115 @@ + +{`--- +description: Add create-mint CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add create-mint CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-mint +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (CreateMintCpi, CreateMintParams, SystemAccountInfos) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/create-mint + +Key CPI struct: \`light_token::instruction::CreateMintCpi\` + +### 1. Index project +- Grep \`declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|mint|decimals|authority|metadata\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: program ID, existing instructions, account structs, mint seeds +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the CPI tab under Program: token metadata config, mint params, system accounts, invoke patterns +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add create-mint to existing program, new program from scratch, migrate from SPL create_mint) +- AskUserQuestion: should the mint seed be an external keypair or a PDA? (determines invoke vs invoke_signed) +- AskUserQuestion: do you need token metadata (name, symbol, uri)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Configure Token Metadata → Configure Mint Params → System Accounts → Build CPI and invoke +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token anchor-lang@0.31\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`anchor build\` +- Bash \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Add create-mint CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add create-mint CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-mint +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (CreateMintCpi, CreateMintParams, SystemAccountInfos) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/create-mint + +Key CPI struct: `light_token::instruction::CreateMintCpi` + +### 1. Index project +- Grep `declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|mint|decimals|authority|metadata` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: program ID, existing instructions, account structs, mint seeds +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the CPI tab under Program: token metadata config, mint params, system accounts, invoke patterns +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add create-mint to existing program, new program from scratch, migrate from SPL create_mint) +- AskUserQuestion: should the mint seed be an external keypair or a PDA? (determines invoke vs invoke_signed) +- AskUserQuestion: do you need token metadata (name, symbol, uri)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Configure Token Metadata → Configure Mint Params → System Accounts → Build CPI and invoke +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token anchor-lang@0.31` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `anchor build` +- Bash `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/program-cookbook/create-mint-macros.mdx b/snippets/ai-prompts/program-cookbook/create-mint-macros.mdx new file mode 100644 index 00000000..f871b97d --- /dev/null +++ b/snippets/ai-prompts/program-cookbook/create-mint-macros.mdx @@ -0,0 +1,113 @@ + +{`--- +description: Create a rent-free mint with Anchor macros +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Create a rent-free mint with Anchor macros + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-mint +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-sdk, light-sdk-macros, light-compressible, anchor-lang +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-macros/create-mint + +Key macros: \`#[light_program]\`, \`LightAccounts\`, \`#[light_account(init, mint::...)]\` + +### 1. Index project +- Grep \`#\[program\]|anchor_lang|Account<|Accounts|seeds|init|payer|mint\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: existing program module, account structs, mint patterns, PDA seeds +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the Anchor Macros tab under Program +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, add rent-free mint to existing program, migrate from SPL create_mint) +- AskUserQuestion: do you need token metadata (name, symbol, uri)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- Follow the guide's step order: Dependencies → Program Module (#[light_program]) → Accounts Struct (#[light_account(init, mint::...)]) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-sdk@0.18 --features anchor,v2,cpi-context\` and \`cargo add light-sdk-macros@0.18 light-compressible@0.1 anchor-lang@0.31\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`anchor build\` +- Bash \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Create a rent-free mint with Anchor macros +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Create a rent-free mint with Anchor macros + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-mint +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-sdk, light-sdk-macros, light-compressible, anchor-lang +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-macros/create-mint + +Key macros: `#[light_program]`, `LightAccounts`, `#[light_account(init, mint::...)]` + +### 1. Index project +- Grep `#\[program\]|anchor_lang|Account<|Accounts|seeds|init|payer|mint` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: existing program module, account structs, mint patterns, PDA seeds +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the Anchor Macros tab under Program +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, add rent-free mint to existing program, migrate from SPL create_mint) +- AskUserQuestion: do you need token metadata (name, symbol, uri)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- Follow the guide's step order: Dependencies → Program Module (#[light_program]) → Accounts Struct (#[light_account(init, mint::...)]) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-sdk@0.18 --features anchor,v2,cpi-context` and `cargo add light-sdk-macros@0.18 light-compressible@0.1 anchor-lang@0.31` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `anchor build` +- Bash `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/program-cookbook/create-token-account-cpi.mdx b/snippets/ai-prompts/program-cookbook/create-token-account-cpi.mdx new file mode 100644 index 00000000..f64adde1 --- /dev/null +++ b/snippets/ai-prompts/program-cookbook/create-token-account-cpi.mdx @@ -0,0 +1,113 @@ + +{`--- +description: Add create-token-account CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add create-token-account CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-token-account +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (CreateTokenAccountCpi) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/create-token-account + +Key CPI struct: \`light_token::instruction::CreateTokenAccountCpi\` + +### 1. Index project +- Grep \`declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|token_account|vault|owner|mint\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: program ID, existing instructions, account structs, vault/token account patterns +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the CPI tab under Program: token account creation with .rent_free() chain +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add create-token-account to existing program, new program from scratch, migrate from SPL token account init) +- AskUserQuestion: should the payer be an external signer or a PDA? (determines invoke vs invoke_signed) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Build CreateTokenAccountCpi → .rent_free() → .invoke() or .invoke_signed() +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token anchor-lang@0.31\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`anchor build\` +- Bash \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Add create-token-account CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add create-token-account CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-token-account +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (CreateTokenAccountCpi) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/create-token-account + +Key CPI struct: `light_token::instruction::CreateTokenAccountCpi` + +### 1. Index project +- Grep `declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|token_account|vault|owner|mint` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: program ID, existing instructions, account structs, vault/token account patterns +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the CPI tab under Program: token account creation with .rent_free() chain +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add create-token-account to existing program, new program from scratch, migrate from SPL token account init) +- AskUserQuestion: should the payer be an external signer or a PDA? (determines invoke vs invoke_signed) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Build CreateTokenAccountCpi → .rent_free() → .invoke() or .invoke_signed() +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token anchor-lang@0.31` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `anchor build` +- Bash `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/program-cookbook/create-token-account-macros.mdx b/snippets/ai-prompts/program-cookbook/create-token-account-macros.mdx new file mode 100644 index 00000000..bbf57fa6 --- /dev/null +++ b/snippets/ai-prompts/program-cookbook/create-token-account-macros.mdx @@ -0,0 +1,111 @@ + +{`--- +description: Create a rent-free token account with Anchor macros +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Create a rent-free token account with Anchor macros + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-token-account +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-sdk, light-sdk-macros, light-compressible, anchor-lang +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-macros/create-token-account + +Key macros: \`#[light_program]\`, \`LightAccounts\`, \`#[light_account(init, token::...)]\` + +### 1. Index project +- Grep \`#\[program\]|anchor_lang|Account<|Accounts|seeds|init|payer|vault|token_account\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: existing program module, account structs, vault/token account patterns +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the Anchor Macros tab under Program +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, add rent-free token account to existing program, migrate from SPL token account init) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- Follow the guide's step order: Dependencies → Program Module (#[light_program]) → Accounts Struct (#[light_account(init, token::...)]) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-sdk@0.18 --features anchor,v2,cpi-context\` and \`cargo add light-sdk-macros@0.18 light-compressible@0.1 anchor-lang@0.31\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`anchor build\` +- Bash \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Create a rent-free token account with Anchor macros +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Create a rent-free token account with Anchor macros + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-token-account +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-sdk, light-sdk-macros, light-compressible, anchor-lang +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-macros/create-token-account + +Key macros: `#[light_program]`, `LightAccounts`, `#[light_account(init, token::...)]` + +### 1. Index project +- Grep `#\[program\]|anchor_lang|Account<|Accounts|seeds|init|payer|vault|token_account` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: existing program module, account structs, vault/token account patterns +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the Anchor Macros tab under Program +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new program from scratch, add rent-free token account to existing program, migrate from SPL token account init) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- Follow the guide's step order: Dependencies → Program Module (#[light_program]) → Accounts Struct (#[light_account(init, token::...)]) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-sdk@0.18 --features anchor,v2,cpi-context` and `cargo add light-sdk-macros@0.18 light-compressible@0.1 anchor-lang@0.31` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `anchor build` +- Bash `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/program-cookbook/freeze-thaw.mdx b/snippets/ai-prompts/program-cookbook/freeze-thaw.mdx new file mode 100644 index 00000000..3aed6dc3 --- /dev/null +++ b/snippets/ai-prompts/program-cookbook/freeze-thaw.mdx @@ -0,0 +1,115 @@ + +{`--- +description: Add freeze and thaw CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add freeze and thaw CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/freeze-thaw +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (FreezeCpi, ThawCpi) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/freeze + +Key CPI structs: \`light_token::instruction::FreezeCpi\`, \`light_token::instruction::ThawCpi\` + +### 1. Index project +- Grep \`declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|freeze|thaw|authority\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: program ID, existing instructions, account structs, freeze authority +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both Freeze and Thaw CPI code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add freeze/thaw to existing program, new program from scratch, migrate from SPL freeze/thaw) +- AskUserQuestion: should the freeze authority be an external signer or a PDA? (determines invoke vs invoke_signed) +- AskUserQuestion: do you need both freeze and thaw, or just one? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Build FreezeCpi/ThawCpi structs → call .invoke() or .invoke_signed() +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token anchor-lang@0.31\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`anchor build\` +- Bash \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Add freeze and thaw CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add freeze and thaw CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/freeze-thaw +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (FreezeCpi, ThawCpi) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/freeze + +Key CPI structs: `light_token::instruction::FreezeCpi`, `light_token::instruction::ThawCpi` + +### 1. Index project +- Grep `declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|freeze|thaw|authority` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: program ID, existing instructions, account structs, freeze authority +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both Freeze and Thaw CPI code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add freeze/thaw to existing program, new program from scratch, migrate from SPL freeze/thaw) +- AskUserQuestion: should the freeze authority be an external signer or a PDA? (determines invoke vs invoke_signed) +- AskUserQuestion: do you need both freeze and thaw, or just one? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Build FreezeCpi/ThawCpi structs → call .invoke() or .invoke_signed() +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token anchor-lang@0.31` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `anchor build` +- Bash `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/program-cookbook/mint-to.mdx b/snippets/ai-prompts/program-cookbook/mint-to.mdx new file mode 100644 index 00000000..71091488 --- /dev/null +++ b/snippets/ai-prompts/program-cookbook/mint-to.mdx @@ -0,0 +1,113 @@ + +{`--- +description: Add mint-to CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add mint-to CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/mint-to +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (MintToCpi) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/mint-to + +Key CPI struct: \`light_token::instruction::MintToCpi\` + +### 1. Index project +- Grep \`declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|mint|supply|amount\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: program ID, existing instructions, account structs, mint accounts +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the Program tab CPI code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add mint-to to existing program, new program from scratch, migrate from SPL mint_to) +- AskUserQuestion: should the authority be an external signer or a PDA? (determines invoke vs invoke_signed) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Build MintToCpi struct → call .invoke() or .invoke_signed() +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token anchor-lang@0.31\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`anchor build\` +- Bash \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Add mint-to CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add mint-to CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/mint-to +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (MintToCpi) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/mint-to + +Key CPI struct: `light_token::instruction::MintToCpi` + +### 1. Index project +- Grep `declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|mint|supply|amount` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: program ID, existing instructions, account structs, mint accounts +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the Program tab CPI code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add mint-to to existing program, new program from scratch, migrate from SPL mint_to) +- AskUserQuestion: should the authority be an external signer or a PDA? (determines invoke vs invoke_signed) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Build MintToCpi struct → call .invoke() or .invoke_signed() +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token anchor-lang@0.31` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `anchor build` +- Bash `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/program-cookbook/transfer-checked.mdx b/snippets/ai-prompts/program-cookbook/transfer-checked.mdx new file mode 100644 index 00000000..abc63102 --- /dev/null +++ b/snippets/ai-prompts/program-cookbook/transfer-checked.mdx @@ -0,0 +1,113 @@ + +{`--- +description: Add transfer-checked CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add transfer-checked CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/transfer-checked +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (TransferCheckedCpi) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/transfer-checked + +Key CPI struct: \`light_token::instruction::TransferCheckedCpi\` + +### 1. Index project +- Grep \`declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|transfer|decimals|amount\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: program ID, existing instructions, account structs, token accounts +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the Program tab CPI code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add transfer-checked to existing program, new program from scratch, migrate from SPL transfer_checked) +- AskUserQuestion: should the authority be an external signer or a PDA? (determines invoke vs invoke_signed) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Build TransferCheckedCpi struct → call .invoke() or .invoke_signed() +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token anchor-lang@0.31\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`anchor build\` +- Bash \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Add transfer-checked CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add transfer-checked CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/transfer-checked +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (TransferCheckedCpi) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/transfer-checked + +Key CPI struct: `light_token::instruction::TransferCheckedCpi` + +### 1. Index project +- Grep `declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|transfer|decimals|amount` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: program ID, existing instructions, account structs, token accounts +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the Program tab CPI code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add transfer-checked to existing program, new program from scratch, migrate from SPL transfer_checked) +- AskUserQuestion: should the authority be an external signer or a PDA? (determines invoke vs invoke_signed) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Build TransferCheckedCpi struct → call .invoke() or .invoke_signed() +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token anchor-lang@0.31` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `anchor build` +- Bash `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/program-cookbook/transfer-interface.mdx b/snippets/ai-prompts/program-cookbook/transfer-interface.mdx new file mode 100644 index 00000000..d286834e --- /dev/null +++ b/snippets/ai-prompts/program-cookbook/transfer-interface.mdx @@ -0,0 +1,115 @@ + +{`--- +description: Add transfer-interface CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add transfer-interface CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/transfer-interface +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (TransferInterfaceCpi) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/transfer-interface + +Key CPI struct: \`light_token::instruction::TransferInterfaceCpi\` + +### 1. Index project +- Grep \`declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|transfer|decimals|interface\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: program ID, existing instructions, account structs, token accounts +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the Program tab CPI code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add transfer-interface to existing program, new program from scratch, migrate from SPL transfer) +- AskUserQuestion: should the authority be an external signer or a PDA? (determines invoke vs invoke_signed) +- AskUserQuestion: which token types will be transferred? (SPL, Token 2022, Light Token, or all via interface) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Build TransferInterfaceCpi → call .invoke() or .invoke_signed() +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token anchor-lang@0.31\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`anchor build\` +- Bash \`anchor test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Add transfer-interface CPI to an Anchor program +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add transfer-interface CPI to an Anchor program + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/transfer-interface +- Skills and resources index: https://zkcompression.com/skill.md +- Crate: light-token (TransferInterfaceCpi) +- Example: https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/basic-instructions/transfer-interface + +Key CPI struct: `light_token::instruction::TransferInterfaceCpi` + +### 1. Index project +- Grep `declare_id|#\[program\]|anchor_lang|Account<|Pubkey|invoke|transfer|decimals|interface` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: program ID, existing instructions, account structs, token accounts +- Read Cargo.toml — note existing dependencies and framework version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — review the Program tab CPI code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (add transfer-interface to existing program, new program from scratch, migrate from SPL transfer) +- AskUserQuestion: should the authority be an external signer or a PDA? (determines invoke vs invoke_signed) +- AskUserQuestion: which token types will be transferred? (SPL, Token 2022, Light Token, or all via interface) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's step order: Build TransferInterfaceCpi → call .invoke() or .invoke_signed() +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token anchor-lang@0.31` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `anchor build` +- Bash `anchor test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/rust-cookbook/approve-revoke.mdx b/snippets/ai-prompts/rust-cookbook/approve-revoke.mdx new file mode 100644 index 00000000..7319e751 --- /dev/null +++ b/snippets/ai-prompts/rust-cookbook/approve-revoke.mdx @@ -0,0 +1,113 @@ + +{`--- +description: Approve and revoke token delegates +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Approve and revoke token delegates + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/approve-revoke +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +SPL equivalent: spl_token::instruction::approve / revoke → Light Token: Approve / Revoke + +### 1. Index project +- Grep \`light_token::|light_token_client::|solana_sdk|Keypair|async|Approve|Revoke|delegate\` across src/ +- Glob \`**/*.rs\` for project structure +- Identify: RPC setup, existing token ops, entry point for delegation +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have delegation operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token-client light-token light-client --features light-client/v2\` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo check\` +- Bash \`cargo test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Approve and revoke token delegates +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Approve and revoke token delegates + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/approve-revoke +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +SPL equivalent: spl_token::instruction::approve / revoke → Light Token: Approve / Revoke + +### 1. Index project +- Grep `light_token::|light_token_client::|solana_sdk|Keypair|async|Approve|Revoke|delegate` across src/ +- Glob `**/*.rs` for project structure +- Identify: RPC setup, existing token ops, entry point for delegation +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have delegation operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token-client light-token light-client --features light-client/v2` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo check` +- Bash `cargo test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/rust-cookbook/burn.mdx b/snippets/ai-prompts/rust-cookbook/burn.mdx new file mode 100644 index 00000000..03c0f144 --- /dev/null +++ b/snippets/ai-prompts/rust-cookbook/burn.mdx @@ -0,0 +1,113 @@ + +{`--- +description: Burn Light Tokens +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Burn Light Tokens + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/burn +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +SPL equivalent: spl_token::instruction::burn → Light Token: Burn + +### 1. Index project +- Grep \`light_token::|light_token_client::|solana_sdk|Keypair|async|Burn|burn\` across src/ +- Glob \`**/*.rs\` for project structure +- Identify: RPC setup, existing token ops, entry point for burn +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have burn operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token-client light-token light-client --features light-client/v2\` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo check\` +- Bash \`cargo test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Burn Light Tokens +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Burn Light Tokens + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/burn +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +SPL equivalent: spl_token::instruction::burn → Light Token: Burn + +### 1. Index project +- Grep `light_token::|light_token_client::|solana_sdk|Keypair|async|Burn|burn` across src/ +- Glob `**/*.rs` for project structure +- Identify: RPC setup, existing token ops, entry point for burn +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have burn operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token-client light-token light-client --features light-client/v2` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo check` +- Bash `cargo test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/rust-cookbook/close-token-account.mdx b/snippets/ai-prompts/rust-cookbook/close-token-account.mdx new file mode 100644 index 00000000..a899432f --- /dev/null +++ b/snippets/ai-prompts/rust-cookbook/close-token-account.mdx @@ -0,0 +1,113 @@ + +{`--- +description: Close Light Token account +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Close Light Token account + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/close-token-account +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +SPL equivalent: spl_token::instruction::close_account → Light Token: CloseAccount + +### 1. Index project +- Grep \`light_token::|light_token_client::|solana_sdk|Keypair|async|CloseAccount|close_account\` across src/ +- Glob \`**/*.rs\` for project structure +- Identify: RPC setup, existing token ops, entry point for close account +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have close operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token-client light-token light-client --features light-client/v2\` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo check\` +- Bash \`cargo test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Close Light Token account +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Close Light Token account + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/close-token-account +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +SPL equivalent: spl_token::instruction::close_account → Light Token: CloseAccount + +### 1. Index project +- Grep `light_token::|light_token_client::|solana_sdk|Keypair|async|CloseAccount|close_account` across src/ +- Glob `**/*.rs` for project structure +- Identify: RPC setup, existing token ops, entry point for close account +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have close operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token-client light-token light-client --features light-client/v2` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo check` +- Bash `cargo test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/rust-cookbook/create-ata.mdx b/snippets/ai-prompts/rust-cookbook/create-ata.mdx new file mode 100644 index 00000000..3e54dc85 --- /dev/null +++ b/snippets/ai-prompts/rust-cookbook/create-ata.mdx @@ -0,0 +1,113 @@ + +{`--- +description: Create rent-free associated token account +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Create rent-free associated token account + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-ata +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +SPL equivalent: spl_associated_token_account::create → Light Token: CreateAta + +### 1. Index project +- Grep \`light_token::|light_token_client::|solana_sdk|Keypair|async|CreateAta|create_associated_token_account\` across src/ +- Glob \`**/*.rs\` for project structure +- Identify: RPC setup, existing token ops, entry point for ATA creation +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have ATA operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token-client light-token light-client --features light-client/v2\` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo check\` +- Bash \`cargo test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Create rent-free associated token account +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Create rent-free associated token account + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-ata +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +SPL equivalent: spl_associated_token_account::create → Light Token: CreateAta + +### 1. Index project +- Grep `light_token::|light_token_client::|solana_sdk|Keypair|async|CreateAta|create_associated_token_account` across src/ +- Glob `**/*.rs` for project structure +- Identify: RPC setup, existing token ops, entry point for ATA creation +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have ATA operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token-client light-token light-client --features light-client/v2` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo check` +- Bash `cargo test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/rust-cookbook/create-mint.mdx b/snippets/ai-prompts/rust-cookbook/create-mint.mdx new file mode 100644 index 00000000..0c833942 --- /dev/null +++ b/snippets/ai-prompts/rust-cookbook/create-mint.mdx @@ -0,0 +1,113 @@ + +{`--- +description: Create rent-free mint with token metadata +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Create rent-free mint with token metadata + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-mint +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +SPL equivalent: spl_token::instruction::initialize_mint → Light Token: CreateMint + +### 1. Index project +- Grep \`light_token::|light_token_client::|solana_sdk|Keypair|async|CreateMint|initialize_mint\` across src/ +- Glob \`**/*.rs\` for project structure +- Identify: RPC setup, existing token ops, entry point for mint creation +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have mint operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token-client light-token light-client --features light-client/v2\` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo check\` +- Bash \`cargo test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Create rent-free mint with token metadata +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Create rent-free mint with token metadata + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-mint +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +SPL equivalent: spl_token::instruction::initialize_mint → Light Token: CreateMint + +### 1. Index project +- Grep `light_token::|light_token_client::|solana_sdk|Keypair|async|CreateMint|initialize_mint` across src/ +- Glob `**/*.rs` for project structure +- Identify: RPC setup, existing token ops, entry point for mint creation +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have mint operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token-client light-token light-client --features light-client/v2` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo check` +- Bash `cargo test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/rust-cookbook/create-token-account.mdx b/snippets/ai-prompts/rust-cookbook/create-token-account.mdx new file mode 100644 index 00000000..a05f6e2a --- /dev/null +++ b/snippets/ai-prompts/rust-cookbook/create-token-account.mdx @@ -0,0 +1,113 @@ + +{`--- +description: Create Light Token account +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Create Light Token account + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-token-account +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +SPL equivalent: spl_token::instruction::initialize_account → Light Token: CreateTokenAccount + +### 1. Index project +- Grep \`light_token::|light_token_client::|solana_sdk|Keypair|async|CreateTokenAccount|initialize_account\` across src/ +- Glob \`**/*.rs\` for project structure +- Identify: RPC setup, existing token ops, entry point for token account creation +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have token account operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token-client light-token light-client --features light-client/v2\` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo check\` +- Bash \`cargo test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Create Light Token account +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Create Light Token account + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-token-account +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +SPL equivalent: spl_token::instruction::initialize_account → Light Token: CreateTokenAccount + +### 1. Index project +- Grep `light_token::|light_token_client::|solana_sdk|Keypair|async|CreateTokenAccount|initialize_account` across src/ +- Glob `**/*.rs` for project structure +- Identify: RPC setup, existing token ops, entry point for token account creation +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have token account operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token-client light-token light-client --features light-client/v2` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo check` +- Bash `cargo test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/rust-cookbook/freeze-thaw.mdx b/snippets/ai-prompts/rust-cookbook/freeze-thaw.mdx new file mode 100644 index 00000000..16a0ccf9 --- /dev/null +++ b/snippets/ai-prompts/rust-cookbook/freeze-thaw.mdx @@ -0,0 +1,121 @@ + +{`--- +description: Freeze and thaw Light Token accounts +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Freeze and thaw Light Token accounts + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/freeze-thaw +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +- Freeze: prevents all transfers or token burns from a specific Light Token account +- Thaw: re-enables transfers on a frozen Light Token account +- Only the freeze authority (set at mint creation) can freeze or thaw accounts + +SPL equivalent: spl_token::instruction::freeze_account / thaw_account → Light Token: Freeze / Thaw + +### 1. Index project +- Grep \`light_token::|light_token_client::|solana_sdk|Keypair|async|Freeze|Thaw|freeze_account|thaw_account\` across src/ +- Glob \`**/*.rs\` for project structure +- Identify: RPC setup, existing token ops, entry point for freeze/thaw +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have freeze/thaw operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token-client light-token light-client --features light-client/v2\` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo check\` +- Bash \`cargo test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Freeze and thaw Light Token accounts +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Freeze and thaw Light Token accounts + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/freeze-thaw +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +- Freeze: prevents all transfers or token burns from a specific Light Token account +- Thaw: re-enables transfers on a frozen Light Token account +- Only the freeze authority (set at mint creation) can freeze or thaw accounts + +SPL equivalent: spl_token::instruction::freeze_account / thaw_account → Light Token: Freeze / Thaw + +### 1. Index project +- Grep `light_token::|light_token_client::|solana_sdk|Keypair|async|Freeze|Thaw|freeze_account|thaw_account` across src/ +- Glob `**/*.rs` for project structure +- Identify: RPC setup, existing token ops, entry point for freeze/thaw +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have freeze/thaw operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token-client light-token light-client --features light-client/v2` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo check` +- Bash `cargo test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/rust-cookbook/mint-to.mdx b/snippets/ai-prompts/rust-cookbook/mint-to.mdx new file mode 100644 index 00000000..31c235fa --- /dev/null +++ b/snippets/ai-prompts/rust-cookbook/mint-to.mdx @@ -0,0 +1,113 @@ + +{`--- +description: Mint tokens to Light Token account +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Mint tokens to Light Token account + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/mint-to +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +SPL equivalent: spl_token::instruction::mint_to → Light Token: MintTo + +### 1. Index project +- Grep \`light_token::|light_token_client::|solana_sdk|Keypair|async|MintTo|mint_to\` across src/ +- Glob \`**/*.rs\` for project structure +- Identify: RPC setup, existing token ops, entry point for minting +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have mint operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token-client light-token light-client --features light-client/v2\` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo check\` +- Bash \`cargo test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Mint tokens to Light Token account +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Mint tokens to Light Token account + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/mint-to +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +SPL equivalent: spl_token::instruction::mint_to → Light Token: MintTo + +### 1. Index project +- Grep `light_token::|light_token_client::|solana_sdk|Keypair|async|MintTo|mint_to` across src/ +- Glob `**/*.rs` for project structure +- Identify: RPC setup, existing token ops, entry point for minting +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have mint operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token-client light-token light-client --features light-client/v2` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo check` +- Bash `cargo test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/rust-cookbook/transfer-checked.mdx b/snippets/ai-prompts/rust-cookbook/transfer-checked.mdx new file mode 100644 index 00000000..b7b4b4f6 --- /dev/null +++ b/snippets/ai-prompts/rust-cookbook/transfer-checked.mdx @@ -0,0 +1,117 @@ + +{`--- +description: Transfer tokens with decimal validation +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Transfer tokens with decimal validation + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/transfer-checked +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +TransferChecked validates that the decimals parameter matches the mint's decimals. Use for Light→Light transfers when you need decimal verification. For transfers involving SPL or Token 2022 accounts, use TransferInterface instead. + +SPL equivalent: spl_token::instruction::transfer_checked → Light Token: TransferChecked + +### 1. Index project +- Grep \`light_token::|light_token_client::|solana_sdk|Keypair|async|TransferChecked|transfer_checked\` across src/ +- Glob \`**/*.rs\` for project structure +- Identify: RPC setup, existing token ops, entry point for transfer checked +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have transfer operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token-client light-token light-client --features light-client/v2\` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo check\` +- Bash \`cargo test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Transfer tokens with decimal validation +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Transfer tokens with decimal validation + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/transfer-checked +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +TransferChecked validates that the decimals parameter matches the mint's decimals. Use for Light→Light transfers when you need decimal verification. For transfers involving SPL or Token 2022 accounts, use TransferInterface instead. + +SPL equivalent: spl_token::instruction::transfer_checked → Light Token: TransferChecked + +### 1. Index project +- Grep `light_token::|light_token_client::|solana_sdk|Keypair|async|TransferChecked|transfer_checked` across src/ +- Glob `**/*.rs` for project structure +- Identify: RPC setup, existing token ops, entry point for transfer checked +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have transfer operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token-client light-token light-client --features light-client/v2` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo check` +- Bash `cargo test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/rust-cookbook/transfer-interface.mdx b/snippets/ai-prompts/rust-cookbook/transfer-interface.mdx new file mode 100644 index 00000000..2158bcff --- /dev/null +++ b/snippets/ai-prompts/rust-cookbook/transfer-interface.mdx @@ -0,0 +1,123 @@ + +{`--- +description: Transfer tokens between Light Token and SPL accounts +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Transfer tokens between Light Token and SPL accounts + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/transfer-interface +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +TransferInterface transfers tokens between token accounts (SPL, Token 2022, or Light Token) in a single call. +- Light Token → Light Token: transfers between Light Token accounts +- SPL → Light Token: locks SPL tokens in interface PDA, mints to Light Token account +- Light Token → SPL: burns Light Token balance, releases SPL tokens from interface PDA + +SPL equivalent: spl_token::instruction::transfer → Light Token: TransferInterface + +### 1. Index project +- Grep \`light_token::|light_token_client::|solana_sdk|Keypair|async|TransferInterface|transfer\` across src/ +- Glob \`**/*.rs\` for project structure +- Identify: RPC setup, existing token ops, entry point for transfers +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have transfer operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token-client light-token light-client --features light-client/v2\` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo check\` +- Bash \`cargo test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Transfer tokens between Light Token and SPL accounts +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Transfer tokens between Light Token and SPL accounts + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/transfer-interface +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +TransferInterface transfers tokens between token accounts (SPL, Token 2022, or Light Token) in a single call. +- Light Token → Light Token: transfers between Light Token accounts +- SPL → Light Token: locks SPL tokens in interface PDA, mints to Light Token account +- Light Token → SPL: burns Light Token balance, releases SPL tokens from interface PDA + +SPL equivalent: spl_token::instruction::transfer → Light Token: TransferInterface + +### 1. Index project +- Grep `light_token::|light_token_client::|solana_sdk|Keypair|async|TransferInterface|transfer` across src/ +- Glob `**/*.rs` for project structure +- Identify: RPC setup, existing token ops, entry point for transfers +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have transfer operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token-client light-token light-client --features light-client/v2` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo check` +- Bash `cargo test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/rust-cookbook/wrap-unwrap.mdx b/snippets/ai-prompts/rust-cookbook/wrap-unwrap.mdx new file mode 100644 index 00000000..a9291718 --- /dev/null +++ b/snippets/ai-prompts/rust-cookbook/wrap-unwrap.mdx @@ -0,0 +1,119 @@ + +{`--- +description: Wrap and unwrap SPL tokens to Light Token +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Wrap and unwrap SPL tokens to Light Token + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/wrap-unwrap +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +- Wrap: move tokens from SPL or Token 2022 account → Light Token ATA (hot balance) +- Unwrap: move tokens from Light Token ATA (hot balance) → SPL or Token 2022 account + +No direct SPL equivalent — Wrap/Unwrap are Light Token operations → Light Token: Wrap / Unwrap + +### 1. Index project +- Grep \`light_token::|light_token_client::|solana_sdk|Keypair|async|Wrap|Unwrap|wrap|unwrap\` across src/ +- Glob \`**/*.rs\` for project structure +- Identify: RPC setup, existing token ops, entry point for wrap/unwrap +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have wrap/unwrap operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add light-token-client light-token light-client --features light-client/v2\` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo check\` +- Bash \`cargo test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Wrap and unwrap SPL tokens to Light Token +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Wrap and unwrap SPL tokens to Light Token + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/wrap-unwrap +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) + +- Wrap: move tokens from SPL or Token 2022 account → Light Token ATA (hot balance) +- Unwrap: move tokens from Light Token ATA (hot balance) → SPL or Token 2022 account + +No direct SPL equivalent — Wrap/Unwrap are Light Token operations → Light Token: Wrap / Unwrap + +### 1. Index project +- Grep `light_token::|light_token_client::|solana_sdk|Keypair|async|Wrap|Unwrap|wrap|unwrap` across src/ +- Glob `**/*.rs` for project structure +- Identify: RPC setup, existing token ops, entry point for wrap/unwrap +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have wrap/unwrap operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token-client light-token light-client --features light-client/v2` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo check` +- Bash `cargo test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/rust-template.mdx b/snippets/ai-prompts/rust-template.mdx new file mode 100644 index 00000000..ed5021d5 --- /dev/null +++ b/snippets/ai-prompts/rust-template.mdx @@ -0,0 +1,57 @@ +```text +--- +description: {{OPERATION_DESCRIPTION}} +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## {{OPERATION_DESCRIPTION}} + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/{{PAGE_SLUG}} +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: light-token-client (actions), light-token (instructions), light-client (RPC) +{{EXTRA_REFS}} + +SPL equivalent: {{SPL_FUNCTION}} → Light Token: {{LIGHT_FUNCTION}} + +### 1. Index project +- Grep `light_token::|light_token_client::|solana_sdk|Keypair|async{{EXTRA_GREP}}` across src/ +- Glob `**/*.rs` for project structure +- Identify: RPC setup, existing token ops, entry point for {{OP_SHORT}} +- Check Cargo.toml for existing light-* dependencies and solana-sdk version +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Rust Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have token operations to extend, or is this greenfield? +- AskUserQuestion: action-level API (high-level, fewer lines) or instruction-level API (low-level, full control)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Rpc/signer setup is compatible with the cookbook prerequisites (light_client::rpc::Rpc, solana_sdk::signature::Keypair) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add light-token-client light-token light-client --features light-client/v2` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo check` +- Bash `cargo test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/streaming/mints.mdx b/snippets/ai-prompts/streaming/mints.mdx new file mode 100644 index 00000000..f089503e --- /dev/null +++ b/snippets/ai-prompts/streaming/mints.mdx @@ -0,0 +1,115 @@ + +{`--- +description: Stream light-mint accounts and metadata via Laserstream gRPC +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Stream light-mint accounts and metadata via Laserstream gRPC + +Context: +- Guide: https://zkcompression.com/light-token/toolkits/for-streaming-mints +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: helius-laserstream, light-token-interface, borsh, futures +- Token accounts streaming: https://zkcompression.com/light-token/toolkits/for-streaming-tokens + +Key APIs: LaserstreamConfig, subscribe(), Mint::deserialize(), ExtensionStruct::TokenMetadata + +### 1. Index project +- Grep \`helius_laserstream|laserstream|subscribe|StreamExt|light_token_interface|Mint|cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: existing gRPC streaming setup, account caching, deserialization logic +- Read Cargo.toml — note existing dependencies +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Steps (Connect, Subscribe, Deserialize, Detect cold, Extract metadata) +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new streaming pipeline for mints, add mint streaming to existing token streaming, specific use case like metadata indexing) +- AskUserQuestion: mainnet or devnet? +- AskUserQuestion: do you need cold/hot transition detection, or just live mint state? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- Follow the guide's step order: Connect → Subscribe (account + transaction subs) → Deserialize Mint → Detect Cold → Extract Metadata +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add helius-laserstream@0.1 light-token-interface@0.3 borsh@0.10 futures@0.3 bs58@0.5 tokio --features full\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo check\` +- Bash \`cargo test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Stream light-mint accounts and metadata via Laserstream gRPC +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Stream light-mint accounts and metadata via Laserstream gRPC + +Context: +- Guide: https://zkcompression.com/light-token/toolkits/for-streaming-mints +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: helius-laserstream, light-token-interface, borsh, futures +- Token accounts streaming: https://zkcompression.com/light-token/toolkits/for-streaming-tokens + +Key APIs: LaserstreamConfig, subscribe(), Mint::deserialize(), ExtensionStruct::TokenMetadata + +### 1. Index project +- Grep `helius_laserstream|laserstream|subscribe|StreamExt|light_token_interface|Mint|cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: existing gRPC streaming setup, account caching, deserialization logic +- Read Cargo.toml — note existing dependencies +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Steps (Connect, Subscribe, Deserialize, Detect cold, Extract metadata) +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new streaming pipeline for mints, add mint streaming to existing token streaming, specific use case like metadata indexing) +- AskUserQuestion: mainnet or devnet? +- AskUserQuestion: do you need cold/hot transition detection, or just live mint state? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- Follow the guide's step order: Connect → Subscribe (account + transaction subs) → Deserialize Mint → Detect Cold → Extract Metadata +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add helius-laserstream@0.1 light-token-interface@0.3 borsh@0.10 futures@0.3 bs58@0.5 tokio --features full` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo check` +- Bash `cargo test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/streaming/tokens.mdx b/snippets/ai-prompts/streaming/tokens.mdx new file mode 100644 index 00000000..8a98db53 --- /dev/null +++ b/snippets/ai-prompts/streaming/tokens.mdx @@ -0,0 +1,121 @@ + +{`--- +description: Stream light-token accounts via Laserstream gRPC +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Stream light-token accounts via Laserstream gRPC + +Context: +- Guide: https://zkcompression.com/light-token/toolkits/for-streaming-tokens +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: helius-laserstream, light-token-interface, spl-pod, spl-token-2022-interface, borsh, futures +- Mint accounts streaming: https://zkcompression.com/light-token/toolkits/for-streaming-mints +- Point queries: light-client (LightClient, get_account_interface) + +Key APIs: LaserstreamConfig, subscribe(), PodAccount (pod_from_bytes), LightClient::get_account_interface() + +### 1. Index project +- Grep \`helius_laserstream|laserstream|subscribe|PodAccount|pod_from_bytes|spl_token_2022_interface|cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m\` across src/ +- Glob \`**/*.rs\` and \`**/Cargo.toml\` for project structure +- Identify: existing gRPC streaming setup, token account caching, SPL parser usage +- Read Cargo.toml — note existing dependencies +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Steps (Connect, Subscribe) and the transition detection sections +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new streaming pipeline for token accounts, add to existing pipeline, integrate cold/hot detection for routing) +- AskUserQuestion: mainnet or devnet? +- AskUserQuestion: do you need point queries (get_account_interface) in addition to streaming? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- Follow the guide's structure: Connect → Subscribe (account + transaction subs) → Detect Transitions (hot-to-cold, cold-to-hot) → Point Queries (optional) +- Token accounts use the same 165-byte SPL layout — existing SPL parsers work directly +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`cargo add helius-laserstream@0.1 light-token-interface@0.3 spl-pod spl-token-2022-interface borsh@0.10 futures@0.3 bs58@0.5 tokio --features full\` +- For point queries, also: Bash \`cargo add light-client@0.19 --features v2\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`cargo check\` +- Bash \`cargo test\` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Stream light-token accounts via Laserstream gRPC +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Stream light-token accounts via Laserstream gRPC + +Context: +- Guide: https://zkcompression.com/light-token/toolkits/for-streaming-tokens +- Skills and resources index: https://zkcompression.com/skill.md +- Crates: helius-laserstream, light-token-interface, spl-pod, spl-token-2022-interface, borsh, futures +- Mint accounts streaming: https://zkcompression.com/light-token/toolkits/for-streaming-mints +- Point queries: light-client (LightClient, get_account_interface) + +Key APIs: LaserstreamConfig, subscribe(), PodAccount (pod_from_bytes), LightClient::get_account_interface() + +### 1. Index project +- Grep `helius_laserstream|laserstream|subscribe|PodAccount|pod_from_bytes|spl_token_2022_interface|cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m` across src/ +- Glob `**/*.rs` and `**/Cargo.toml` for project structure +- Identify: existing gRPC streaming setup, token account caching, SPL parser usage +- Read Cargo.toml — note existing dependencies +- Task subagent (Grep/Read/WebFetch) if project has multiple crates to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the Steps (Connect, Subscribe) and the transition detection sections +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new streaming pipeline for token accounts, add to existing pipeline, integrate cold/hot detection for routing) +- AskUserQuestion: mainnet or devnet? +- AskUserQuestion: do you need point queries (get_account_interface) in addition to streaming? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- Follow the guide's structure: Connect → Subscribe (account + transaction subs) → Detect Transitions (hot-to-cold, cold-to-hot) → Point Queries (optional) +- Token accounts use the same 165-byte SPL layout — existing SPL parsers work directly +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `cargo add helius-laserstream@0.1 light-token-interface@0.3 spl-pod spl-token-2022-interface borsh@0.10 futures@0.3 bs58@0.5 tokio --features full` +- For point queries, also: Bash `cargo add light-client@0.19 --features v2` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `cargo check` +- Bash `cargo test` if tests exist +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/template.mdx b/snippets/ai-prompts/template.mdx new file mode 100644 index 00000000..786f9661 --- /dev/null +++ b/snippets/ai-prompts/template.mdx @@ -0,0 +1,55 @@ +```text +--- +description: {{OPERATION_DESCRIPTION}} +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## {{OPERATION_DESCRIPTION}} + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/{{PAGE_SLUG}} +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js +{{EXTRA_REFS}} + +SPL equivalent: {{SPL_FUNCTION}} → Light Token: {{LIGHT_FUNCTION}} + +### 1. Index project +- Grep `@solana/spl-token|Connection|Keypair` across src/ +- Glob `**/*.ts` for project structure +- Identify: RPC setup, existing token ops, entry point for {{OP_SHORT}} +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the TypeScript Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have token operations to extend, or is this greenfield? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing connection/signer setup is compatible with the cookbook prerequisites +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `npm install @lightprotocol/compressed-token @lightprotocol/stateless.js` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `tsc --noEmit` +- Bash run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/toolkits/airdrop.mdx b/snippets/ai-prompts/toolkits/airdrop.mdx new file mode 100644 index 00000000..5eb368c7 --- /dev/null +++ b/snippets/ai-prompts/toolkits/airdrop.mdx @@ -0,0 +1,125 @@ + +{`--- +description: Distribute compressed tokens via airdrop +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Distribute compressed tokens via airdrop + +Context: +- Guide: https://zkcompression.com/compressed-tokens/airdrop +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js, @solana/spl-token +- Example repo: https://github.com/Lightprotocol/example-token-distribution +- Webapp alternative: https://airship.helius.dev/ (Airship by Helius Labs, up to 200k recipients) + +Key APIs: LightTokenProgram.compress(), getTokenPoolInfos(), selectTokenPoolInfo(), getStateTreeInfos(), selectStateTreeInfo(), buildAndSignTx(), sendAndConfirmTx() + +### 1. Index project +- Grep \`LightTokenProgram|compress|getTokenPoolInfos|selectTokenPoolInfo|getStateTreeInfos|@lightprotocol|airdrop|distribution\` across src/ +- Glob \`**/*.ts\` for project structure +- Identify: existing airdrop/distribution logic, token minting setup, recipient list format +- Check package.json for existing @lightprotocol/* or @solana/spl-token dependencies +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — review all three tabs (Localnet Guide, Simple Airdrop, Batched) +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what scale? (<10k recipients = simple airdrop, 10k+ = batched) +- AskUserQuestion: localnet testing first, or production deploy? +- AskUserQuestion: do you have an existing SPL mint, or need to create one? +- AskUserQuestion: do you need decompression/claim functionality, or just direct distribution? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- For simple airdrop: create mint → mint SPL tokens → LightTokenProgram.compress() with recipients array +- For batched: create instruction batches → manage blockhash refresh → sign and send with retry logic +- Address lookup table needed for production (mainnet: 9NYFyEqPkyXUhkerbGHXUXkvb4qpzeEdHuGpgbgpH1NJ) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`npm install @lightprotocol/compressed-token @lightprotocol/stateless.js @solana/spl-token\` +- Set up RPC: \`createRpc(RPC_ENDPOINT)\` with a ZK Compression endpoint (Helius, Triton) +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`tsc --noEmit\` +- Bash run existing test suite or execute localnet test airdrop +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Distribute compressed tokens via airdrop +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Distribute compressed tokens via airdrop + +Context: +- Guide: https://zkcompression.com/compressed-tokens/airdrop +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js, @solana/spl-token +- Example repo: https://github.com/Lightprotocol/example-token-distribution +- Webapp alternative: https://airship.helius.dev/ (Airship by Helius Labs, up to 200k recipients) + +Key APIs: LightTokenProgram.compress(), getTokenPoolInfos(), selectTokenPoolInfo(), getStateTreeInfos(), selectStateTreeInfo(), buildAndSignTx(), sendAndConfirmTx() + +### 1. Index project +- Grep `LightTokenProgram|compress|getTokenPoolInfos|selectTokenPoolInfo|getStateTreeInfos|@lightprotocol|airdrop|distribution` across src/ +- Glob `**/*.ts` for project structure +- Identify: existing airdrop/distribution logic, token minting setup, recipient list format +- Check package.json for existing @lightprotocol/* or @solana/spl-token dependencies +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — review all three tabs (Localnet Guide, Simple Airdrop, Batched) +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what scale? (<10k recipients = simple airdrop, 10k+ = batched) +- AskUserQuestion: localnet testing first, or production deploy? +- AskUserQuestion: do you have an existing SPL mint, or need to create one? +- AskUserQuestion: do you need decompression/claim functionality, or just direct distribution? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan +- For simple airdrop: create mint → mint SPL tokens → LightTokenProgram.compress() with recipients array +- For batched: create instruction batches → manage blockhash refresh → sign and send with retry logic +- Address lookup table needed for production (mainnet: 9NYFyEqPkyXUhkerbGHXUXkvb4qpzeEdHuGpgbgpH1NJ) +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `npm install @lightprotocol/compressed-token @lightprotocol/stateless.js @solana/spl-token` +- Set up RPC: `createRpc(RPC_ENDPOINT)` with a ZK Compression endpoint (Helius, Triton) +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `tsc --noEmit` +- Bash run existing test suite or execute localnet test airdrop +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/toolkits/nullifiers.mdx b/snippets/ai-prompts/toolkits/nullifiers.mdx new file mode 100644 index 00000000..0f781c9d --- /dev/null +++ b/snippets/ai-prompts/toolkits/nullifiers.mdx @@ -0,0 +1,127 @@ + +{`--- +description: Create rent-free nullifier PDAs to prevent duplicate actions +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Create rent-free nullifier PDAs to prevent duplicate actions + +Context: +- Guide: https://zkcompression.com/pda/compressed-pdas/guides/how-to-create-nullifier-pdas +- Skills and resources index: https://zkcompression.com/skill.md +- Rust crates: light-nullifier-program, light-client +- TS packages: @lightprotocol/nullifier-program, @lightprotocol/stateless.js +- Example: https://github.com/Lightprotocol/examples-light-token/blob/main/rust-client/actions/create_nullifier.rs +- Program source: https://github.com/Lightprotocol/nullifier-program/ + +Key APIs: +- Rust: create_nullifier_ix(), fetch_proof(), build_instruction(), derive_nullifier_address() +- TS: createNullifierIx(), fetchProof(), buildInstruction(), deriveNullifierAddress() + +### 1. Index project +- Grep \`nullifier|create_nullifier|createNullifierIx|deriveNullifierAddress|NFLx5WGPrTHHvdRNsidcrNcLxRruMC92E4yv7zhZBoT\` across src/ +- Glob \`**/*.rs\` and \`**/*.ts\` for project structure +- Identify: existing transaction building, duplicate prevention logic, payment flow +- Check Cargo.toml or package.json for existing light-* dependencies +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both Rust and TS code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: Rust or TypeScript? +- AskUserQuestion: what is the goal? (prevent duplicate payments, idempotent instruction execution, other use case) +- AskUserQuestion: do you need the helper (create_nullifier_ix) or manual proof fetching (fetch_proof + build_instruction)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's pattern: create unique 32-byte ID → build nullifier instruction → prepend to transaction +- If checking existence is needed, add derive_nullifier_address + get_compressed_account check +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- For Rust: Bash \`cargo add light-nullifier-program@0.1 light-client@0.19\` +- For TypeScript: Bash \`npm install @lightprotocol/nullifier-program @lightprotocol/stateless.js@beta\` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Rust: Bash \`cargo check\` + \`cargo test\` if tests exist +- TypeScript: Bash \`tsc --noEmit\` + run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Create rent-free nullifier PDAs to prevent duplicate actions +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Create rent-free nullifier PDAs to prevent duplicate actions + +Context: +- Guide: https://zkcompression.com/pda/compressed-pdas/guides/how-to-create-nullifier-pdas +- Skills and resources index: https://zkcompression.com/skill.md +- Rust crates: light-nullifier-program, light-client +- TS packages: @lightprotocol/nullifier-program, @lightprotocol/stateless.js +- Example: https://github.com/Lightprotocol/examples-light-token/blob/main/rust-client/actions/create_nullifier.rs +- Program source: https://github.com/Lightprotocol/nullifier-program/ + +Key APIs: +- Rust: create_nullifier_ix(), fetch_proof(), build_instruction(), derive_nullifier_address() +- TS: createNullifierIx(), fetchProof(), buildInstruction(), deriveNullifierAddress() + +### 1. Index project +- Grep `nullifier|create_nullifier|createNullifierIx|deriveNullifierAddress|NFLx5WGPrTHHvdRNsidcrNcLxRruMC92E4yv7zhZBoT` across src/ +- Glob `**/*.rs` and `**/*.ts` for project structure +- Identify: existing transaction building, duplicate prevention logic, payment flow +- Check Cargo.toml or package.json for existing light-* dependencies +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both Rust and TS code samples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: Rust or TypeScript? +- AskUserQuestion: what is the goal? (prevent duplicate payments, idempotent instruction execution, other use case) +- AskUserQuestion: do you need the helper (create_nullifier_ix) or manual proof fetching (fetch_proof + build_instruction)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Follow the guide's pattern: create unique 32-byte ID → build nullifier instruction → prepend to transaction +- If checking existence is needed, add derive_nullifier_address + get_compressed_account check +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- For Rust: Bash `cargo add light-nullifier-program@0.1 light-client@0.19` +- For TypeScript: Bash `npm install @lightprotocol/nullifier-program @lightprotocol/stateless.js@beta` +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Rust: Bash `cargo check` + `cargo test` if tests exist +- TypeScript: Bash `tsc --noEmit` + run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/toolkits/payments.mdx b/snippets/ai-prompts/toolkits/payments.mdx new file mode 100644 index 00000000..6926fba9 --- /dev/null +++ b/snippets/ai-prompts/toolkits/payments.mdx @@ -0,0 +1,135 @@ + +{`--- +description: Integrate light-token APIs for stablecoin payments +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Integrate light-token APIs for stablecoin payments + +Context: +- Guide: https://zkcompression.com/light-token/toolkits/for-payments +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js +- Full examples: https://github.com/Lightprotocol/examples-light-token/tree/main/toolkits/payments-and-wallets + +SPL → Light Token API mapping: +| Operation | SPL | Light Token | +| Receive | getOrCreateAssociatedTokenAccount() | createLoadAtaInstructions() / loadAta() | +| Transfer | createTransferInstruction() | createTransferInterfaceInstructions() | +| Get Balance | getAccount() | getAtaInterface() | +| Tx History | getSignaturesForAddress() | getSignaturesForOwnerInterface() | +| Wrap SPL | N/A | createWrapInstruction() / wrap() | +| Unwrap | N/A | createUnwrapInstructions() / unwrap() | + +### 1. Index project +- Grep \`@solana/spl-token|@lightprotocol|createTransferInstruction|getAccount|Connection|Keypair|stablecoin|payment\` across src/ +- Glob \`**/*.ts\` and \`**/*.tsx\` for project structure +- Identify: RPC setup, existing token operations, payment flow, wallet signing pattern +- Check package.json for existing @lightprotocol/* or @solana/spl-token dependencies +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — review Instruction and Action tabs for each operation +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new payment integration, migrate existing SPL payment flow, add alongside existing SPL) +- AskUserQuestion: which operations? (receive, send, balance, history, wrap, unwrap — or all) +- AskUserQuestion: instruction-level API (build your own transactions) or action-level API (high-level, fewer lines)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing connection/signer setup is compatible (createRpc with ZK Compression endpoint) +- Key pattern: import from \`@lightprotocol/compressed-token/unified\` for all interface APIs +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`npm install @lightprotocol/compressed-token @lightprotocol/stateless.js\` +- Set up RPC: \`createRpc(RPC_ENDPOINT)\` with a ZK Compression endpoint (Helius, Triton) +- Import from \`@lightprotocol/compressed-token/unified\` for the interface APIs +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`tsc --noEmit\` +- Bash run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Integrate light-token APIs for stablecoin payments +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Integrate light-token APIs for stablecoin payments + +Context: +- Guide: https://zkcompression.com/light-token/toolkits/for-payments +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js +- Full examples: https://github.com/Lightprotocol/examples-light-token/tree/main/toolkits/payments-and-wallets + +SPL → Light Token API mapping: +| Operation | SPL | Light Token | +| Receive | getOrCreateAssociatedTokenAccount() | createLoadAtaInstructions() / loadAta() | +| Transfer | createTransferInstruction() | createTransferInterfaceInstructions() | +| Get Balance | getAccount() | getAtaInterface() | +| Tx History | getSignaturesForAddress() | getSignaturesForOwnerInterface() | +| Wrap SPL | N/A | createWrapInstruction() / wrap() | +| Unwrap | N/A | createUnwrapInstructions() / unwrap() | + +### 1. Index project +- Grep `@solana/spl-token|@lightprotocol|createTransferInstruction|getAccount|Connection|Keypair|stablecoin|payment` across src/ +- Glob `**/*.ts` and `**/*.tsx` for project structure +- Identify: RPC setup, existing token operations, payment flow, wallet signing pattern +- Check package.json for existing @lightprotocol/* or @solana/spl-token dependencies +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — review Instruction and Action tabs for each operation +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new payment integration, migrate existing SPL payment flow, add alongside existing SPL) +- AskUserQuestion: which operations? (receive, send, balance, history, wrap, unwrap — or all) +- AskUserQuestion: instruction-level API (build your own transactions) or action-level API (high-level, fewer lines)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing connection/signer setup is compatible (createRpc with ZK Compression endpoint) +- Key pattern: import from `@lightprotocol/compressed-token/unified` for all interface APIs +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `npm install @lightprotocol/compressed-token @lightprotocol/stateless.js` +- Set up RPC: `createRpc(RPC_ENDPOINT)` with a ZK Compression endpoint (Helius, Triton) +- Import from `@lightprotocol/compressed-token/unified` for the interface APIs +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `tsc --noEmit` +- Bash run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/toolkits/wallets.mdx b/snippets/ai-prompts/toolkits/wallets.mdx new file mode 100644 index 00000000..b0b73c58 --- /dev/null +++ b/snippets/ai-prompts/toolkits/wallets.mdx @@ -0,0 +1,137 @@ + +{`--- +description: Add light-token support to a wallet application +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add light-token support to a wallet application + +Context: +- Guide: https://zkcompression.com/light-token/toolkits/for-wallets +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js +- Full examples: https://github.com/Lightprotocol/examples-light-token/tree/main/toolkits/payments-and-wallets + +SPL → Light Token API mapping: +| Operation | SPL | Light Token | +| Receive | getOrCreateAssociatedTokenAccount() | createLoadAtaInstructions() / loadAta() | +| Transfer | createTransferInstruction() | createTransferInterfaceInstructions() | +| Get Balance | getAccount() | getAtaInterface() | +| Tx History | getSignaturesForAddress() | getSignaturesForOwnerInterface() | +| Wrap SPL | N/A | createWrapInstruction() / wrap() | +| Unwrap | N/A | createUnwrapInstructions() / unwrap() | + +### 1. Index project +- Grep \`@solana/spl-token|@lightprotocol|createTransferInstruction|getAccount|wallet|signTransaction|signAllTransactions|Connection\` across src/ +- Glob \`**/*.ts\` and \`**/*.tsx\` for project structure +- Identify: RPC setup, existing token display/balance logic, wallet adapter, transaction signing pattern +- Check package.json for existing @lightprotocol/* or @solana/spl-token dependencies +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — review Instruction and Action tabs for each operation +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new wallet integration, migrate existing SPL wallet to light-token, add light-token alongside existing SPL) +- AskUserQuestion: which operations? (receive, send, balance, history, wrap, unwrap — or all) +- AskUserQuestion: instruction-level API (build your own transactions) or action-level API (high-level, fewer lines)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing connection/signer setup is compatible (createRpc with ZK Compression endpoint) +- Key pattern: import from \`@lightprotocol/compressed-token/unified\` for all interface APIs +- APIs return TransactionInstruction[][] — handle multi-tx case with signAllTransactions +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`npm install @lightprotocol/compressed-token @lightprotocol/stateless.js\` +- Set up RPC: \`createRpc(RPC_ENDPOINT)\` with a ZK Compression endpoint (Helius, Triton) +- Import from \`@lightprotocol/compressed-token/unified\` for the interface APIs +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`tsc --noEmit\` +- Bash run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Add light-token support to a wallet application +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add light-token support to a wallet application + +Context: +- Guide: https://zkcompression.com/light-token/toolkits/for-wallets +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js +- Full examples: https://github.com/Lightprotocol/examples-light-token/tree/main/toolkits/payments-and-wallets + +SPL → Light Token API mapping: +| Operation | SPL | Light Token | +| Receive | getOrCreateAssociatedTokenAccount() | createLoadAtaInstructions() / loadAta() | +| Transfer | createTransferInstruction() | createTransferInterfaceInstructions() | +| Get Balance | getAccount() | getAtaInterface() | +| Tx History | getSignaturesForAddress() | getSignaturesForOwnerInterface() | +| Wrap SPL | N/A | createWrapInstruction() / wrap() | +| Unwrap | N/A | createUnwrapInstructions() / unwrap() | + +### 1. Index project +- Grep `@solana/spl-token|@lightprotocol|createTransferInstruction|getAccount|wallet|signTransaction|signAllTransactions|Connection` across src/ +- Glob `**/*.ts` and `**/*.tsx` for project structure +- Identify: RPC setup, existing token display/balance logic, wallet adapter, transaction signing pattern +- Check package.json for existing @lightprotocol/* or @solana/spl-token dependencies +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — review Instruction and Action tabs for each operation +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new wallet integration, migrate existing SPL wallet to light-token, add light-token alongside existing SPL) +- AskUserQuestion: which operations? (receive, send, balance, history, wrap, unwrap — or all) +- AskUserQuestion: instruction-level API (build your own transactions) or action-level API (high-level, fewer lines)? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing connection/signer setup is compatible (createRpc with ZK Compression endpoint) +- Key pattern: import from `@lightprotocol/compressed-token/unified` for all interface APIs +- APIs return TransactionInstruction[][] — handle multi-tx case with signAllTransactions +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `npm install @lightprotocol/compressed-token @lightprotocol/stateless.js` +- Set up RPC: `createRpc(RPC_ENDPOINT)` with a ZK Compression endpoint (Helius, Triton) +- Import from `@lightprotocol/compressed-token/unified` for the interface APIs +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `tsc --noEmit` +- Bash run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/ts-cookbook/approve-revoke.mdx b/snippets/ai-prompts/ts-cookbook/approve-revoke.mdx new file mode 100644 index 00000000..b8927232 --- /dev/null +++ b/snippets/ai-prompts/ts-cookbook/approve-revoke.mdx @@ -0,0 +1,109 @@ + +{`--- +description: Approve and revoke token delegates +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Approve and revoke token delegates + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/approve-revoke +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js + +SPL equivalent: approve() / revoke() → Light Token: approve() / revoke() + +### 1. Index project +- Grep \`@solana/spl-token|Connection|Keypair|approve|revoke|delegate\` across src/ +- Glob \`**/*.ts\` for project structure +- Identify: RPC setup, existing delegation logic, entry point for delegation +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the TypeScript Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have delegate operations to extend, or is this greenfield? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing connection/signer setup is compatible with the cookbook prerequisites +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`npm install @lightprotocol/compressed-token @lightprotocol/stateless.js\` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`tsc --noEmit\` +- Bash run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Approve and revoke token delegates +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Approve and revoke token delegates + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/approve-revoke +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js + +SPL equivalent: approve() / revoke() → Light Token: approve() / revoke() + +### 1. Index project +- Grep `@solana/spl-token|Connection|Keypair|approve|revoke|delegate` across src/ +- Glob `**/*.ts` for project structure +- Identify: RPC setup, existing delegation logic, entry point for delegation +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the TypeScript Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have delegate operations to extend, or is this greenfield? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing connection/signer setup is compatible with the cookbook prerequisites +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `npm install @lightprotocol/compressed-token @lightprotocol/stateless.js` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `tsc --noEmit` +- Bash run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/ts-cookbook/create-ata.mdx b/snippets/ai-prompts/ts-cookbook/create-ata.mdx new file mode 100644 index 00000000..8731bd4d --- /dev/null +++ b/snippets/ai-prompts/ts-cookbook/create-ata.mdx @@ -0,0 +1,109 @@ + +{`--- +description: Create rent-free associated token account +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Create rent-free associated token account + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-ata +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js + +SPL equivalent: createAssociatedTokenAccount() → Light Token: createAtaInterface() + +### 1. Index project +- Grep \`@solana/spl-token|Connection|Keypair|createAssociatedTokenAccount|createAtaInterface\` across src/ +- Glob \`**/*.ts\` for project structure +- Identify: RPC setup, existing ATA logic, entry point for ATA creation +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the TypeScript Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have ATA operations to extend, or is this greenfield? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing connection/signer setup is compatible with the cookbook prerequisites +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`npm install @lightprotocol/compressed-token @lightprotocol/stateless.js\` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`tsc --noEmit\` +- Bash run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Create rent-free associated token account +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Create rent-free associated token account + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-ata +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js + +SPL equivalent: createAssociatedTokenAccount() → Light Token: createAtaInterface() + +### 1. Index project +- Grep `@solana/spl-token|Connection|Keypair|createAssociatedTokenAccount|createAtaInterface` across src/ +- Glob `**/*.ts` for project structure +- Identify: RPC setup, existing ATA logic, entry point for ATA creation +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the TypeScript Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have ATA operations to extend, or is this greenfield? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing connection/signer setup is compatible with the cookbook prerequisites +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `npm install @lightprotocol/compressed-token @lightprotocol/stateless.js` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `tsc --noEmit` +- Bash run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/ts-cookbook/create-mint.mdx b/snippets/ai-prompts/ts-cookbook/create-mint.mdx new file mode 100644 index 00000000..bd177f08 --- /dev/null +++ b/snippets/ai-prompts/ts-cookbook/create-mint.mdx @@ -0,0 +1,109 @@ + +{`--- +description: Add rent-free mint with token metadata +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add rent-free mint with token metadata + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-mint +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js + +SPL equivalent: createMint() → Light Token: createMintInterface() + +### 1. Index project +- Grep \`@solana/spl-token|Connection|Keypair|createMint\` across src/ +- Glob \`**/*.ts\` for project structure +- Identify: RPC setup, existing mint logic, entry point for mint creation +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the TypeScript Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have mint operations to extend, or is this greenfield? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing connection/signer setup is compatible with the cookbook prerequisites +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`npm install @lightprotocol/compressed-token @lightprotocol/stateless.js\` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`tsc --noEmit\` +- Bash run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Add rent-free mint with token metadata +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Add rent-free mint with token metadata + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/create-mint +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js + +SPL equivalent: createMint() → Light Token: createMintInterface() + +### 1. Index project +- Grep `@solana/spl-token|Connection|Keypair|createMint` across src/ +- Glob `**/*.ts` for project structure +- Identify: RPC setup, existing mint logic, entry point for mint creation +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the TypeScript Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have mint operations to extend, or is this greenfield? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing connection/signer setup is compatible with the cookbook prerequisites +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `npm install @lightprotocol/compressed-token @lightprotocol/stateless.js` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `tsc --noEmit` +- Bash run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/ts-cookbook/mint-to.mdx b/snippets/ai-prompts/ts-cookbook/mint-to.mdx new file mode 100644 index 00000000..0e24f3f1 --- /dev/null +++ b/snippets/ai-prompts/ts-cookbook/mint-to.mdx @@ -0,0 +1,109 @@ + +{`--- +description: Mint tokens to Light Token account +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Mint tokens to Light Token account + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/mint-to +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js + +SPL equivalent: mintTo() → Light Token: mintToInterface() + +### 1. Index project +- Grep \`@solana/spl-token|Connection|Keypair|mintTo|mintToInterface\` across src/ +- Glob \`**/*.ts\` for project structure +- Identify: RPC setup, existing mint logic, entry point for minting +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the TypeScript Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have mint operations to extend, or is this greenfield? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing connection/signer setup is compatible with the cookbook prerequisites +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`npm install @lightprotocol/compressed-token @lightprotocol/stateless.js\` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`tsc --noEmit\` +- Bash run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Mint tokens to Light Token account +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Mint tokens to Light Token account + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/mint-to +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js + +SPL equivalent: mintTo() → Light Token: mintToInterface() + +### 1. Index project +- Grep `@solana/spl-token|Connection|Keypair|mintTo|mintToInterface` across src/ +- Glob `**/*.ts` for project structure +- Identify: RPC setup, existing mint logic, entry point for minting +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the TypeScript Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have mint operations to extend, or is this greenfield? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing connection/signer setup is compatible with the cookbook prerequisites +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `npm install @lightprotocol/compressed-token @lightprotocol/stateless.js` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `tsc --noEmit` +- Bash run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/ts-cookbook/transfer-interface.mdx b/snippets/ai-prompts/ts-cookbook/transfer-interface.mdx new file mode 100644 index 00000000..2138a6ad --- /dev/null +++ b/snippets/ai-prompts/ts-cookbook/transfer-interface.mdx @@ -0,0 +1,115 @@ + +{`--- +description: Transfer tokens between Light Token and SPL accounts +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Transfer tokens between Light Token and SPL accounts + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/transfer-interface +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js + +transferInterface() transfers tokens between token accounts (SPL, Token 2022, or Light Token) in a single call. +- Light Token → Light Token: transfers between Light Token accounts +- SPL → Light Token: locks SPL tokens in interface PDA, mints to Light Token account +- Light Token → SPL: burns Light Token balance, releases SPL tokens from interface PDA + +### 1. Index project +- Grep \`@solana/spl-token|Connection|Keypair|transfer|transferInterface\` across src/ +- Glob \`**/*.ts\` for project structure +- Identify: RPC setup, existing transfer logic, entry point for transfers +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the TypeScript Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have transfer operations to extend, or is this greenfield? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing connection/signer setup is compatible with the cookbook prerequisites +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`npm install @lightprotocol/compressed-token @lightprotocol/stateless.js\` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`tsc --noEmit\` +- Bash run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Transfer tokens between Light Token and SPL accounts +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Transfer tokens between Light Token and SPL accounts + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/transfer-interface +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js + +transferInterface() transfers tokens between token accounts (SPL, Token 2022, or Light Token) in a single call. +- Light Token → Light Token: transfers between Light Token accounts +- SPL → Light Token: locks SPL tokens in interface PDA, mints to Light Token account +- Light Token → SPL: burns Light Token balance, releases SPL tokens from interface PDA + +### 1. Index project +- Grep `@solana/spl-token|Connection|Keypair|transfer|transferInterface` across src/ +- Glob `**/*.ts` for project structure +- Identify: RPC setup, existing transfer logic, entry point for transfers +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the TypeScript Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have transfer operations to extend, or is this greenfield? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing connection/signer setup is compatible with the cookbook prerequisites +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `npm install @lightprotocol/compressed-token @lightprotocol/stateless.js` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `tsc --noEmit` +- Bash run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/ts-cookbook/wrap-unwrap.mdx b/snippets/ai-prompts/ts-cookbook/wrap-unwrap.mdx new file mode 100644 index 00000000..9db38063 --- /dev/null +++ b/snippets/ai-prompts/ts-cookbook/wrap-unwrap.mdx @@ -0,0 +1,111 @@ + +{`--- +description: Wrap and unwrap SPL tokens to Light Token +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Wrap and unwrap SPL tokens to Light Token + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/wrap-unwrap +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js + +- Wrap: Move tokens from SPL or Token 2022 account → Light Token associated token account (hot balance) +- Unwrap: Move tokens from Light Token associated token account (hot balance) → SPL or Token 2022 account + +### 1. Index project +- Grep \`@solana/spl-token|Connection|Keypair|wrap|unwrap|WrapTokens|UnwrapTokens\` across src/ +- Glob \`**/*.ts\` for project structure +- Identify: RPC setup, existing wrap/unwrap logic, entry point for wrap/unwrap +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the TypeScript Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have wrap/unwrap operations to extend, or is this greenfield? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing connection/signer setup is compatible with the cookbook prerequisites +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`npm install @lightprotocol/compressed-token @lightprotocol/stateless.js\` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`tsc --noEmit\` +- Bash run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Wrap and unwrap SPL tokens to Light Token +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Wrap and unwrap SPL tokens to Light Token + +Context: +- Guide: https://zkcompression.com/light-token/cookbook/wrap-unwrap +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js + +- Wrap: Move tokens from SPL or Token 2022 account → Light Token associated token account (hot balance) +- Unwrap: Move tokens from Light Token associated token account (hot balance) → SPL or Token 2022 account + +### 1. Index project +- Grep `@solana/spl-token|Connection|Keypair|wrap|unwrap|WrapTokens|UnwrapTokens` across src/ +- Glob `**/*.ts` for project structure +- Identify: RPC setup, existing wrap/unwrap logic, entry point for wrap/unwrap +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — follow the TypeScript Client tab +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: what is the goal? (new feature, migrate existing SPL code, add alongside existing) +- AskUserQuestion: does the project already have wrap/unwrap operations to extend, or is this greenfield? +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing connection/signer setup is compatible with the cookbook prerequisites +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `npm install @lightprotocol/compressed-token @lightprotocol/stateless.js` +- Follow the cookbook guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `tsc --noEmit` +- Bash run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/ai-prompts/v1-to-v2-migration.mdx b/snippets/ai-prompts/v1-to-v2-migration.mdx index 466aa94f..11bed006 100644 --- a/snippets/ai-prompts/v1-to-v2-migration.mdx +++ b/snippets/ai-prompts/v1-to-v2-migration.mdx @@ -1,3 +1,114 @@ + +{`--- +argument-hint: +description: Migrate Light Protocol program from v1 to v2 Merkle trees +allowed-tools: [Bash, Read, Glob, Grep, Task, WebFetch] +--- + +Migrate this Light Protocol program from v1 to v2 Merkle trees. + +## Goal + +Produce a **fully working migration** that builds and tests pass. + +## Available commands + +Via Bash tool: +- **cargo build-sbf**, **cargo test-sbf**, **cargo fmt**, **cargo clippy** +- **anchor build**, **anchor test** +- **grep**, **sed** + +## Documentation + +- Migration Guide: https://zkcompression.com/references/migration-v1-to-v2 +- Reference PR: https://github.com/Lightprotocol/program-examples/commit/54f0e7f15c2972a078f776cfb40b238d83c7e486 + +## Reference repos + +program-examples/counter/anchor/ +├── programs/counter/src/lib.rs # v2 patterns: derive_address, CpiAccounts +├── Cargo.toml # v2 feature flags +└── tests/counter.ts # v2 client patterns + +## Workflow + +### Phase 1: Index program + +Find all v1 patterns: + + grep -r "::v1::" src/ tests/ + grep -r "ADDRESS_TREE_V1" src/ + grep -r "into_new_address_params_packed" src/ + grep -r "get_address_tree_v1" tests/ + +### Phase 2: Update dependencies + +Update Cargo.toml. V2 is the default - no feature flag needed: + + # On-chain program + [dependencies] + light-sdk = { version = "0.17.1", features = ["anchor"] } + light-hasher = "5.0.0" + + # Off-chain client + [dependencies] + light-client = "0.17.2" + +Note: V2 is now the default in all crates. Only specify \`features = ["v2"]\` if you disabled default features. + +### Phase 3: Rust SDK replacements + +| v1 Pattern | v2 Replacement | +|------------|----------------| +| address::v1::derive_address | address::v2::derive_address | +| cpi::v1::CpiAccounts | cpi::v2::CpiAccounts | +| cpi::v1::LightSystemProgramCpi | cpi::v2::LightSystemProgramCpi | +| constants::ADDRESS_TREE_V1 | constants::ADDRESS_TREE_V2 | +| .into_new_address_params_packed(seed) | .into_new_address_params_assigned_packed(seed, Some(0)) | +| .add_system_accounts(config) | .add_system_accounts_v2(config) | + +### Phase 4: TypeScript SDK replacements + +| v1 Pattern | v2 Replacement | +|------------|----------------| +| deriveAddress( | deriveAddressV2( | +| deriveAddressSeed( | deriveAddressSeedV2( | +| defaultTestStateTreeAccounts().addressTree | batchAddressTree | +| .newWithSystemAccounts( | .newWithSystemAccountsV2( | +| get_address_tree_v1() | get_address_tree_v2() | +| get_random_state_tree_info_v1() | get_random_state_tree_info() | + +### Phase 5: Build and test loop + +**Required commands (no shortcuts):** + +For Anchor programs: **anchor build && anchor test** + +For Native programs: **cargo build-sbf && cargo test-sbf** + +**NO shortcuts allowed:** + +- Do NOT use **cargo build** (must use **cargo build-sbf**) +- Do NOT use **cargo test** (must use **cargo test-sbf**) +- Tests MUST run against real BPF bytecode + +**On failure:** Spawn debugger agent with error context. + +**Loop rules:** + +1. Each debugger gets fresh context + previous debug reports +2. Each attempt tries something DIFFERENT +3. **NEVER GIVE UP** - keep spawning until fixed + +Do NOT proceed until all tests pass. + +## DeepWiki fallback + +If no matching pattern in reference repos: + + mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "How to migrate {pattern} from v1 to v2?")`} + + ~~~~text --- argument-hint: diff --git a/snippets/ai-prompts/wallets/privy.mdx b/snippets/ai-prompts/wallets/privy.mdx new file mode 100644 index 00000000..cf122f38 --- /dev/null +++ b/snippets/ai-prompts/wallets/privy.mdx @@ -0,0 +1,135 @@ + +{`--- +description: Integrate light-token with Privy embedded wallets +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Integrate light-token with Privy embedded wallets + +Context: +- Guide: https://zkcompression.com/light-token/toolkits/for-privy +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js +- Node.js example: https://github.com/Lightprotocol/examples-light-token/tree/main/privy/nodejs +- React example: https://github.com/Lightprotocol/examples-light-token/tree/main/privy/react + +SPL → Light Token API mapping: +| Operation | SPL | Light Token | +| Transfer | createTransferInstruction() | createTransferInterfaceInstructions() | +| Wrap SPL→Light | N/A | createWrapInstruction() | +| Unwrap Light→SPL | N/A | createUnwrapInstructions() | +| Get balance | getAccount() | getAtaInterface() | +| Tx history | getSignaturesForAddress() | getSignaturesForOwnerInterface() | + +### 1. Index project +- Grep \`privy|@privy-io|usePrivy|PrivyProvider|createTransferInstruction|@solana/spl-token|Connection\` across src/ +- Glob \`**/*.ts\` and \`**/*.tsx\` for project structure +- Identify: Privy SDK version, existing wallet setup, RPC config, token operations +- Check package.json for existing @lightprotocol/* or @solana/spl-token dependencies +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both Node.js and React code examples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: Node.js or React? +- AskUserQuestion: what is the goal? (new Privy integration, migrate existing Privy+SPL code, add light-token alongside existing SPL) +- AskUserQuestion: which operations? (transfer, wrap, unwrap, balances, tx history — or all) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Privy wallet setup is compatible (signTransaction or sendTransaction pattern) +- Key integration pattern: build unsigned tx with light-token SDK → sign with Privy → send to RPC +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash \`npm install @lightprotocol/compressed-token @lightprotocol/stateless.js\` +- Set up RPC: \`createRpc(RPC_ENDPOINT)\` with a ZK Compression endpoint (Helius, Triton) +- Import from \`@lightprotocol/compressed-token/unified\` for the interface APIs +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash \`tsc --noEmit\` +- Bash run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work`} + + +```text +--- +description: Integrate light-token with Privy embedded wallets +allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Task, TaskCreate, TaskGet, TaskList, TaskUpdate, TaskOutput, mcp__deepwiki, mcp__zkcompression +--- + +## Integrate light-token with Privy embedded wallets + +Context: +- Guide: https://zkcompression.com/light-token/toolkits/for-privy +- Skills and resources index: https://zkcompression.com/skill.md +- Packages: @lightprotocol/compressed-token, @lightprotocol/stateless.js +- Node.js example: https://github.com/Lightprotocol/examples-light-token/tree/main/privy/nodejs +- React example: https://github.com/Lightprotocol/examples-light-token/tree/main/privy/react + +SPL → Light Token API mapping: +| Operation | SPL | Light Token | +| Transfer | createTransferInstruction() | createTransferInterfaceInstructions() | +| Wrap SPL→Light | N/A | createWrapInstruction() | +| Unwrap Light→SPL | N/A | createUnwrapInstructions() | +| Get balance | getAccount() | getAtaInterface() | +| Tx history | getSignaturesForAddress() | getSignaturesForOwnerInterface() | + +### 1. Index project +- Grep `privy|@privy-io|usePrivy|PrivyProvider|createTransferInstruction|@solana/spl-token|Connection` across src/ +- Glob `**/*.ts` and `**/*.tsx` for project structure +- Identify: Privy SDK version, existing wallet setup, RPC config, token operations +- Check package.json for existing @lightprotocol/* or @solana/spl-token dependencies +- Task subagent (Grep/Read/WebFetch) if project has multiple packages to scan in parallel + +### 2. Read references +- WebFetch the guide above — review both Node.js and React code examples +- WebFetch skill.md — check for a dedicated skill and resources matching this task +- TaskCreate one todo per phase below to track progress + +### 3. Clarify intention +- AskUserQuestion: Node.js or React? +- AskUserQuestion: what is the goal? (new Privy integration, migrate existing Privy+SPL code, add light-token alongside existing SPL) +- AskUserQuestion: which operations? (transfer, wrap, unwrap, balances, tx history — or all) +- Summarize findings and wait for user confirmation before implementing + +### 4. Create plan +- Based on steps 1–3, draft an implementation plan: which files to modify, what code to add, dependency changes +- Verify existing Privy wallet setup is compatible (signTransaction or sendTransaction pattern) +- Key integration pattern: build unsigned tx with light-token SDK → sign with Privy → send to RPC +- If anything is unclear or ambiguous, loop back to step 3 (AskUserQuestion) +- Present the plan to the user for approval before proceeding + +### 5. Implement +- Add deps if missing: Bash `npm install @lightprotocol/compressed-token @lightprotocol/stateless.js` +- Set up RPC: `createRpc(RPC_ENDPOINT)` with a ZK Compression endpoint (Helius, Triton) +- Import from `@lightprotocol/compressed-token/unified` for the interface APIs +- Follow the guide and the approved plan +- Write/Edit to create or modify files +- TaskUpdate to mark each step done + +### 6. Verify +- Bash `tsc --noEmit` +- Bash run existing test suite if present +- TaskUpdate to mark complete + +### Tools +- mcp__zkcompression__SearchLightProtocol("") for API details +- mcp__deepwiki__ask_question("Lightprotocol/light-protocol", "") for architecture +- Task subagent with Grep/Read/WebFetch for parallel lookups +- TaskList to check remaining work +``` diff --git a/snippets/code-snippets/light-token/counter/anchor-macro/full-example.mdx b/snippets/code-snippets/light-token/counter/anchor-macro/full-example.mdx new file mode 100644 index 00000000..dd4680f2 --- /dev/null +++ b/snippets/code-snippets/light-token/counter/anchor-macro/full-example.mdx @@ -0,0 +1,266 @@ + + + +```rust lib.rs expandable +use anchor_lang::prelude::*; +use light_account::{ + CompressionInfo, LightAccount, LightAccounts, CreateAccountsProof, + derive_light_cpi_signer, light_program, CpiSigner, +}; + +declare_id!("YourProgramId11111111111111111111111111111111"); + +pub const LIGHT_CPI_SIGNER: CpiSigner = + derive_light_cpi_signer!("YourProgramId11111111111111111111111111111111"); + +pub const COUNTER_SEED: &[u8] = b"counter"; + +#[derive(Default, Debug, InitSpace, LightAccount)] +#[account] +pub struct Counter { + pub compression_info: CompressionInfo, + pub owner: Pubkey, + pub count: u64, +} + +#[derive(AnchorSerialize, AnchorDeserialize, Clone)] +pub struct CreateCounterParams { + pub create_accounts_proof: CreateAccountsProof, + pub count: u64, +} + +#[light_program] +#[program] +pub mod counter { + use super::*; + + pub fn create_counter<'info>( + ctx: Context<'_, '_, '_, 'info, CreateCounter<'info>>, + params: CreateCounterParams, + ) -> Result<()> { + ctx.accounts.counter.owner = ctx.accounts.owner.key(); + ctx.accounts.counter.count = params.count; + Ok(()) + } + + /// Standard Anchor — no Light-specific changes. + pub fn increment(ctx: Context) -> Result<()> { + ctx.accounts.counter.count = ctx.accounts.counter.count.checked_add(1).unwrap(); + Ok(()) + } + + /// Standard Anchor — no Light-specific changes. + pub fn close_counter(_ctx: Context) -> Result<()> { + Ok(()) + } +} + +#[derive(Accounts, LightAccounts)] +#[instruction(params: CreateCounterParams)] +pub struct CreateCounter<'info> { + #[account(mut)] + pub fee_payer: Signer<'info>, + + /// CHECK: Read-only, used for PDA derivation. + pub owner: AccountInfo<'info>, + + /// CHECK: Validated by Light Protocol CPI. + pub compression_config: AccountInfo<'info>, + + /// CHECK: PDA rent sponsor for compression rent reimbursement. + #[account(mut)] + pub pda_rent_sponsor: AccountInfo<'info>, + + #[account( + init, + payer = fee_payer, + space = 8 + ::INIT_SPACE, + seeds = [COUNTER_SEED, owner.key().as_ref()], + bump, + )] + #[light_account(init)] + pub counter: Account<'info, Counter>, + + pub system_program: Program<'info, System>, +} + +/// Standard Anchor +#[derive(Accounts)] +pub struct Increment<'info> { + pub owner: Signer<'info>, + + #[account( + mut, + seeds = [COUNTER_SEED, owner.key().as_ref()], + bump, + has_one = owner, + )] + pub counter: Account<'info, Counter>, +} + +/// Standard Anchor close +#[derive(Accounts)] +pub struct CloseCounter<'info> { + #[account(mut)] + pub fee_payer: Signer<'info>, + + pub owner: Signer<'info>, + + #[account( + mut, + close = fee_payer, + seeds = [COUNTER_SEED, owner.key().as_ref()], + bump, + has_one = owner, + )] + pub counter: Account<'info, Counter>, +} +``` + + + + +```rust counter.rs expandable +//! Light-PDA lifecycle test: create → increment → close. + +use anchor_lang::{InstructionData, ToAccountMetas}; +use light_client::interface::{ + get_create_accounts_proof, CreateAccountsProofInput, InitializeRentFreeConfig, +}; +use light_program_test::{ + program_test::{setup_mock_program_data, LightProgramTest}, + ProgramTestConfig, Rpc, +}; +use light_token::instruction::RENT_SPONSOR; +use solana_instruction::Instruction; +use solana_keypair::Keypair; +use solana_pubkey::Pubkey; +use solana_signer::Signer; + +const PROGRAM_ID: Pubkey = counter::ID; + +/// Setup: create test RPC and initialize rent-free config for the counter program. +async fn setup() -> (LightProgramTest, Keypair, Pubkey) { + let config = ProgramTestConfig::new_v2(true, Some(vec![("counter", PROGRAM_ID)])); + let mut rpc = LightProgramTest::new(config).await.unwrap(); + let payer = rpc.get_payer().insecure_clone(); + + let program_data_pda = setup_mock_program_data(&mut rpc, &payer, &PROGRAM_ID); + + // Register this program for rent-free accounts. One-time setup per program. + let (init_config_ix, compression_config) = InitializeRentFreeConfig::new( + &PROGRAM_ID, + &payer.pubkey(), + &program_data_pda, + RENT_SPONSOR, + payer.pubkey(), + ) + .build(); + + rpc.create_and_send_transaction(&[init_config_ix], &payer.pubkey(), &[&payer]) + .await + .expect("initialize rent-free config"); + + (rpc, payer, compression_config) +} + +#[tokio::test] +async fn test_counter_lifecycle() { + let (mut rpc, payer, compression_config) = setup().await; + + // ── Create ─────────────────────────────────────────────────────────── + let (counter_pda, _) = Pubkey::find_program_address( + &[counter::COUNTER_SEED, payer.pubkey().as_ref()], + &PROGRAM_ID, + ); + + let proof_result = get_create_accounts_proof( + &rpc, + &PROGRAM_ID, + vec![CreateAccountsProofInput::pda(counter_pda)], + ) + .await + .unwrap(); + + let create_accounts = counter::accounts::CreateCounter { + fee_payer: payer.pubkey(), + owner: payer.pubkey(), + compression_config, + counter: counter_pda, + system_program: solana_sdk::system_program::ID, + }; + + let create_data = counter::instruction::CreateCounter { + params: counter::CreateCounterParams { + create_accounts_proof: proof_result.create_accounts_proof, + count: 0, + }, + }; + + let create_ix = Instruction { + program_id: PROGRAM_ID, + accounts: [ + create_accounts.to_account_metas(None), + proof_result.remaining_accounts, + ] + .concat(), + data: create_data.data(), + }; + + rpc.create_and_send_transaction(&[create_ix], &payer.pubkey(), &[&payer]) + .await + .expect("create_counter"); + + // Verify initial state. + let account = rpc.get_account(counter_pda).await.unwrap().unwrap(); + let ctr: counter::Counter = + anchor_lang::AccountDeserialize::try_deserialize(&mut account.data.as_slice()).unwrap(); + assert_eq!(ctr.count, 0); + assert_eq!(ctr.owner, payer.pubkey()); + + // ── Increment (standard Anchor) ──────────────────────────── + let inc_accounts = counter::accounts::Increment { + owner: payer.pubkey(), + counter: counter_pda, + }; + let inc_data = counter::instruction::Increment {}; + let inc_ix = Instruction { + program_id: PROGRAM_ID, + accounts: inc_accounts.to_account_metas(None), + data: inc_data.data(), + }; + + rpc.create_and_send_transaction(&[inc_ix], &payer.pubkey(), &[&payer]) + .await + .expect("increment"); + + let account = rpc.get_account(counter_pda).await.unwrap().unwrap(); + let ctr: counter::Counter = + anchor_lang::AccountDeserialize::try_deserialize(&mut account.data.as_slice()).unwrap(); + assert_eq!(ctr.count, 1); + + // ── Close (standard Anchor) ──────────────────────────────── + let close_accounts = counter::accounts::CloseCounter { + fee_payer: payer.pubkey(), + owner: payer.pubkey(), + counter: counter_pda, + }; + let close_data = counter::instruction::CloseCounter {}; + let close_ix = Instruction { + program_id: PROGRAM_ID, + accounts: close_accounts.to_account_metas(None), + data: close_data.data(), + }; + + rpc.create_and_send_transaction(&[close_ix], &payer.pubkey(), &[&payer]) + .await + .expect("close_counter"); + + // Account should no longer exist. + let account = rpc.get_account(counter_pda).await.unwrap(); + assert!(account.is_none(), "counter should be closed"); +} +``` + + + diff --git a/snippets/code-snippets/light-token/mint-spl-and-wrap/action.mdx b/snippets/code-snippets/light-token/mint-spl-and-wrap/action.mdx new file mode 100644 index 00000000..c7912507 --- /dev/null +++ b/snippets/code-snippets/light-token/mint-spl-and-wrap/action.mdx @@ -0,0 +1,96 @@ +```typescript +import "dotenv/config"; +import { Keypair, PublicKey } from "@solana/web3.js"; +import { createRpc } from "@lightprotocol/stateless.js"; +import { + createMintInterface, + createAtaInterfaceIdempotent, + getAssociatedTokenAddressInterface, + wrap, + transferInterface, +} from "@lightprotocol/compressed-token"; +import { + TOKEN_2022_PROGRAM_ID, + createAssociatedTokenAccount, + mintTo, +} from "@solana/spl-token"; +import { homedir } from "os"; +import { readFileSync } from "fs"; + +// devnet: +const RPC_URL = `https://devnet.helius-rpc.com?api-key=${process.env.API_KEY!}`; +const rpc = createRpc(RPC_URL); +// localnet: +// const rpc = createRpc(); + +const payer = Keypair.fromSecretKey( + new Uint8Array( + JSON.parse(readFileSync(`${homedir()}/.config/solana/id.json`, "utf8")) + ) +); + +(async function () { + const decimals = 9; + const tokenAmount = BigInt(100 * Math.pow(10, decimals)); + const recipient = Keypair.generate(); + + // Creates on-chain SPL or Token-2022 mint and registers SPL interface PDA. + // SPL interface PDA enables wrap/unwrap between SPL/Token-2022 and Light Token. + const mintKeypair = Keypair.generate(); + const { mint } = await createMintInterface( + rpc, + payer, + payer, + null, + decimals, + mintKeypair, + undefined, + TOKEN_2022_PROGRAM_ID, + ); + + // 1. Mint SPL tokens to payer's associated token account + const payerSplAta = await createAssociatedTokenAccount( + rpc, + payer, + mint, + payer.publicKey, + undefined, + TOKEN_2022_PROGRAM_ID, + ); + await mintTo( + rpc, + payer, + mint, + payerSplAta, + payer, + tokenAmount, + [], + undefined, + TOKEN_2022_PROGRAM_ID, + ); + + // 2. Wrap SPL tokens into payer's light associated token account + await createAtaInterfaceIdempotent(rpc, payer, mint, payer.publicKey); + const payerLightAta = getAssociatedTokenAddressInterface(mint, payer.publicKey); + await wrap(rpc, payer, payerSplAta, payerLightAta, payer, mint, tokenAmount); + + // 3. Transfer to recipient's light associated token account + await createAtaInterfaceIdempotent(rpc, payer, mint, recipient.publicKey); + const recipientLightAta = getAssociatedTokenAddressInterface(mint, recipient.publicKey); + await transferInterface( + rpc, + payer, + payerLightAta, + mint, + recipientLightAta, + payer, + tokenAmount, + ); + + console.log("Transferred", 100, "tokens to", recipient.publicKey.toBase58()); +})(); +``` + + +Source: [mint-spl-and-wrap.ts](https://github.com/Lightprotocol/examples-light-token/blob/main/toolkits/sign-with-privy/scripts/src/mint-spl-and-wrap.ts) + diff --git a/snippets/code-snippets/light-token/transfer-interface/anchor-program/create-and-transfer-example.mdx b/snippets/code-snippets/light-token/transfer-interface/anchor-program/create-and-transfer-example.mdx new file mode 100644 index 00000000..868d48b6 --- /dev/null +++ b/snippets/code-snippets/light-token/transfer-interface/anchor-program/create-and-transfer-example.mdx @@ -0,0 +1,249 @@ + +```rust lib.rs +#![allow(unexpected_cfgs, deprecated)] + +use anchor_lang::prelude::*; +use light_sdk::interface::CreateAccountsProof; +use light_token::anchor::{derive_light_cpi_signer, light_program, CpiSigner, LightAccounts}; +use light_token::instruction::TransferInterfaceCpi; + +declare_id!("672fL1Nm191MbPoygNM9DRiG2psBELn97XUpGbU3jW7E"); + +pub const LIGHT_CPI_SIGNER: CpiSigner = + derive_light_cpi_signer!("672fL1Nm191MbPoygNM9DRiG2psBELn97XUpGbU3jW7E"); + +#[derive(AnchorSerialize, AnchorDeserialize, Clone)] +pub struct TransferParams { + pub create_accounts_proof: CreateAccountsProof, + pub dest_associated_token_account_bump: u8, + pub amount: u64, + pub decimals: u8, +} + +#[light_program] +#[program] +pub mod create_and_transfer { + use super::*; + + pub fn transfer<'info>( + ctx: Context<'_, '_, '_, 'info, Transfer<'info>>, + params: TransferParams, + ) -> Result<()> { + TransferInterfaceCpi::new( + params.amount, + params.decimals, + ctx.accounts.source.to_account_info(), + ctx.accounts.destination.to_account_info(), + ctx.accounts.authority.to_account_info(), + ctx.accounts.payer.to_account_info(), + ctx.accounts.light_token_cpi_authority.to_account_info(), + ctx.accounts.system_program.to_account_info(), + ) + .invoke() + .map_err(|e| anchor_lang::prelude::ProgramError::from(e))?; + Ok(()) + } +} + +#[derive(Accounts, LightAccounts)] +#[instruction(params: TransferParams)] +pub struct Transfer<'info> { + #[account(mut)] + pub payer: Signer<'info>, + + pub authority: Signer<'info>, + + /// CHECK: Validated by light-token CPI + pub mint: AccountInfo<'info>, + + /// CHECK: Validated by light-token CPI + #[account(mut)] + pub source: AccountInfo<'info>, + + /// CHECK: Validated by light-token CPI + pub recipient: AccountInfo<'info>, + + /// CHECK: Validated by light-token CPI + #[account(mut)] + #[light_account(init, + associated_token::authority = recipient, + associated_token::mint = mint, + associated_token::bump = params.dest_associated_token_account_bump + )] + pub destination: UncheckedAccount<'info>, + + /// CHECK: Validated by light-token CPI + pub light_token_program: AccountInfo<'info>, + + pub system_program: Program<'info, System>, + + /// CHECK: Validated by light-token CPI + pub light_token_compressible_config: AccountInfo<'info>, + + /// CHECK: Validated by light-token CPI + #[account(mut)] + pub rent_sponsor: AccountInfo<'info>, + + /// CHECK: Validated by light-token CPI + pub light_token_cpi_authority: AccountInfo<'info>, +} +``` + +```rust test.rs +use anchor_lang::{InstructionData, ToAccountMetas}; +use light_client::interface::{get_create_accounts_proof, InitializeRentFreeConfig}; +use light_program_test::{ + program_test::{setup_mock_program_data, LightProgramTest}, + Indexer, ProgramTestConfig, Rpc, +}; +use light_sdk_types::LIGHT_TOKEN_PROGRAM_ID; +use light_token::instruction::{ + derive_token_ata, find_mint_address, COMPRESSIBLE_CONFIG_V1, RENT_SPONSOR, +}; +use solana_instruction::Instruction; +use solana_keypair::Keypair; +use solana_signer::Signer; +use create_and_transfer::{TransferParams, ID}; + +#[tokio::test] +async fn test_transfer() { + let config = ProgramTestConfig::new_v2(true, Some(vec![("create_and_transfer", ID)])) + .with_light_protocol_events(); + + let mut rpc = LightProgramTest::new(config).await.unwrap(); + let payer = rpc.get_payer().insecure_clone(); + + let program_data_pda = setup_mock_program_data(&mut rpc, &payer, &ID); + + let (init_config_ix, _config_pda) = InitializeRentFreeConfig::new( + &ID, + &payer.pubkey(), + &program_data_pda, + RENT_SPONSOR, + payer.pubkey(), + ) + .build(); + + rpc.create_and_send_transaction(&[init_config_ix], &payer.pubkey(), &[&payer]) + .await + .unwrap(); + + let (mint_pda, _mint_seed) = setup_create_mint( + &mut rpc, + &payer, + payer.pubkey(), // mint_authority + 9, // decimals + ) + .await; + + println!("Mint created at: {}", mint_pda); + + let sender = Keypair::new(); + let (sender_associated_token_account, _sender_associated_token_account_bump) = + derive_token_ata(&sender.pubkey(), &mint_pda); + + let create_sender_associated_token_account_ix = + light_token::instruction::CreateAssociatedTokenAccount::new( + payer.pubkey(), + sender.pubkey(), + mint_pda, + ) + .instruction() + .unwrap(); + + rpc.create_and_send_transaction( + &[create_sender_associated_token_account_ix], + &payer.pubkey(), + &[&payer], + ) + .await + .unwrap(); + + let mint_amount: u64 = 1_000_000_000; + mint_tokens(&mut rpc, &payer, mint_pda, sender_associated_token_account, mint_amount).await; + + println!( + "Minted {} tokens to sender: {}", + mint_amount, sender_associated_token_account + ); + + let recipient = Keypair::new(); + let (recipient_associated_token_account, recipient_associated_token_account_bump) = + derive_token_ata(&recipient.pubkey(), &mint_pda); + + let transfer_proof_result = get_create_accounts_proof(&rpc, &ID, vec![]).await.unwrap(); + + let transfer_accounts = create_and_transfer::accounts::Transfer { + payer: payer.pubkey(), + authority: sender.pubkey(), + mint: mint_pda, + source: sender_associated_token_account, + recipient: recipient.pubkey(), + destination: recipient_associated_token_account, + light_token_program: LIGHT_TOKEN_PROGRAM_ID.into(), + system_program: solana_sdk::system_program::ID, + light_token_compressible_config: COMPRESSIBLE_CONFIG_V1, + rent_sponsor: RENT_SPONSOR, + light_token_cpi_authority: light_token_types::CPI_AUTHORITY_PDA.into(), + }; + + let transfer_amount: u64 = 500_000_000; // 0.5 tokens + let decimals: u8 = 9; + + let transfer_ix = Instruction { + program_id: ID, + accounts: [ + transfer_accounts.to_account_metas(None), + transfer_proof_result.remaining_accounts, + ] + .concat(), + data: create_and_transfer::instruction::Transfer { + params: TransferParams { + create_accounts_proof: transfer_proof_result.create_accounts_proof, + dest_associated_token_account_bump: recipient_associated_token_account_bump, + amount: transfer_amount, + decimals, + }, + } + .data(), + }; + + let sig = rpc + .create_and_send_transaction(&[transfer_ix], &payer.pubkey(), &[&payer, &sender]) + .await + .unwrap(); + + println!("Transfer Tx: {}", sig); + + use light_token_interface::state::Token; + + let recipient_account = rpc + .get_account(recipient_associated_token_account) + .await + .unwrap() + .unwrap(); + let recipient_token: Token = + borsh::BorshDeserialize::deserialize(&mut &recipient_account.data[..]).unwrap(); + + assert_eq!(recipient_token.amount, transfer_amount); + assert_eq!(recipient_token.owner, recipient.pubkey().to_bytes()); + + println!( + "Recipient balance: {}, owner: {}", + recipient_token.amount, + recipient.pubkey() + ); + + let sender_account = rpc + .get_account(sender_associated_token_account) + .await + .unwrap() + .unwrap(); + let sender_token: Token = + borsh::BorshDeserialize::deserialize(&mut &sender_account.data[..]).unwrap(); + + assert_eq!(sender_token.amount, mint_amount - transfer_amount); + println!("Sender remaining balance: {}", sender_token.amount); +} +``` + \ No newline at end of file diff --git a/snippets/code-snippets/privy/balances/nodejs.mdx b/snippets/code-snippets/privy/balances/nodejs.mdx index ebf6e51d..7322f3fc 100644 --- a/snippets/code-snippets/privy/balances/nodejs.mdx +++ b/snippets/code-snippets/privy/balances/nodejs.mdx @@ -1,38 +1,141 @@ ```typescript -import {PublicKey} from '@solana/web3.js'; +import 'dotenv/config'; +import {PublicKey, LAMPORTS_PER_SOL} from '@solana/web3.js'; +import {TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID} from '@solana/spl-token'; import {createRpc} from '@lightprotocol/stateless.js'; -import {HELIUS_RPC_URL} from './config.js'; +import { + getAtaInterface, + getAssociatedTokenAddressInterface, +} from '@lightprotocol/compressed-token/unified'; -export async function getCompressedBalances(ownerAddress: string) { - const rpc = createRpc(HELIUS_RPC_URL); +interface TokenBalance { + mint: string; + decimals: number; + hot: number; + cold: number; + spl: number; + t22: number; + unified: number; +} + +interface BalanceBreakdown { + sol: number; + tokens: TokenBalance[]; +} + +export async function getBalances( + ownerAddress: string, +): Promise { + const rpc = createRpc(process.env.HELIUS_RPC_URL!); const owner = new PublicKey(ownerAddress); - // Get compressed SOL balance - const compressedSol = await rpc.getCompressedBalanceByOwner(owner); - const compressedSolLamports = compressedSol.value ? BigInt(compressedSol.value.toString()) : 0n; - - // Get compressed token accounts (filter out null items from indexer) - const compressedAccounts = await rpc.getCompressedTokenAccountsByOwner(owner); - const validItems = (compressedAccounts.items || []).filter((item): item is NonNullable => item !== null); - - // Aggregate balances by mint - const balances = new Map(); - for (const account of validItems) { - if (account.parsed) { - const mint = account.parsed.mint.toBase58(); - const amount = BigInt(account.parsed.amount.toString()); - const current = balances.get(mint) || 0n; - balances.set(mint, current + amount); - } + // SOL balance + let solLamports = 0; + try { + solLamports = await rpc.getBalance(owner); + } catch (e) { + console.error('Failed to fetch SOL balance:', e); } - return { - sol: compressedSolLamports.toString(), - tokens: Array.from(balances.entries()).map(([mint, amount]) => ({ - mint, - amount: amount.toString(), - accounts: validItems.filter(a => a.parsed?.mint.toBase58() === mint).length - })) + // Per-mint accumulator + const mintMap = new Map(); + + const getOrCreate = (mintStr: string) => { + let entry = mintMap.get(mintStr); + if (!entry) { + entry = {spl: 0, t22: 0, hot: 0, cold: 0, decimals: 9}; + mintMap.set(mintStr, entry); + } + return entry; }; + + // 1. SPL accounts + try { + const splAccounts = await rpc.getTokenAccountsByOwner(owner, { + programId: TOKEN_PROGRAM_ID, + }); + for (const {account} of splAccounts.value) { + const buf = toBuffer(account.data); + if (!buf || buf.length < 72) continue; + const mint = new PublicKey(buf.subarray(0, 32)); + const amount = buf.readBigUInt64LE(64); + const mintStr = mint.toBase58(); + getOrCreate(mintStr).spl += toUiAmount(amount, 9); + } + } catch { + // No SPL accounts + } + + // 2. Token 2022 accounts + try { + const t22Accounts = await rpc.getTokenAccountsByOwner(owner, { + programId: TOKEN_2022_PROGRAM_ID, + }); + for (const {account} of t22Accounts.value) { + const buf = toBuffer(account.data); + if (!buf || buf.length < 72) continue; + const mint = new PublicKey(buf.subarray(0, 32)); + const amount = buf.readBigUInt64LE(64); + const mintStr = mint.toBase58(); + getOrCreate(mintStr).t22 += toUiAmount(amount, 9); + } + } catch { + // No Token 2022 accounts + } + + // 3. Hot balance from Light Token associated token account + const mintKeys = [...mintMap.keys()]; + await Promise.allSettled( + mintKeys.map(async (mintStr) => { + try { + const mint = new PublicKey(mintStr); + const ata = getAssociatedTokenAddressInterface(mint, owner); + const {parsed} = await getAtaInterface(rpc, ata, owner, mint); + getOrCreate(mintStr).hot = toUiAmount(parsed.amount, 9); + } catch { + // Associated token account does not exist for this mint + } + }), + ); + + // 4. Cold balance from compressed token accounts + try { + const compressed = await rpc.getCompressedTokenBalancesByOwnerV2(owner); + for (const item of compressed.value.items) { + const mintStr = item.mint.toBase58(); + getOrCreate(mintStr).cold += toUiAmount(BigInt(item.balance.toString()), 9); + } + } catch { + // No compressed accounts + } + + // Assemble result + const tokens: TokenBalance[] = []; + for (const [mintStr, entry] of mintMap) { + tokens.push({ + mint: mintStr, + decimals: entry.decimals, + hot: entry.hot, + cold: entry.cold, + spl: entry.spl, + t22: entry.t22, + unified: entry.hot + entry.cold, + }); + } + + return {sol: solLamports / LAMPORTS_PER_SOL, tokens}; +} + +function toBuffer(data: Buffer | Uint8Array | string | unknown): Buffer | null { + if (data instanceof Buffer) return data; + if (data instanceof Uint8Array) return Buffer.from(data); + return null; } + +function toUiAmount(raw: bigint | {toNumber: () => number}, decimals: number): number { + const value = typeof raw === 'bigint' ? Number(raw) : raw.toNumber(); + return value / 10 ** decimals; +} + +export default getBalances; ``` diff --git a/snippets/code-snippets/privy/balances/react.mdx b/snippets/code-snippets/privy/balances/react.mdx index cd6310f8..8792502e 100644 --- a/snippets/code-snippets/privy/balances/react.mdx +++ b/snippets/code-snippets/privy/balances/react.mdx @@ -1,21 +1,25 @@ ```typescript import { useState, useCallback } from 'react'; import { PublicKey, LAMPORTS_PER_SOL } from '@solana/web3.js'; -import { getAccount, getAssociatedTokenAddressSync } from '@solana/spl-token'; +import { TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID } from '@solana/spl-token'; import { createRpc } from '@lightprotocol/stateless.js'; - -const USDC_MINT = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'; -const TEST_MINT = '7cT3PeXyDLkyEcvr9YzsjGLuZneKsea4c8hPbJQEjMCZ'; +import { + getAssociatedTokenAddressInterface, + getAtaInterface, +} from '@lightprotocol/compressed-token/unified'; export interface TokenBalance { mint: string; - amount: string; decimals: number; - isCompressed: boolean; isNative: boolean; + hot: bigint; + cold: bigint; + spl: bigint; + t22: bigint; + unified: bigint; } -export function useCompressedBalances() { +export function useUnifiedBalance() { const [balances, setBalances] = useState([]); const [isLoading, setIsLoading] = useState(false); @@ -26,141 +30,118 @@ export function useCompressedBalances() { try { const rpc = createRpc(import.meta.env.VITE_HELIUS_RPC_URL); const owner = new PublicKey(ownerAddress); - const allBalances: TokenBalance[] = []; - // Get compressed SOL balance - try { - const compressedSol = await rpc.getCompressedBalanceByOwner(owner); - if (compressedSol && BigInt(compressedSol.toString()) > 0n) { - allBalances.push({ - mint: 'So11111111111111111111111111111111111111112', - amount: compressedSol.toString(), - decimals: 9, - isCompressed: true, - isNative: true, - }); + // Per-mint accumulator + const mintMap = new Map(); + + const getOrCreate = (mintStr: string) => { + let entry = mintMap.get(mintStr); + if (!entry) { + entry = { spl: 0n, t22: 0n, hot: 0n, cold: 0n, decimals: 9 }; + mintMap.set(mintStr, entry); } + return entry; + }; + + // 1. SOL balance + let solLamports = 0; + try { + solLamports = await rpc.getBalance(owner); } catch { - // No compressed SOL + // Failed to fetch SOL balance } - // Get regular SOL balance + // 2. SPL accounts try { - const solBalance = await rpc.getBalance(owner); - allBalances.push({ - mint: 'So11111111111111111111111111111111111111112', - amount: solBalance.toString(), - decimals: 9, - isCompressed: false, - isNative: true, + const splAccounts = await rpc.getTokenAccountsByOwner(owner, { + programId: TOKEN_PROGRAM_ID, }); + for (const { account } of splAccounts.value) { + const buf = toBuffer(account.data); + if (!buf || buf.length < 72) continue; + const mint = new PublicKey(buf.subarray(0, 32)); + const amount = buf.readBigUInt64LE(64); + const mintStr = mint.toBase58(); + getOrCreate(mintStr).spl += amount; + } } catch { - // Failed to get SOL balance + // No SPL accounts } - // Get regular SPL token accounts + // 3. Token 2022 accounts try { - const tokenAccounts = await rpc.getTokenAccountsByOwner(owner, { - programId: new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'), + const t22Accounts = await rpc.getTokenAccountsByOwner(owner, { + programId: TOKEN_2022_PROGRAM_ID, }); - - for (const { account, pubkey } of tokenAccounts.value) { - const data = account.data; - if (data instanceof Buffer || (typeof data === 'object' && 'length' in data)) { - // Parse token account data - const dataBuffer = Buffer.from(data as Uint8Array); - if (dataBuffer.length >= 72) { - const mint = new PublicKey(dataBuffer.subarray(0, 32)); - const amount = dataBuffer.readBigUInt64LE(64); - - // Get mint info for decimals - try { - const mintInfo = await rpc.getAccountInfo(mint); - const decimals = mintInfo?.data ? (mintInfo.data as Buffer)[44] || 6 : 6; - - allBalances.push({ - mint: mint.toBase58(), - amount: amount.toString(), - decimals, - isCompressed: false, - isNative: false, - }); - } catch { - allBalances.push({ - mint: mint.toBase58(), - amount: amount.toString(), - decimals: 6, - isCompressed: false, - isNative: false, - }); - } - } - } + for (const { account } of t22Accounts.value) { + const buf = toBuffer(account.data); + if (!buf || buf.length < 72) continue; + const mint = new PublicKey(buf.subarray(0, 32)); + const amount = buf.readBigUInt64LE(64); + const mintStr = mint.toBase58(); + getOrCreate(mintStr).t22 += amount; } } catch { - // Failed to get token accounts + // No Token 2022 accounts } - // Get compressed token accounts - try { - const compressedAccounts = await rpc.getCompressedTokenAccountsByOwner(owner); - - if (compressedAccounts?.items) { - const mintAmounts = new Map(); - const mintDecimals = new Map(); - - for (const item of compressedAccounts.items) { - if (item?.parsed?.mint && item?.parsed?.amount) { - const mint = item.parsed.mint.toBase58(); - const amount = BigInt(item.parsed.amount.toString()); - const current = mintAmounts.get(mint) || 0n; - mintAmounts.set(mint, current + amount); - - // Store decimals (assume 6 for now, could fetch from mint) - if (!mintDecimals.has(mint)) { - mintDecimals.set(mint, 6); - } - } + // 4. Hot balance from Light Token associated token account + const mintKeys = [...mintMap.keys()]; + await Promise.allSettled( + mintKeys.map(async (mintStr) => { + try { + const mint = new PublicKey(mintStr); + const ata = getAssociatedTokenAddressInterface(mint, owner); + const { parsed } = await getAtaInterface(rpc, ata, owner, mint); + const entry = getOrCreate(mintStr); + entry.hot = BigInt(parsed.amount.toString()); + } catch { + // Associated token account does not exist for this mint — hot stays 0n } + }), + ); - for (const [mint, amount] of mintAmounts) { - allBalances.push({ - mint, - amount: amount.toString(), - decimals: mintDecimals.get(mint) || 6, - isCompressed: true, - isNative: false, - }); - } + // 5. Cold balance from compressed token accounts + try { + const compressed = await rpc.getCompressedTokenBalancesByOwnerV2(owner); + for (const item of compressed.value.items) { + const mintStr = item.mint.toBase58(); + getOrCreate(mintStr).cold += BigInt(item.balance.toString()); } } catch { - // Failed to get compressed accounts + // No compressed accounts } - // Add fallback tokens with 0 balance if not present - const hasMint = (mint: string) => allBalances.some(b => b.mint === mint); - - if (!hasMint(USDC_MINT)) { - allBalances.push({ - mint: USDC_MINT, - amount: '0', - decimals: 6, - isCompressed: false, + // 6. Assemble TokenBalance[] + const result: TokenBalance[] = []; + + // SOL entry + result.push({ + mint: 'So11111111111111111111111111111111111111112', + decimals: 9, + isNative: true, + hot: 0n, + cold: 0n, + spl: BigInt(solLamports), + t22: 0n, + unified: 0n, + }); + + // Token entries + for (const [mintStr, entry] of mintMap) { + result.push({ + mint: mintStr, + decimals: entry.decimals, isNative: false, + hot: entry.hot, + cold: entry.cold, + spl: entry.spl, + t22: entry.t22, + unified: entry.hot + entry.cold, }); } - if (!hasMint(TEST_MINT)) { - allBalances.push({ - mint: TEST_MINT, - amount: '0', - decimals: 6, - isCompressed: false, - isNative: false, - }); - } - - setBalances(allBalances); + setBalances(result); } catch (error) { console.error('Failed to fetch balances:', error); setBalances([]); @@ -171,4 +152,10 @@ export function useCompressedBalances() { return { balances, isLoading, fetchBalances }; } + +function toBuffer(data: Buffer | Uint8Array | string | unknown): Buffer | null { + if (data instanceof Buffer) return data; + if (data instanceof Uint8Array) return Buffer.from(data); + return null; +} ``` diff --git a/snippets/code-snippets/privy/compress/nodejs.mdx b/snippets/code-snippets/privy/compress/nodejs.mdx deleted file mode 100644 index 41e41a3f..00000000 --- a/snippets/code-snippets/privy/compress/nodejs.mdx +++ /dev/null @@ -1,89 +0,0 @@ -```typescript -import 'dotenv/config'; -import {PrivyClient} from '@privy-io/node'; -import {createRpc, bn, selectStateTreeInfo} from '@lightprotocol/stateless.js'; -import {PublicKey, Transaction, ComputeBudgetProgram} from '@solana/web3.js'; -import {getAssociatedTokenAddressSync, getAccount} from '@solana/spl-token'; -import {LightTokenProgram, getTokenPoolInfos, selectTokenPoolInfo} from '@lightprotocol/compressed-token'; - -const compressTokens = async ( - fromAddress: string, - toAddress: string, - tokenMintAddress: string, - amount: number, - decimals: number = 6 -) => { - const connection = createRpc(process.env.HELIUS_RPC_URL!); - - const privy = new PrivyClient({ - appId: process.env.PRIVY_APP_ID!, - appSecret: process.env.PRIVY_APP_SECRET!, - }); - - // Create public key objects - const fromPubkey = new PublicKey(fromAddress); - const toPubkey = new PublicKey(toAddress); - const mintPubkey = new PublicKey(tokenMintAddress); - const tokenAmount = bn(amount * Math.pow(10, decimals)); - - // Get source token account and verify balance - const ownerAta = getAssociatedTokenAddressSync(mintPubkey, fromPubkey); - const ataAccount = await getAccount(connection, ownerAta); - if (ataAccount.amount < BigInt(tokenAmount.toString())) { - throw new Error('Insufficient SPL balance'); - } - - // Get state tree to store compressed tokens - // Get SPL interface info. SPL tokens are stored in the interface PDA when compressed. - const stateTreeInfos = await connection.getStateTreeInfos(); - const selectedTreeInfo = selectStateTreeInfo(stateTreeInfos); - const tokenPoolInfos = await getTokenPoolInfos(connection, mintPubkey); - const tokenPoolInfo = selectTokenPoolInfo(tokenPoolInfos); - - // Create compress instruction - const instruction = await LightTokenProgram.compress({ - payer: fromPubkey, - owner: fromPubkey, - source: ownerAta, - toAddress: toPubkey, - mint: mintPubkey, - amount: tokenAmount, - outputStateTreeInfo: selectedTreeInfo, - tokenPoolInfo, - }); - - // Create transaction - const transaction = new Transaction(); - transaction.add(ComputeBudgetProgram.setComputeUnitLimit({units: 300_000})); - transaction.add(instruction); - - // Get recent blockhash - const {blockhash} = await connection.getLatestBlockhash(); - transaction.recentBlockhash = blockhash; - transaction.feePayer = fromPubkey; - - // Sign with Privy - const signResult = await privy.wallets().solana().signTransaction(process.env.TREASURY_WALLET_ID!, { - transaction: transaction.serialize({requireAllSignatures: false}), - authorization_context: { - authorization_private_keys: [process.env.TREASURY_AUTHORIZATION_KEY!] - } - }); - const signedTx = (signResult as any).signed_transaction || signResult.signedTransaction; - if (!signedTx) { - throw new Error('Privy returned invalid response: ' + JSON.stringify(signResult)); - } - const signedTransaction = Buffer.from(signedTx, 'base64'); - - // Send transaction - const signature = await connection.sendRawTransaction(signedTransaction, { - skipPreflight: false, - preflightCommitment: 'confirmed' - }); - await connection.confirmTransaction(signature, 'confirmed'); - - return signature; -}; - -export default compressTokens; -``` diff --git a/snippets/code-snippets/privy/compress/react.mdx b/snippets/code-snippets/privy/compress/react.mdx deleted file mode 100644 index 5adfc1e4..00000000 --- a/snippets/code-snippets/privy/compress/react.mdx +++ /dev/null @@ -1,106 +0,0 @@ -```typescript -import { useState } from 'react'; -import { PublicKey, Transaction, ComputeBudgetProgram } from '@solana/web3.js'; -import { getAssociatedTokenAddressSync, getAccount } from '@solana/spl-token'; -import { bn, createRpc, selectStateTreeInfo } from '@lightprotocol/stateless.js'; -import { LightTokenProgram, getTokenPoolInfos, selectTokenPoolInfo } from '@lightprotocol/compressed-token'; -import type { ConnectedStandardSolanaWallet } from '@privy-io/js-sdk-core'; -import type { SignTransactionResult } from '@privy-io/react-auth/solana'; - -export interface CompressParams { - ownerPublicKey: string; - toAddress: string; - mint: string; - amount: number; - decimals?: number; -} - -export interface CompressArgs { - params: CompressParams; - wallet: ConnectedStandardSolanaWallet; - signTransaction: (args: { - transaction: Buffer; - wallet: ConnectedStandardSolanaWallet; - chain: string; - }) => Promise; -} - -export function useCompress() { - const [isLoading, setIsLoading] = useState(false); - - const compress = async (args: CompressArgs): Promise => { - setIsLoading(true); - - try { - const { params, wallet, signTransaction } = args; - const { ownerPublicKey, toAddress, mint, amount, decimals = 6 } = params; - - // Create RPC connection - const rpc = createRpc(import.meta.env.VITE_HELIUS_RPC_URL); - - // Create public key objects - const ownerPubkey = new PublicKey(ownerPublicKey); - const toPubkey = new PublicKey(toAddress); - const mintPubkey = new PublicKey(mint); - const tokenAmount = bn(amount * Math.pow(10, decimals)); - - // Get source token account and verify balance - const ownerAta = getAssociatedTokenAddressSync(mintPubkey, ownerPubkey); - const ataAccount = await getAccount(rpc, ownerAta); - if (ataAccount.amount < BigInt(tokenAmount.toString())) { - throw new Error('Insufficient SPL balance'); - } - - // Get state tree to store compressed tokens - // Get SPL interface info. SPL tokens are stored in the interface PDA when compressed. - const stateTreeInfos = await rpc.getStateTreeInfos(); - const selectedTreeInfo = selectStateTreeInfo(stateTreeInfos); - const tokenPoolInfos = await getTokenPoolInfos(rpc, mintPubkey); - const tokenPoolInfo = selectTokenPoolInfo(tokenPoolInfos); - - // Create compress instruction - const instruction = await LightTokenProgram.compress({ - payer: ownerPubkey, - owner: ownerPubkey, - source: ownerAta, - toAddress: toPubkey, - mint: mintPubkey, - amount: tokenAmount, - outputStateTreeInfo: selectedTreeInfo, - tokenPoolInfo, - }); - - // Build transaction - const { blockhash } = await rpc.getLatestBlockhash(); - const transaction = new Transaction(); - transaction.add(ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 })); - transaction.add(instruction); - transaction.recentBlockhash = blockhash; - transaction.feePayer = ownerPubkey; - - // Serialize unsigned transaction - const unsignedTxBuffer = transaction.serialize({ requireAllSignatures: false }); - - // Sign with Privy - const signedTx = await signTransaction({ - transaction: unsignedTxBuffer, - wallet, - chain: 'solana:devnet', - }); - - // Send transaction - const signedTxBuffer = Buffer.from(signedTx.signedTransaction); - const signature = await rpc.sendRawTransaction(signedTxBuffer, { - skipPreflight: false, - preflightCommitment: 'confirmed', - }); - - return signature; - } finally { - setIsLoading(false); - } - }; - - return { compress, isLoading }; -} -``` diff --git a/snippets/code-snippets/privy/decompress/nodejs.mdx b/snippets/code-snippets/privy/decompress/nodejs.mdx deleted file mode 100644 index 6f722014..00000000 --- a/snippets/code-snippets/privy/decompress/nodejs.mdx +++ /dev/null @@ -1,81 +0,0 @@ -```typescript -import 'dotenv/config'; -import {PrivyClient} from '@privy-io/node'; -import {createRpc} from '@lightprotocol/stateless.js'; -import {Keypair, PublicKey, Transaction} from '@solana/web3.js'; -import {getAssociatedTokenAddressSync, createAssociatedTokenAccount} from '@solana/spl-token'; -import {decompress} from '@lightprotocol/compressed-token'; - -const decompressTokens = async ( - fromAddress: string, - tokenMintAddress: string, - amount: number, - decimals: number = 6 -) => { - const connection = createRpc(process.env.HELIUS_RPC_URL!); - - const privy = new PrivyClient({ - appId: process.env.PRIVY_APP_ID!, - appSecret: process.env.PRIVY_APP_SECRET!, - }); - - const fromPubkey = new PublicKey(fromAddress); - const mintPubkey = new PublicKey(tokenMintAddress); - const rawAmount = amount * Math.pow(10, decimals); - - // Get destination ATA - const ownerAta = getAssociatedTokenAddressSync(mintPubkey, fromPubkey); - - // Check ATA exists (decompress action will handle creation internally) - // But we need to be aware ATA creation requires a separate signer - - // Create fake keypair for decompress action (only publicKey is used) - const dummyPayer = { - publicKey: fromPubkey, - secretKey: new Uint8Array(64), - } as any; - - // Intercept sendAndConfirmTransaction to use Privy signing - const originalSendAndConfirm = (connection as any).sendAndConfirmTransaction; - (connection as any).sendAndConfirmTransaction = async (tx: Transaction, signers: any[]) => { - const signResult = await privy.wallets().solana().signTransaction(process.env.TREASURY_WALLET_ID!, { - transaction: tx.serialize({requireAllSignatures: false}), - authorization_context: { - authorization_private_keys: [process.env.TREASURY_AUTHORIZATION_KEY!] - } - }); - - const signedTx = (signResult as any).signed_transaction || signResult.signedTransaction; - if (!signedTx) { - throw new Error('Privy returned invalid response'); - } - - const signedTransaction = Buffer.from(signedTx, 'base64'); - const signature = await connection.sendRawTransaction(signedTransaction, { - skipPreflight: false, - preflightCommitment: 'confirmed' - }); - await connection.confirmTransaction(signature, 'confirmed'); - return signature; - }; - - try { - // Use high-level decompress action (handles account configuration correctly) - const signature = await decompress( - connection, - dummyPayer, - mintPubkey, - rawAmount, - dummyPayer, - ownerAta - ); - - return signature; - } finally { - // Restore original function - (connection as any).sendAndConfirmTransaction = originalSendAndConfirm; - } -}; - -export default decompressTokens; -``` diff --git a/snippets/code-snippets/privy/decompress/react.mdx b/snippets/code-snippets/privy/decompress/react.mdx deleted file mode 100644 index 193761e8..00000000 --- a/snippets/code-snippets/privy/decompress/react.mdx +++ /dev/null @@ -1,124 +0,0 @@ -```typescript -import { useState } from 'react'; -import { PublicKey, Transaction, ComputeBudgetProgram } from '@solana/web3.js'; -import { getAssociatedTokenAddressSync, createAssociatedTokenAccountInstruction, getAccount, TokenAccountNotFoundError } from '@solana/spl-token'; -import { LightTokenProgram, selectMinCompressedTokenAccountsForTransfer, getSplInterfaceInfos, selectSplInterfaceInfosForDecompression } from '@lightprotocol/compressed-token'; -import { bn, createRpc } from '@lightprotocol/stateless.js'; -import type { ConnectedStandardSolanaWallet } from '@privy-io/js-sdk-core'; -import type { SignTransactionResult } from '@privy-io/react-auth/solana'; - -export interface DecompressParams { - ownerPublicKey: string; - mint: string; - amount: number; - decimals?: number; -} - -export interface DecompressArgs { - params: DecompressParams; - wallet: ConnectedStandardSolanaWallet; - signTransaction: (args: { - transaction: Buffer; - wallet: ConnectedStandardSolanaWallet; - chain: string; - }) => Promise; -} - -export function useDecompress() { - const [isLoading, setIsLoading] = useState(false); - - const decompress = async (args: DecompressArgs): Promise => { - setIsLoading(true); - - try { - const { params, wallet, signTransaction } = args; - const { ownerPublicKey, mint, amount, decimals = 6 } = params; - - // Create RPC connection - const rpc = createRpc(import.meta.env.VITE_HELIUS_RPC_URL); - - const owner = new PublicKey(ownerPublicKey); - const mintPubkey = new PublicKey(mint); - const tokenAmount = bn(Math.floor(amount * Math.pow(10, decimals))); - - // Get destination ATA - const destinationAta = getAssociatedTokenAddressSync(mintPubkey, owner); - - // Get compressed token accounts - const accounts = await rpc.getCompressedTokenAccountsByOwner(owner, { mint: mintPubkey }); - if (!accounts.items || accounts.items.length === 0) { - throw new Error('No compressed token accounts found'); - } - - // Select minimum accounts needed - const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer(accounts.items, tokenAmount); - if (inputAccounts.length === 0) { - throw new Error('Insufficient compressed balance'); - } - - // Get validity proof and SPL interface info - const proof = await rpc.getValidityProof( - inputAccounts.map((account) => bn(account.compressedAccount.hash)) - ); - const splInterfaceInfos = await getSplInterfaceInfos(rpc, mintPubkey); - const tokenPoolInfos = selectSplInterfaceInfosForDecompression(splInterfaceInfos, tokenAmount); - - // Build transaction - const { blockhash } = await rpc.getLatestBlockhash(); - const transaction = new Transaction(); - transaction.add(ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 })); - - // Create ATA if needed - try { - await getAccount(rpc, destinationAta); - } catch (e) { - if (e instanceof TokenAccountNotFoundError) { - transaction.add( - createAssociatedTokenAccountInstruction(owner, destinationAta, owner, mintPubkey) - ); - } else { - throw e; - } - } - - // Build decompress instruction - const decompressIx = await LightTokenProgram.decompress({ - payer: owner, - inputCompressedTokenAccounts: inputAccounts, - toAddress: destinationAta, - amount: tokenAmount, - recentInputStateRootIndices: proof.rootIndices, - recentValidityProof: proof.compressedProof, - tokenPoolInfos, - }); - - transaction.add(decompressIx); - transaction.recentBlockhash = blockhash; - transaction.feePayer = owner; - - // Serialize unsigned transaction - const unsignedTxBuffer = transaction.serialize({ requireAllSignatures: false }); - - // Sign with Privy - const signedTx = await signTransaction({ - transaction: unsignedTxBuffer, - wallet, - chain: 'solana:devnet', - }); - - // Send transaction - const signedTxBuffer = Buffer.from(signedTx.signedTransaction); - const signature = await rpc.sendRawTransaction(signedTxBuffer, { - skipPreflight: false, - preflightCommitment: 'confirmed', - }); - - return signature; - } finally { - setIsLoading(false); - } - }; - - return { decompress, isLoading }; -} -``` diff --git a/snippets/code-snippets/privy/helpers/sign-and-send-batches.mdx b/snippets/code-snippets/privy/helpers/sign-and-send-batches.mdx new file mode 100644 index 00000000..082607d7 --- /dev/null +++ b/snippets/code-snippets/privy/helpers/sign-and-send-batches.mdx @@ -0,0 +1,46 @@ +```typescript +import { Transaction, TransactionInstruction, PublicKey } from '@solana/web3.js'; +import type { ConnectedStandardSolanaWallet } from '@privy-io/js-sdk-core'; +import { useSignTransaction } from '@privy-io/react-auth/solana'; + +type SignTransactionFn = ReturnType['signTransaction']; + +interface SignAndSendOptions { + rpc: any; + feePayer: PublicKey; + wallet: ConnectedStandardSolanaWallet; + signTransaction: SignTransactionFn; +} + +export async function signAndSendBatches( + instructionBatches: TransactionInstruction[][], + options: SignAndSendOptions, +): Promise { + const { rpc, feePayer, wallet, signTransaction } = options; + const signatures: string[] = []; + + for (const ixs of instructionBatches) { + const tx = new Transaction().add(...ixs); + const { blockhash } = await rpc.getLatestBlockhash(); + tx.recentBlockhash = blockhash; + tx.feePayer = feePayer; + + const unsignedTxBuffer = tx.serialize({ requireAllSignatures: false }); + const signedTx = await signTransaction({ + transaction: unsignedTxBuffer, + wallet, + chain: 'solana:devnet', + }); + + const signedTxBuffer = Buffer.from(signedTx.signedTransaction); + const sig = await rpc.sendRawTransaction(signedTxBuffer, { + skipPreflight: false, + preflightCommitment: 'confirmed', + }); + await rpc.confirmTransaction(sig, 'confirmed'); + signatures.push(sig); + } + + return signatures.length > 0 ? signatures[signatures.length - 1] : null; +} +``` diff --git a/snippets/code-snippets/privy/transaction-history/nodejs.mdx b/snippets/code-snippets/privy/transaction-history/nodejs.mdx index 9d58855f..00fce8c1 100644 --- a/snippets/code-snippets/privy/transaction-history/nodejs.mdx +++ b/snippets/code-snippets/privy/transaction-history/nodejs.mdx @@ -6,63 +6,36 @@ import {PublicKey} from '@solana/web3.js'; const getTransactionHistory = async ( ownerAddress: string, limit: number = 10, - includeDetails: boolean = false ) => { const connection = createRpc(process.env.HELIUS_RPC_URL!); const owner = new PublicKey(ownerAddress); - // Get compression signatures for token owner - const signatures = await connection.getCompressionSignaturesForTokenOwner(owner); + // Get Light Token interface signatures + const result = await connection.getSignaturesForOwnerInterface(owner); - if (signatures.items.length === 0) { + if (!result.signatures || result.signatures.length === 0) { return { count: 0, transactions: [], }; } - // Limit results - const limitedSignatures = signatures.items.slice(0, limit); + const limitedSignatures = result.signatures.slice(0, limit); - // Get detailed info if requested - if (includeDetails && limitedSignatures.length > 0) { - const transactions = await Promise.all( - limitedSignatures.map(async (sig) => { - const txInfo = await connection.getTransactionWithCompressionInfo(sig.signature); - - return { - signature: sig.signature, - slot: sig.slot, - blockTime: sig.blockTime, - timestamp: new Date(sig.blockTime * 1000).toISOString(), - compressionInfo: txInfo?.compressionInfo ? { - closedAccounts: txInfo.compressionInfo.closedAccounts.length, - openedAccounts: txInfo.compressionInfo.openedAccounts.length, - } : null, - }; - }) - ); - - return { - count: signatures.items.length, - transactions, - }; - } - - // Return basic signature info const transactions = limitedSignatures.map((sig) => ({ signature: sig.signature, slot: sig.slot, - blockTime: sig.blockTime, - timestamp: new Date(sig.blockTime * 1000).toISOString(), + blockTime: sig.blockTime ?? 0, + timestamp: sig.blockTime ? new Date(sig.blockTime * 1000).toISOString() : '', })); return { - count: signatures.items.length, + count: result.signatures.length, transactions, }; }; export default getTransactionHistory; + ``` diff --git a/snippets/code-snippets/privy/transaction-history/react.mdx b/snippets/code-snippets/privy/transaction-history/react.mdx index b7fe5611..1c98218e 100644 --- a/snippets/code-snippets/privy/transaction-history/react.mdx +++ b/snippets/code-snippets/privy/transaction-history/react.mdx @@ -3,17 +3,11 @@ import { useState, useCallback } from 'react'; import { PublicKey } from '@solana/web3.js'; import { createRpc } from '@lightprotocol/stateless.js'; -export interface TransactionCompressionInfo { - closedAccounts: number; - openedAccounts: number; -} - export interface Transaction { signature: string; slot: number; blockTime: number; timestamp: string; - compressionInfo?: TransactionCompressionInfo | null; } export function useTransactionHistory() { @@ -25,7 +19,6 @@ export function useTransactionHistory() { async ( ownerAddress: string, limit: number = 10, - includeDetails: boolean = false ) => { if (!ownerAddress) { setTransactions([]); @@ -39,44 +32,20 @@ export function useTransactionHistory() { const rpc = createRpc(import.meta.env.VITE_HELIUS_RPC_URL); const owner = new PublicKey(ownerAddress); - const signatures = await rpc.getCompressionSignaturesForTokenOwner(owner); + const result = await rpc.getSignaturesForOwnerInterface(owner); - if (signatures.items.length === 0) { + if (!result.signatures || result.signatures.length === 0) { setTransactions([]); return; } - const limitedSignatures = signatures.items.slice(0, limit); - - if (includeDetails && limitedSignatures.length > 0) { - const transactionsWithDetails = await Promise.all( - limitedSignatures.map(async (sig) => { - const txInfo = await rpc.getTransactionWithCompressionInfo(sig.signature); - - return { - signature: sig.signature, - slot: sig.slot, - blockTime: sig.blockTime, - timestamp: new Date(sig.blockTime * 1000).toISOString(), - compressionInfo: txInfo?.compressionInfo - ? { - closedAccounts: txInfo.compressionInfo.closedAccounts.length, - openedAccounts: txInfo.compressionInfo.openedAccounts.length, - } - : null, - }; - }) - ); - - setTransactions(transactionsWithDetails); - return; - } + const limitedSignatures = result.signatures.slice(0, limit); const basicTransactions = limitedSignatures.map((sig) => ({ signature: sig.signature, slot: sig.slot, - blockTime: sig.blockTime, - timestamp: new Date(sig.blockTime * 1000).toISOString(), + blockTime: sig.blockTime ?? 0, + timestamp: sig.blockTime ? new Date(sig.blockTime * 1000).toISOString() : '', })); setTransactions(basicTransactions); diff --git a/snippets/code-snippets/privy/transfer/nodejs.mdx b/snippets/code-snippets/privy/transfer/nodejs.mdx index 0d4134b8..4a0844e4 100644 --- a/snippets/code-snippets/privy/transfer/nodejs.mdx +++ b/snippets/code-snippets/privy/transfer/nodejs.mdx @@ -1,16 +1,18 @@ ```typescript import 'dotenv/config'; import {PrivyClient} from '@privy-io/node'; -import {createRpc, bn} from '@lightprotocol/stateless.js'; -import {PublicKey, Transaction, ComputeBudgetProgram} from '@solana/web3.js'; -import {LightTokenProgram, selectMinCompressedTokenAccountsForTransfer} from '@lightprotocol/compressed-token'; +import {createRpc} from '@lightprotocol/stateless.js'; +import {PublicKey, Transaction} from '@solana/web3.js'; +import { + createTransferInterfaceInstructions, +} from '@lightprotocol/compressed-token/unified'; -const transferCompressedTokens = async ( +const transferLightTokens = async ( fromAddress: string, toAddress: string, tokenMintAddress: string, amount: number, - decimals: number = 6 + decimals: number = 9, ) => { const connection = createRpc(process.env.HELIUS_RPC_URL!); @@ -19,69 +21,46 @@ const transferCompressedTokens = async ( appSecret: process.env.PRIVY_APP_SECRET!, }); - // Create public key objects const fromPubkey = new PublicKey(fromAddress); const toPubkey = new PublicKey(toAddress); const mintPubkey = new PublicKey(tokenMintAddress); - const tokenAmount = bn(amount * Math.pow(10, decimals)); + const tokenAmount = Math.floor(amount * Math.pow(10, decimals)); - // Get compressed token accounts (filter out null items from indexer) - const accounts = await connection.getCompressedTokenAccountsByOwner(fromPubkey, {mint: mintPubkey}); - const validItems = (accounts.items || []).filter((item): item is NonNullable => item !== null); - if (validItems.length === 0) { - throw new Error('No compressed token accounts found'); - } - - // Select minimum accounts needed for transfer - const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer(validItems, tokenAmount); - if (inputAccounts.length === 0) { - throw new Error('Insufficient balance'); - } + // Loads cold (compressed), SPL, and Token 2022 balances into the Light Token associated token account before transfer. + // Returns TransactionInstruction[][] — send [0..n-2] in parallel, then [n-1] last. + const instructions = await createTransferInterfaceInstructions( + connection, fromPubkey, mintPubkey, tokenAmount, fromPubkey, toPubkey, + ); - // Get validity proof to prove compressed token accounts exist in state tree. - const proof = await connection.getValidityProof(inputAccounts.map(account => bn(account.compressedAccount.hash))); - - // Create transfer instruction - const instruction = await LightTokenProgram.transfer({ - payer: fromPubkey, - inputCompressedTokenAccounts: inputAccounts, - toAddress: toPubkey, - amount: tokenAmount, - recentInputStateRootIndices: proof.rootIndices, - recentValidityProof: proof.compressedProof, - }); + // Sign and send each batch via Privy + const walletId = process.env.TREASURY_WALLET_ID!; + const authorizationKey = process.env.TREASURY_AUTHORIZATION_KEY!; + const signatures: string[] = []; - // Create transaction - const transaction = new Transaction(); - transaction.add(ComputeBudgetProgram.setComputeUnitLimit({units: 300_000})); - transaction.add(instruction); + for (const ixs of instructions) { + const tx = new Transaction().add(...ixs); + const {blockhash} = await connection.getLatestBlockhash(); + tx.recentBlockhash = blockhash; + tx.feePayer = fromPubkey; - // Get recent blockhash - const {blockhash} = await connection.getLatestBlockhash(); - transaction.recentBlockhash = blockhash; - transaction.feePayer = fromPubkey; + const {signed_transaction} = await privy.wallets().solana().signTransaction( + walletId, { + transaction: tx.serialize({requireAllSignatures: false}), + authorization_context: {authorization_private_keys: [authorizationKey]}, + }, + ) as any; - // Sign with Privy - const signResult = await privy.wallets().solana().signTransaction(process.env.TREASURY_WALLET_ID!, { - transaction: transaction.serialize({requireAllSignatures: false}), - authorization_context: { - authorization_private_keys: [process.env.TREASURY_AUTHORIZATION_KEY!] - } - }); - const signedTx = (signResult as any).signed_transaction || signResult.signedTransaction; - if (!signedTx) { - throw new Error('Privy returned invalid response: ' + JSON.stringify(signResult)); + const sig = await connection.sendRawTransaction( + Buffer.from(signed_transaction, 'base64'), + {skipPreflight: false, preflightCommitment: 'confirmed'}, + ); + await connection.confirmTransaction(sig, 'confirmed'); + signatures.push(sig); } - const signedTransaction = Buffer.from(signedTx, 'base64'); - - // Send transaction - const signature = await connection.sendRawTransaction(signedTransaction, { - skipPreflight: false, - preflightCommitment: 'confirmed' - }); - await connection.confirmTransaction(signature, 'confirmed'); - return signature; + return signatures[signatures.length - 1]; }; -export default transferCompressedTokens;``` +export default transferLightTokens; + +``` diff --git a/snippets/code-snippets/privy/transfer/react.mdx b/snippets/code-snippets/privy/transfer/react.mdx index c532013b..e5a3e715 100644 --- a/snippets/code-snippets/privy/transfer/react.mdx +++ b/snippets/code-snippets/privy/transfer/react.mdx @@ -1,10 +1,15 @@ ```typescript import { useState } from 'react'; -import { PublicKey, Transaction, ComputeBudgetProgram } from '@solana/web3.js'; -import { LightTokenProgram, selectMinCompressedTokenAccountsForTransfer } from '@lightprotocol/compressed-token'; -import { bn, createRpc } from '@lightprotocol/stateless.js'; +import { PublicKey } from '@solana/web3.js'; +import { + createTransferInterfaceInstructions, +} from '@lightprotocol/compressed-token/unified'; +import { createRpc } from '@lightprotocol/stateless.js'; import type { ConnectedStandardSolanaWallet } from '@privy-io/js-sdk-core'; -import type { SignTransactionResult } from '@privy-io/react-auth/solana'; +import { useSignTransaction } from '@privy-io/react-auth/solana'; +import { signAndSendBatches } from './signAndSendBatches'; + +type SignTransactionFn = ReturnType['signTransaction']; export interface TransferParams { ownerPublicKey: string; @@ -17,11 +22,7 @@ export interface TransferParams { export interface TransferArgs { params: TransferParams; wallet: ConnectedStandardSolanaWallet; - signTransaction: (args: { - transaction: Buffer; - wallet: ConnectedStandardSolanaWallet; - chain: string; - }) => Promise; + signTransaction: SignTransactionFn; } export function useTransfer() { @@ -32,67 +33,32 @@ export function useTransfer() { try { const { params, wallet, signTransaction } = args; - const { ownerPublicKey, mint, toAddress, amount, decimals = 6 } = params; + const { ownerPublicKey, mint, toAddress, amount, decimals = 9 } = params; - // Create RPC connection const rpc = createRpc(import.meta.env.VITE_HELIUS_RPC_URL); const owner = new PublicKey(ownerPublicKey); const mintPubkey = new PublicKey(mint); const recipient = new PublicKey(toAddress); - const tokenAmount = bn(Math.floor(amount * Math.pow(10, decimals))); - - // Get compressed token accounts - const accounts = await rpc.getCompressedTokenAccountsByOwner(owner, { mint: mintPubkey }); - if (!accounts.items || accounts.items.length === 0) { - throw new Error('No compressed token accounts found'); - } + const tokenAmount = Math.floor(amount * Math.pow(10, decimals)); - // Select minimum accounts needed - const [inputAccounts] = selectMinCompressedTokenAccountsForTransfer(accounts.items, tokenAmount); - if (inputAccounts.length === 0) { - throw new Error('Insufficient balance'); - } - - // Get validity proof - const proof = await rpc.getValidityProof( - inputAccounts.map((account) => bn(account.compressedAccount.hash)) + // Returns TransactionInstruction[][]. + // Each inner array is one transaction. + // Almost always returns just one. + const instructions = await createTransferInterfaceInstructions( + rpc, owner, mintPubkey, tokenAmount, owner, recipient, ); - // Build transfer instruction - const transferIx = await LightTokenProgram.transfer({ - payer: owner, - inputCompressedTokenAccounts: inputAccounts, - toAddress: recipient, - amount: tokenAmount, - recentInputStateRootIndices: proof.rootIndices, - recentValidityProof: proof.compressedProof, - }); - - // Build transaction - const { blockhash } = await rpc.getLatestBlockhash(); - const transaction = new Transaction(); - transaction.add(ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 })); - transaction.add(transferIx); - transaction.recentBlockhash = blockhash; - transaction.feePayer = owner; - - // Serialize unsigned transaction - const unsignedTxBuffer = transaction.serialize({ requireAllSignatures: false }); - - // Sign with Privy - const signedTx = await signTransaction({ - transaction: unsignedTxBuffer, + const signature = await signAndSendBatches(instructions, { + rpc, + feePayer: owner, wallet, - chain: 'solana:devnet', + signTransaction, }); - // Send transaction - const signedTxBuffer = Buffer.from(signedTx.signedTransaction); - const signature = await rpc.sendRawTransaction(signedTxBuffer, { - skipPreflight: false, - preflightCommitment: 'confirmed', - }); + if (!signature) { + throw new Error('Transfer returned no instructions'); + } return signature; } finally { diff --git a/snippets/code-snippets/privy/unwrap/nodejs.mdx b/snippets/code-snippets/privy/unwrap/nodejs.mdx new file mode 100644 index 00000000..1bc631e2 --- /dev/null +++ b/snippets/code-snippets/privy/unwrap/nodejs.mdx @@ -0,0 +1,74 @@ +```typescript +import 'dotenv/config'; +import {PrivyClient} from '@privy-io/node'; +import {createRpc} from '@lightprotocol/stateless.js'; +import {PublicKey, Transaction} from '@solana/web3.js'; +import {getAssociatedTokenAddressSync} from '@solana/spl-token'; +import { + createUnwrapInstructions, +} from '@lightprotocol/compressed-token/unified'; + +const unwrapTokens = async ( + fromAddress: string, + tokenMintAddress: string, + amount: number, + decimals: number = 9, +) => { + const connection = createRpc(process.env.HELIUS_RPC_URL!); + + const privy = new PrivyClient({ + appId: process.env.PRIVY_APP_ID!, + appSecret: process.env.PRIVY_APP_SECRET!, + }); + + const fromPubkey = new PublicKey(fromAddress); + const mintPubkey = new PublicKey(tokenMintAddress); + const tokenAmount = BigInt(Math.floor(amount * Math.pow(10, decimals))); + + // Auto-detect token program (SPL vs Token 2022) from mint account owner + const mintAccountInfo = await connection.getAccountInfo(mintPubkey); + if (!mintAccountInfo) throw new Error(`Mint account ${tokenMintAddress} not found`); + const tokenProgramId = mintAccountInfo.owner; + + // Destination: SPL/T22 associated token account + const splAta = getAssociatedTokenAddressSync(mintPubkey, fromPubkey, false, tokenProgramId); + + // Returns TransactionInstruction[][]. + // Each inner array is one transaction. + // Handles loading + unwrapping together. + const instructions = await createUnwrapInstructions( + connection, splAta, fromPubkey, mintPubkey, tokenAmount, fromPubkey, + ); + + // Sign and send each batch via Privy + const walletId = process.env.TREASURY_WALLET_ID!; + const authorizationKey = process.env.TREASURY_AUTHORIZATION_KEY!; + const signatures: string[] = []; + + for (const ixs of instructions) { + const tx = new Transaction().add(...ixs); + const {blockhash} = await connection.getLatestBlockhash(); + tx.recentBlockhash = blockhash; + tx.feePayer = fromPubkey; + + const {signed_transaction} = await privy.wallets().solana().signTransaction( + walletId, { + transaction: tx.serialize({requireAllSignatures: false}), + authorization_context: {authorization_private_keys: [authorizationKey]}, + }, + ) as any; + + const sig = await connection.sendRawTransaction( + Buffer.from(signed_transaction, 'base64'), + {skipPreflight: false, preflightCommitment: 'confirmed'}, + ); + await connection.confirmTransaction(sig, 'confirmed'); + signatures.push(sig); + } + + return signatures[signatures.length - 1]; +}; + +export default unwrapTokens; + +``` diff --git a/snippets/code-snippets/privy/unwrap/react.mdx b/snippets/code-snippets/privy/unwrap/react.mdx new file mode 100644 index 00000000..cf5def70 --- /dev/null +++ b/snippets/code-snippets/privy/unwrap/react.mdx @@ -0,0 +1,78 @@ +```typescript +import { useState } from 'react'; +import { PublicKey } from '@solana/web3.js'; +import { getAssociatedTokenAddressSync } from '@solana/spl-token'; +import { + createUnwrapInstructions, +} from '@lightprotocol/compressed-token/unified'; +import { createRpc } from '@lightprotocol/stateless.js'; +import type { ConnectedStandardSolanaWallet } from '@privy-io/js-sdk-core'; +import { useSignTransaction } from '@privy-io/react-auth/solana'; +import { signAndSendBatches } from './signAndSendBatches'; + +type SignTransactionFn = ReturnType['signTransaction']; + +export interface UnwrapParams { + ownerPublicKey: string; + mint: string; + amount: number; + decimals?: number; +} + +export interface UnwrapArgs { + params: UnwrapParams; + wallet: ConnectedStandardSolanaWallet; + signTransaction: SignTransactionFn; +} + +export function useUnwrap() { + const [isLoading, setIsLoading] = useState(false); + + const unwrap = async (args: UnwrapArgs): Promise => { + setIsLoading(true); + + try { + const { params, wallet, signTransaction } = args; + const { ownerPublicKey, mint, amount, decimals = 9 } = params; + + const rpc = createRpc(import.meta.env.VITE_HELIUS_RPC_URL); + + const owner = new PublicKey(ownerPublicKey); + const mintPubkey = new PublicKey(mint); + const tokenAmount = BigInt(Math.floor(amount * Math.pow(10, decimals))); + + // Auto-detect token program (SPL vs T22) from mint account owner + const mintAccountInfo = await rpc.getAccountInfo(mintPubkey); + if (!mintAccountInfo) throw new Error(`Mint account ${mint} not found`); + const tokenProgramId = mintAccountInfo.owner; + + // Destination: SPL/T22 associated token account + const splAta = getAssociatedTokenAddressSync(mintPubkey, owner, false, tokenProgramId); + + // Returns TransactionInstruction[][]. + // Each inner array is one transaction. + // Handles loading + unwrapping together. + const instructions = await createUnwrapInstructions( + rpc, splAta, owner, mintPubkey, tokenAmount, owner, + ); + + const signature = await signAndSendBatches(instructions, { + rpc, + feePayer: owner, + wallet, + signTransaction, + }); + + if (!signature) { + throw new Error('Unwrap returned no instructions'); + } + + return signature; + } finally { + setIsLoading(false); + } + }; + + return { unwrap, isLoading }; +} +``` diff --git a/snippets/code-snippets/privy/wrap/nodejs.mdx b/snippets/code-snippets/privy/wrap/nodejs.mdx new file mode 100644 index 00000000..bf34ca1c --- /dev/null +++ b/snippets/code-snippets/privy/wrap/nodejs.mdx @@ -0,0 +1,87 @@ +```typescript +import 'dotenv/config'; +import {PrivyClient} from '@privy-io/node'; +import {createRpc, CTOKEN_PROGRAM_ID} from '@lightprotocol/stateless.js'; +import {PublicKey, Transaction, ComputeBudgetProgram} from '@solana/web3.js'; +import {getAssociatedTokenAddressSync, getAccount} from '@solana/spl-token'; +import {getSplInterfaceInfos} from '@lightprotocol/compressed-token'; +import { + createWrapInstruction, + getAssociatedTokenAddressInterface, + createAssociatedTokenAccountInterfaceIdempotentInstruction, +} from '@lightprotocol/compressed-token/unified'; + +const wrapTokens = async ( + fromAddress: string, + tokenMintAddress: string, + amount: number, + decimals: number = 9, +) => { + const connection = createRpc(process.env.HELIUS_RPC_URL!); + + const privy = new PrivyClient({ + appId: process.env.PRIVY_APP_ID!, + appSecret: process.env.PRIVY_APP_SECRET!, + }); + + const fromPubkey = new PublicKey(fromAddress); + const mintPubkey = new PublicKey(tokenMintAddress); + const tokenAmount = BigInt(Math.floor(amount * Math.pow(10, decimals))); + + // Get SPL interface info — determines whether mint uses SPL or Token 2022 + const splInterfaceInfos = await getSplInterfaceInfos(connection, mintPubkey); + const splInterfaceInfo = splInterfaceInfos.find( + (info) => info.isInitialized, + ); + if (!splInterfaceInfo) throw new Error('No SPL interface found for this mint'); + + // Derive source associated token account using the mint's token program (SPL or Token 2022) + const {tokenProgram} = splInterfaceInfo; + const splAta = getAssociatedTokenAddressSync(mintPubkey, fromPubkey, false, tokenProgram); + const ataAccount = await getAccount(connection, splAta, undefined, tokenProgram); + if (ataAccount.amount < BigInt(tokenAmount)) { + throw new Error('Insufficient SPL balance'); + } + + // Derive Light Token associated token account + const lightTokenAta = getAssociatedTokenAddressInterface(mintPubkey, fromPubkey); + + // Build instructions + const tx = new Transaction().add( + ComputeBudgetProgram.setComputeUnitLimit({units: 200_000}), + createAssociatedTokenAccountInterfaceIdempotentInstruction( + fromPubkey, lightTokenAta, fromPubkey, mintPubkey, CTOKEN_PROGRAM_ID, + ), + createWrapInstruction( + splAta, lightTokenAta, fromPubkey, mintPubkey, + tokenAmount, splInterfaceInfo, decimals, fromPubkey, + ), + ); + + // Sign and send via Privy + const {blockhash} = await connection.getLatestBlockhash(); + tx.recentBlockhash = blockhash; + tx.feePayer = fromPubkey; + + const walletId = process.env.TREASURY_WALLET_ID!; + const authorizationKey = process.env.TREASURY_AUTHORIZATION_KEY!; + + const {signed_transaction} = await privy.wallets().solana().signTransaction( + walletId, { + transaction: tx.serialize({requireAllSignatures: false}), + authorization_context: {authorization_private_keys: [authorizationKey]}, + }, + ) as any; + + const signature = await connection.sendRawTransaction( + Buffer.from(signed_transaction, 'base64'), + {skipPreflight: false, preflightCommitment: 'confirmed'}, + ); + await connection.confirmTransaction(signature, 'confirmed'); + + return signature; +}; + +export default wrapTokens; + +``` diff --git a/snippets/code-snippets/privy/wrap/react.mdx b/snippets/code-snippets/privy/wrap/react.mdx new file mode 100644 index 00000000..4cefafd5 --- /dev/null +++ b/snippets/code-snippets/privy/wrap/react.mdx @@ -0,0 +1,99 @@ +```typescript +import { useState } from 'react'; +import { PublicKey, Transaction, ComputeBudgetProgram } from '@solana/web3.js'; +import { getAssociatedTokenAddressSync, getAccount } from '@solana/spl-token'; +import { getSplInterfaceInfos } from '@lightprotocol/compressed-token'; +import { + createWrapInstruction, + getAssociatedTokenAddressInterface, + createAssociatedTokenAccountInterfaceIdempotentInstruction, +} from '@lightprotocol/compressed-token/unified'; +import { createRpc, CTOKEN_PROGRAM_ID } from '@lightprotocol/stateless.js'; +import type { ConnectedStandardSolanaWallet } from '@privy-io/js-sdk-core'; +import { useSignTransaction } from '@privy-io/react-auth/solana'; + +type SignTransactionFn = ReturnType['signTransaction']; + +export interface WrapParams { + ownerPublicKey: string; + mint: string; + amount: number; + decimals?: number; +} + +export interface WrapArgs { + params: WrapParams; + wallet: ConnectedStandardSolanaWallet; + signTransaction: SignTransactionFn; +} + +export function useWrap() { + const [isLoading, setIsLoading] = useState(false); + + const wrap = async (args: WrapArgs): Promise => { + setIsLoading(true); + + try { + const { params, wallet, signTransaction } = args; + const { ownerPublicKey, mint, amount, decimals = 9 } = params; + + const rpc = createRpc(import.meta.env.VITE_HELIUS_RPC_URL); + + const owner = new PublicKey(ownerPublicKey); + const mintPubkey = new PublicKey(mint); + const tokenAmount = BigInt(Math.floor(amount * Math.pow(10, decimals))); + + // Get SPL interface info — determines whether mint uses SPL or T22 + const splInterfaceInfos = await getSplInterfaceInfos(rpc, mintPubkey); + const splInterfaceInfo = splInterfaceInfos.find( + (info) => info.isInitialized, + ); + if (!splInterfaceInfo) throw new Error('No SPL interface found for this mint'); + const { tokenProgram } = splInterfaceInfo; + + // Derive source associated token account using the mint's token program (SPL or T22) + const splAta = getAssociatedTokenAddressSync(mintPubkey, owner, false, tokenProgram); + const ataAccount = await getAccount(rpc, splAta, undefined, tokenProgram); + if (ataAccount.amount < BigInt(tokenAmount)) { + throw new Error('Insufficient SPL balance'); + } + + // Derive light-token associated token account + const lightTokenAta = getAssociatedTokenAddressInterface(mintPubkey, owner); + + // Build transaction + const tx = new Transaction().add( + ComputeBudgetProgram.setComputeUnitLimit({ units: 200_000 }), + createAssociatedTokenAccountInterfaceIdempotentInstruction( + owner, lightTokenAta, owner, mintPubkey, CTOKEN_PROGRAM_ID, + ), + createWrapInstruction( + splAta, lightTokenAta, owner, mintPubkey, + tokenAmount, splInterfaceInfo, decimals, owner, + ), + ); + + const { blockhash } = await rpc.getLatestBlockhash(); + tx.recentBlockhash = blockhash; + tx.feePayer = owner; + + const unsignedTxBuffer = tx.serialize({ requireAllSignatures: false }); + const signedTx = await signTransaction({ + transaction: unsignedTxBuffer, + wallet, + chain: 'solana:devnet', + }); + + const signedTxBuffer = Buffer.from(signedTx.signedTransaction); + return rpc.sendRawTransaction(signedTxBuffer, { + skipPreflight: false, + preflightCommitment: 'confirmed', + }); + } finally { + setIsLoading(false); + } + }; + + return { wrap, isLoading }; +} +``` diff --git a/snippets/jsx/liquid-glass-pill.jsx b/snippets/jsx/liquid-glass-pill.jsx index 05670a24..2e721839 100644 --- a/snippets/jsx/liquid-glass-pill.jsx +++ b/snippets/jsx/liquid-glass-pill.jsx @@ -1,6 +1,6 @@ // Styles in style.css - uses .glass-pill classes -export const LiquidGlassPill = ({ title }) => { +export const LiquidGlassPill = ({ title, children }) => { return (
@@ -8,6 +8,7 @@ export const LiquidGlassPill = ({ title }) => {

{title}

+ {children}
); diff --git a/snippets/jsx/partner-logos.jsx b/snippets/jsx/partner-logos.jsx new file mode 100644 index 00000000..94465bc1 --- /dev/null +++ b/snippets/jsx/partner-logos.jsx @@ -0,0 +1,24 @@ +// Styles in style.css - uses .partner-logos classes + +export const PartnerLogos = () => { + return ( +
+ Light Protocol + × + Helius + Helius +
+ ); +}; diff --git a/snippets/overview-tables/compressed-pdas-guides-table.mdx b/snippets/overview-tables/compressed-pdas-guides-table.mdx index b72a52b2..63763552 100644 --- a/snippets/overview-tables/compressed-pdas-guides-table.mdx +++ b/snippets/overview-tables/compressed-pdas-guides-table.mdx @@ -1,7 +1,50 @@ -| Guide | Description | -| ------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | -| [Create Compressed Accounts](/compressed-pdas/guides/how-to-create-compressed-accounts) | Create compressed accounts with address | -| [Update Compressed Accounts](/compressed-pdas/guides/how-to-update-compressed-accounts) | Update compressed accounts | -| [Close Compressed Accounts](/compressed-pdas/guides/how-to-close-compressed-accounts) | Close compressed accounts, retain the address | -| [Reinitialize Compressed Accounts](/compressed-pdas/guides/how-to-reinitialize-compressed-accounts) | Reinitialize closed compressed accounts with the same address and new values | -| [Burn Compressed Accounts](/compressed-pdas/guides/how-to-burn-compressed-accounts) | Burn compressed accounts and their address permanently | +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Create + Initialize compressed PDAs in your program
+ Update + Modify state in compressed accounts
+ Close + Reclaim lamports from compressed accounts
+ Reinitialize + Reset and reuse compressed accounts
+ Burn + Permanently delete compressed accounts
+ Nullifier PDAs + Prevent replay attacks with one-time use accounts
diff --git a/snippets/overview-tables/compressed-tokens-advanced-guides-table.mdx b/snippets/overview-tables/compressed-tokens-advanced-guides-table.mdx index ac09b01c..88ccd3dc 100644 --- a/snippets/overview-tables/compressed-tokens-advanced-guides-table.mdx +++ b/snippets/overview-tables/compressed-tokens-advanced-guides-table.mdx @@ -1,7 +1,4 @@ | Guide | Description | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------ | -| [Create an Airdrop without Claim](/compressed-tokens/advanced-guides/airdrop) | ZK Compression is the most efficient way to distribute SPL tokens. Distribute via Webapp or customize with claim. | -| [Combine Instructions in One Transaction](/compressed-tokens/advanced-guides/how-to-combine-operations-in-one-transaction) | Execute multiple token instructions within a single transaction | -| [For Wallet Applications](/compressed-tokens/advanced-guides/add-wallet-support-for-compressed-tokens) | Add compressed token support in your wallet application | -| [Use Token-2022 with Compression](/compressed-tokens/advanced-guides/use-token-2022-with-compression) | Create compressed Token-2022 mints with metadata and other extensions | -| [Privy Guide](/compressed-tokens/for-privy) | Integrate compressed tokens with Privy embedded wallets for rent-free token accounts | +| [Create an Airdrop without Claim](/compressed-tokens/airdrop) | ZK Compression is the most efficient way to distribute SPL tokens. Distribute via Webapp or customize with claim. | +| [Privy Guide](/light-token/toolkits/for-privy) | Integrate light-tokens with Privy embedded wallets for rent-free token accounts | diff --git a/snippets/overview-tables/compressed-tokens-guides-table.mdx b/snippets/overview-tables/compressed-tokens-guides-table.mdx index 4e5d2458..b6b4e758 100644 --- a/snippets/overview-tables/compressed-tokens-guides-table.mdx +++ b/snippets/overview-tables/compressed-tokens-guides-table.mdx @@ -1,11 +1,11 @@ | Guide | Description | | :---------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------- | -| [Create Compressed Token Accounts](/compressed-tokens/guides/create-compressed-token-accounts) | Create compressed and learn difference to regular token accounts | -| [Mint Compressed Tokens](/compressed-tokens/guides/mint-compressed-tokens) | Create new compressed tokens to existing mint | -| [Transfer Compressed Tokens](/compressed-tokens/guides/transfer-compressed-tokens) | Move compressed tokens between compressed accounts | -| [Decompress and Compress Tokens](/compressed-tokens/guides/compress-decompress) | Convert SPL tokens between regular and compressed format | -| [Compress Complete SPL Token Accounts](/compressed-tokens/guides/compress-spl-token-account) | Compress complete SPL token accounts and reclaim rent afterwards | -| [Create a mint with SPL interface](/compressed-tokens/guides/create-mint-with-token-pool) | Create new SPL mint with SPL Interface PDA for compression | -| [Create SPL interface for existing mints](/compressed-tokens/guides/add-token-pools-to-mint-accounts) | Create SPL Interface PDA (omnibus account) for existing SPL mints | -| [Merge Compressed Accounts](/compressed-tokens/guides/merge-compressed-token-accounts) | Consolidate multiple compressed accounts of the same mint into one | -| [Approve and Revoke Delegate Authority](/compressed-tokens/guides/delegate) | Approve or revoke delegates for compressed token accounts | +| [Create Compressed Token Accounts](https://github.com/Lightprotocol/examples-zk-compression/tree/main/compressed-token-cookbook) | Create compressed and learn difference to regular token accounts | +| [Mint Compressed Tokens](https://github.com/Lightprotocol/examples-zk-compression/tree/main/compressed-token-cookbook) | Create new compressed tokens to existing mint | +| [Transfer Compressed Tokens](https://github.com/Lightprotocol/examples-zk-compression/tree/main/compressed-token-cookbook) | Move compressed tokens between compressed accounts | +| [Decompress and Compress Tokens](https://github.com/Lightprotocol/examples-zk-compression/tree/main/compressed-token-cookbook) | Convert SPL tokens between regular and compressed format | +| [Compress Complete SPL Token Accounts](https://github.com/Lightprotocol/examples-zk-compression/tree/main/compressed-token-cookbook) | Compress complete SPL token accounts and reclaim rent afterwards | +| [Create a Mint with Interface PDA](https://github.com/Lightprotocol/examples-zk-compression/tree/main/compressed-token-cookbook) | Create new SPL mint with SPL Interface PDA for compression | +| [Create SPL Interface for Existing Mints](https://github.com/Lightprotocol/examples-zk-compression/tree/main/compressed-token-cookbook) | Create SPL Interface PDA for existing SPL mints | +| [Merge Compressed Accounts](https://github.com/Lightprotocol/examples-zk-compression/tree/main/compressed-token-cookbook) | Consolidate multiple compressed accounts of the same mint into one | +| [Approve and Revoke Delegate Authority](https://github.com/Lightprotocol/examples-zk-compression/tree/main/compressed-token-cookbook) | Approve or revoke delegates for compressed token accounts | \ No newline at end of file diff --git a/snippets/overview-tables/examples-guides-table.mdx b/snippets/overview-tables/examples-guides-table.mdx new file mode 100644 index 00000000..d0d9dbb3 --- /dev/null +++ b/snippets/overview-tables/examples-guides-table.mdx @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + + + + + + + + +
+ Client + TypeScript and Rust client examples for light-token SDK
+ Program + Anchor program examples for light-token CPI, Macros and more
\ No newline at end of file diff --git a/snippets/overview-tables/light-token-program-examples-table.mdx b/snippets/overview-tables/light-token-program-examples-table.mdx index 57943e36..6865d378 100644 --- a/snippets/overview-tables/light-token-program-examples-table.mdx +++ b/snippets/overview-tables/light-token-program-examples-table.mdx @@ -4,6 +4,8 @@ |---------|-------------| | [cp-swap-reference](https://github.com/Lightprotocol/cp-swap-reference) | Fork of Raydium AMM that creates markets without paying rent-exemption | | [create-and-transfer](https://github.com/Lightprotocol/examples-light-token/tree/main/programs/anchor/create-and-transfer) | Create account via macro and transfer via CPI | +| [pinocchio-swap](https://github.com/Lightprotocol/examples-light-token/tree/main/pinocchio/swap) | Light Token swap reference implementation | + ### Macros | | Description | diff --git a/snippets/overview-tables/program-examples-table.mdx b/snippets/overview-tables/program-examples-table.mdx index 86761063..e736f453 100644 --- a/snippets/overview-tables/program-examples-table.mdx +++ b/snippets/overview-tables/program-examples-table.mdx @@ -1,12 +1,15 @@ | Example | Description | |:---------|:------------| +| [Account Comparison](https://github.com/Lightprotocol/program-examples/tree/main/account-comparison) | Compare compressed accounts with standard Solana accounts | | [basic-operations/anchor](https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/anchor) | Anchor programs to create, update, close, reinitialize and burn compressed accounts with Rust and TypeScript tests | | [basic-operations/native](https://github.com/Lightprotocol/program-examples/tree/main/basic-operations/native) | Native Solana program implementation to create, update, close, reinitialize and burn compressed accounts with Rust tests | | [Counter (Anchor)](https://github.com/Lightprotocol/program-examples/tree/main/counter/anchor) | Full compressed account lifecycle (create, increment, decrement, reset, close) using Anchor framework | | [Counter (Native)](https://github.com/Lightprotocol/program-examples/tree/main/counter/native) | Native Solana program implementation with Rust tests | | [Counter (Pinocchio)](https://github.com/Lightprotocol/program-examples/tree/main/counter/pinocchio) | Pinocchio implementation using light-sdk-pinocchio with Rust tests | | [Create-and-Update](https://github.com/Lightprotocol/program-examples/tree/main/create-and-update) | Create new compressed accounts and update existing ones within a single instruction and one validity proof | +| [merkle-distributor](https://github.com/Lightprotocol/distributor) | SPL token distribution with compressed PDAs for claim tracking, vesting, and clawback | +| [Nullifier Program](https://github.com/Lightprotocol/nullifier-program) | System for payments, AI agents and more to prevent your onchain instruction from being executed more than once | | [Read-Only](https://github.com/Lightprotocol/program-examples/tree/main/read-only) | Create compressed accounts and read them on-chain | -| [Account Comparison](https://github.com/Lightprotocol/program-examples/tree/main/account-comparison) | Compare compressed accounts with standard Solana accounts | -| [Nullifier Program](https://github.com/Lightprotocol/nullifier-program) | For some use cases, such as sending payments, you might want to prevent your onchain instruction from being executed more than once. Creates a rent-free PDA derived from an id. If the id has been used before, the PDA already exists, causing the instruction to fail | -| [ZK-ID](https://github.com/Lightprotocol/program-examples/tree/main/zk-id) | Program that uses zero-knowledge proofs for identity verification with compressed accounts | +| [simple-claim](https://github.com/Lightprotocol/program-examples-airdrop-implementations/tree/main/simple-claim) | Distributes compressed tokens that decompress to SPL on claim | +| [ZK-ID](https://github.com/Lightprotocol/program-examples/tree/main/zk-id) | Zero-knowledge proofs for identity verification with compressed accounts | +| [ZK-Nullifier](https://github.com/Lightprotocol/program-examples/tree/main/zk-nullifier) | Implementation of nullifiers for zk programs on Solana to prevent double spending | diff --git a/snippets/overview-tables/sdk-reference-compressed-pdas.mdx b/snippets/overview-tables/sdk-reference-compressed-pdas.mdx new file mode 100644 index 00000000..99739874 --- /dev/null +++ b/snippets/overview-tables/sdk-reference-compressed-pdas.mdx @@ -0,0 +1,32 @@ +### Client + + + + TypeScript RPC client for compressed accounts, validity proofs, and address derivation. + + + Rust RPC client and indexer for compressed accounts. + + + +### Program + + + + Core SDK for compressed accounts in Anchor programs. + + + Procedural macros for LightAccount derivation. + + + Local testing framework for programs. + + diff --git a/snippets/overview-tables/sdk-reference.mdx b/snippets/overview-tables/sdk-reference.mdx new file mode 100644 index 00000000..000c6f38 --- /dev/null +++ b/snippets/overview-tables/sdk-reference.mdx @@ -0,0 +1,55 @@ +### Client + + + + TypeScript RPC client for Light Token and Compressed Accounts. + + + Rust RPC client for Light Token and ZK Compression. + + + TypeScript token operations for Light Token and Compressed Tokens. + + + Rust token operations for Light Token. + + + TypeScript SDK for creating nullifier PDAs to prevent duplicate actions. + + + Rust SDK for creating nullifier PDAs to prevent duplicate actions. + + + +### Program + + + + Core SDK for on-chain programs. + + + Procedural macros for Light accounts. + + + CPI instructions for Light Token program. + + + Local testing framework for programs. + + diff --git a/snippets/setup/agent-skill-airdrop.mdx b/snippets/setup/agent-skill-airdrop.mdx new file mode 100644 index 00000000..f90145fa --- /dev/null +++ b/snippets/setup/agent-skill-airdrop.mdx @@ -0,0 +1,9 @@ +import InstallAgentSkills from "/snippets/setup/install-agent-skills.mdx"; + + + +Use the [airdrop](https://github.com/Lightprotocol/skills/tree/main/skills/airdrop) agent skill for token distribution and airdrops: + + + + diff --git a/snippets/setup/agent-skill-defi-program.mdx b/snippets/setup/agent-skill-defi-program.mdx new file mode 100644 index 00000000..1d2994cc --- /dev/null +++ b/snippets/setup/agent-skill-defi-program.mdx @@ -0,0 +1,9 @@ +import InstallAgentSkills from "/snippets/setup/install-agent-skills.mdx"; + + + +Use the [defi-program](https://github.com/Lightprotocol/skills/tree/main/skills/defi-program) agent skill to build rent-free DeFi programs: + + + + diff --git a/snippets/setup/agent-skill-defi-router.mdx b/snippets/setup/agent-skill-defi-router.mdx new file mode 100644 index 00000000..83171a18 --- /dev/null +++ b/snippets/setup/agent-skill-defi-router.mdx @@ -0,0 +1,9 @@ +import InstallAgentSkills from "/snippets/setup/install-agent-skills.mdx"; + + + +Use the [defi-router](https://github.com/Lightprotocol/skills/tree/main/skills/defi-router) agent skill to integrate rent-free markets into your router: + + + + diff --git a/snippets/setup/agent-skill-generic.mdx b/snippets/setup/agent-skill-generic.mdx new file mode 100644 index 00000000..df59651e --- /dev/null +++ b/snippets/setup/agent-skill-generic.mdx @@ -0,0 +1,11 @@ + + +Install the [agent skill](https://zkcompression.com/skill.md): + +```bash +npx skills add https://zkcompression.com +``` + +See the [AI tools guide](/ai-tools/guide) for dedicated skills. + + diff --git a/snippets/setup/agent-skill-payments.mdx b/snippets/setup/agent-skill-payments.mdx new file mode 100644 index 00000000..80e5711f --- /dev/null +++ b/snippets/setup/agent-skill-payments.mdx @@ -0,0 +1,9 @@ +import InstallAgentSkills from "/snippets/setup/install-agent-skills.mdx"; + + + +Use the [payments-and-wallets](https://github.com/Lightprotocol/skills/tree/main/skills/payments-and-wallets) agent skill to add light-token payment support to your project: + + + + diff --git a/snippets/setup/agent-skill-streaming.mdx b/snippets/setup/agent-skill-streaming.mdx new file mode 100644 index 00000000..d3bb9e7b --- /dev/null +++ b/snippets/setup/agent-skill-streaming.mdx @@ -0,0 +1,9 @@ +import InstallAgentSkills from "/snippets/setup/install-agent-skills.mdx"; + + + +Use the [data-streaming](https://github.com/Lightprotocol/skills/tree/main/skills/data-streaming) agent skill to add Laserstream support to your project: + + + + diff --git a/snippets/setup/agent-skill-zk-nullifier.mdx b/snippets/setup/agent-skill-zk-nullifier.mdx new file mode 100644 index 00000000..80809e72 --- /dev/null +++ b/snippets/setup/agent-skill-zk-nullifier.mdx @@ -0,0 +1,9 @@ +import InstallAgentSkills from "/snippets/setup/install-agent-skills.mdx"; + + + +Use the [zk-nullifier](https://github.com/Lightprotocol/skills/tree/main/skills/zk-nullifier) agent skill to build privacy-preserving ZK programs with nullifiers: + + + + diff --git a/snippets/setup/compressed-tokens-mint-prereq.mdx b/snippets/setup/compressed-tokens-mint-prereq.mdx index 6d55f472..f902e9a8 100644 --- a/snippets/setup/compressed-tokens-mint-prereq.mdx +++ b/snippets/setup/compressed-tokens-mint-prereq.mdx @@ -1,5 +1,5 @@ The SPL mint must have an SPL Interface PDA for compression.
The script creates it for you. -For development, create a new mint with SPL interface via [`createMint()`](/compressed-tokens/guides/create-mint-with-token-pool) or add an SPL interface to an existing mint via [`createSplInterface()`](/compressed-tokens/guides/add-token-pools-to-mint-accounts). +For development, create a new mint with SPL interface via [`createMint()`](https://github.com/Lightprotocol/examples-zk-compression/tree/main/compressed-token-cookbook) or add an SPL interface to an existing mint via [`createSplInterface()`](https://github.com/Lightprotocol/examples-zk-compression/tree/main/compressed-token-cookbook). diff --git a/snippets/setup/install-agent-skills.mdx b/snippets/setup/install-agent-skills.mdx new file mode 100644 index 00000000..ffa18e7d --- /dev/null +++ b/snippets/setup/install-agent-skills.mdx @@ -0,0 +1,27 @@ + + +Add the marketplace and install: + +``` +/plugin marketplace add Lightprotocol/skills +/plugin install solana-rent-free-dev +``` + + +1. Open Settings (**Cmd+Shift+J** / **Ctrl+Shift+J**) +2. Navigate to **Rules & Commands** → **Project Rules** → **Add Rule** → **Remote Rule (GitHub)** +3. Enter: `https://github.com/Lightprotocol/skills.git` + + + +``` +npx skills add Lightprotocol/skills +``` + + + +For orchestration, install the [general skill](https://zkcompression.com/skill.md): + +```bash +npx skills add https://zkcompression.com +``` \ No newline at end of file diff --git a/snippets/setup/register-spl-mint.mdx b/snippets/setup/register-spl-mint.mdx new file mode 100644 index 00000000..57ccead5 --- /dev/null +++ b/snippets/setup/register-spl-mint.mdx @@ -0,0 +1,68 @@ +## One-time: Create interface PDA to existing SPL Mint + +For existing SPL mints (e.g. USDC), register the SPL interface once. This creates the omnibus PDA that holds SPL tokens when wrapped to light-token. + + +Find a full code example [here](https://github.com/Lightprotocol/examples-light-token/blob/main/toolkits/payments-and-wallets/register-spl-mint.ts). + + +Check if the interface already exists: + +```typescript +import { getSplInterfaceInfos } from "@lightprotocol/compressed-token"; + +try { + const infos = await getSplInterfaceInfos(rpc, mint); + const exists = infos.some((i) => i.isInitialized); + console.log("Interface exists:", exists); +} catch { + console.log("No interface registered for this mint."); +} +``` + +Register: + + + + +```typescript +import { Transaction, sendAndConfirmTransaction } from "@solana/web3.js"; +import { LightTokenProgram } from "@lightprotocol/compressed-token"; +import { TOKEN_PROGRAM_ID } from "@solana/spl-token"; + +const ix = await LightTokenProgram.createSplInterface({ + feePayer: payer.publicKey, + mint, + tokenProgramId: TOKEN_PROGRAM_ID, +}); + +const tx = new Transaction().add(ix); +await sendAndConfirmTransaction(rpc, tx, [payer]); +``` + + + + +```typescript +import { createSplInterface } from "@lightprotocol/compressed-token"; + +await createSplInterface(rpc, payer, mint); +``` + + + + + + +Use `createMintInterface` with `TOKEN_PROGRAM_ID` to create a new SPL mint and register the interface in one transaction: + +```typescript +import { createMintInterface } from "@lightprotocol/compressed-token/unified"; +import { TOKEN_PROGRAM_ID } from "@solana/spl-token"; + +const { mint } = await createMintInterface( + rpc, payer, payer, null, 9, undefined, undefined, TOKEN_PROGRAM_ID +); +``` + + \ No newline at end of file diff --git a/snippets/versions/rust-native-token.mdx b/snippets/versions/rust-native-token.mdx new file mode 100644 index 00000000..e77600fa --- /dev/null +++ b/snippets/versions/rust-native-token.mdx @@ -0,0 +1,7 @@ +```toml +[dependencies] +light-token = "0.4.0" +light-compressible = "0.4.0" +light-token-interface = "0.3.0" +light-compressed-account = "0.9.0" +``` diff --git a/snippets/versions/rust-sdk-macros.mdx b/snippets/versions/rust-sdk-macros.mdx new file mode 100644 index 00000000..cd5fc463 --- /dev/null +++ b/snippets/versions/rust-sdk-macros.mdx @@ -0,0 +1,5 @@ +```toml +[dependencies] +light-sdk = { version = "0.19.0", features = ["anchor", "v2", "cpi-context"] } +light-sdk-macros = "0.19.0" +``` diff --git a/snippets/versions/rust-sdk.mdx b/snippets/versions/rust-sdk.mdx new file mode 100644 index 00000000..110d90ab --- /dev/null +++ b/snippets/versions/rust-sdk.mdx @@ -0,0 +1,4 @@ +```toml +[dependencies] +light-sdk = "0.19.0" +``` diff --git a/snippets/versions/rust-test.mdx b/snippets/versions/rust-test.mdx new file mode 100644 index 00000000..ab8e5c69 --- /dev/null +++ b/snippets/versions/rust-test.mdx @@ -0,0 +1,5 @@ +```toml +[dev-dependencies] +light-program-test = { version = "0.19.0", features = ["v2"] } +light-client = { version = "0.19.0", features = ["v2"] } +``` diff --git a/snippets/versions/rust-token-defi.mdx b/snippets/versions/rust-token-defi.mdx new file mode 100644 index 00000000..dbaa0a59 --- /dev/null +++ b/snippets/versions/rust-token-defi.mdx @@ -0,0 +1,6 @@ +```toml +[dependencies] +light-sdk = { version = "0.19.0", features = ["anchor", "v2", "cpi-context"] } +light-sdk-macros = "0.19.0" +light-token = { version = "0.4.0", features = ["anchor"] } +``` diff --git a/snippets/versions/rust-token.mdx b/snippets/versions/rust-token.mdx new file mode 100644 index 00000000..e51ec9cc --- /dev/null +++ b/snippets/versions/rust-token.mdx @@ -0,0 +1,5 @@ +```toml +[dependencies] +light-sdk = "0.19.0" +light-token = "0.4.0" +``` diff --git a/style.css b/style.css index 642acdf1..f89d0b85 100644 --- a/style.css +++ b/style.css @@ -79,7 +79,7 @@ html.dark .hero-cube-grid { .glass-pill-bg { position: absolute; - inset: -16px -28px; + inset: -20px -28px; z-index: 0; border-radius: 9999px; overflow: hidden; @@ -99,14 +99,14 @@ html.dark .glass-pill-bg { /* Tablet and up - larger pill padding */ @media (min-width: 640px) { .glass-pill-bg { - inset: -18px -44px; + inset: -22px -44px; } } /* Desktop - full pill padding */ @media (min-width: 768px) { .glass-pill-bg { - inset: -22px -64px; + inset: -28px -64px; } } @@ -219,3 +219,75 @@ html.dark .hero-title { font-size: 3rem; } } + +/* Partner logos inside hero pill */ +.partner-logos { + display: flex; + align-items: center; + justify-content: center; + gap: 16px; + margin-top: 6px; + pointer-events: none; +} + +.partner-logos img { + height: 18px; + width: auto; +} + +.partner-divider { + color: #9ca3af; + font-size: 10px; +} + +@media (min-width: 640px) { + .partner-logos { + gap: 20px; + margin-top: 10px; + } + .partner-logos img { + height: 22px; + } + .partner-divider { + font-size: 11px; + } +} + +@media (min-width: 768px) { + .partner-logos { + gap: 24px; + margin-top: 14px; + } + .partner-logos img { + height: 26px; + } + .partner-divider { + font-size: 12px; + } +} + +/* Light wordmark is white SVG - invert for light mode */ +.light-wordmark { + filter: invert(1); +} + +html.dark .light-wordmark { + filter: none; +} + +/* Helius logo switching */ +.logo-dark { + display: none; +} + +html.dark .logo-light { + display: none; +} + +html.dark .logo-dark { + display: block; +} + +html.dark .partner-divider { + color: #6b7280; +} diff --git a/use-agent.skill b/use-agent.skill new file mode 100644 index 00000000..528f89fb Binary files /dev/null and b/use-agent.skill differ diff --git a/welcome.mdx b/welcome.mdx index 16f17ef4..b68b8adb 100644 --- a/welcome.mdx +++ b/welcome.mdx @@ -9,51 +9,6 @@ import WelcomePageInstall from "/snippets/setup/welcome-page-install.mdx"; ![](/images/banner-image.png) -| **Creation Cost** | Solana | ZK Compression | -| :---------------- | :------------------ | :------------------- | -| **Token Account** | ~2,000,000 lamports | ~**5,000** lamports | -| **100-byte PDA** | ~1,600,000 lamports | ~**15,000** lamports | - -## Features - - - High performance token standard for rent-free DeFi and Payments. - - - - - - For App State. - - - For Token Distribution. - - - -## Quickstart - - - - - - - - - - ## What is ZK Compression? ZK Compression is a framework that reduces the storage cost of Solana accounts by combining generalized state compression and zero-knowledge proofs. @@ -68,57 +23,4 @@ ZK Compression is a framework that reduces the storage cost of Solana accounts b the compressed accounts. By default, this is all done under the hood. You can fetch validity proofs from RPC providers that support ZK Compression. - - -## Resources - - - - Browse ZK Compression's JSON RPC methods. - - - Explore our TypeScript and Rust SDKs. - - - Install the ZK Compression CLI for local development. - - - -## Learn & Community - - - - Learn about ZK Compression's core concepts. - - - Read our external audit and formal verification reports. - - - Join our Discord for support and discussions. - - - -## Next Steps - - + \ No newline at end of file diff --git a/zk/examples.mdx b/zk/examples.mdx index 35f7e34f..1040d4d6 100644 --- a/zk/examples.mdx +++ b/zk/examples.mdx @@ -5,6 +5,9 @@ keywords: ["privacy examples solana", "zk examples solana", "private payments ex --- import ZkExamplesTable from "/snippets/overview-tables/zk-examples-table.mdx"; +import AgentSkillZkNullifier from "/snippets/setup/agent-skill-zk-nullifier.mdx"; + + diff --git a/zk/overview.mdx b/zk/overview.mdx index c56e4714..a31b601d 100644 --- a/zk/overview.mdx +++ b/zk/overview.mdx @@ -6,9 +6,12 @@ keywords: ["shielded pools", "mixer", "nullifiers on Solana", "zcash on solana", --- import ZkExamplesTable from "/snippets/overview-tables/zk-examples-table.mdx"; +import AgentSkillZkNullifier from "/snippets/setup/agent-skill-zk-nullifier.mdx"; --- + + Building a ZK Solana program requires: 1. Nullifiers to prevent double spending 2. Proof verification @@ -16,11 +19,11 @@ Building a ZK Solana program requires: 4. An indexer to serve Merkle proofs 5. Encrypted state -## Nullifiers on Solana +## Nullifiers for ZK on Solana A nullifier is a deterministically derived hash to ensure an action can only be performed once. The nullifier cannot be linked to the action or user. -For example Zcash uses nullifiers to prevent double spending. +For example Zcash uses nullifiers to prevent double spending. To implement nullifiers we need a data structure that ensures every nullifier is only created once and never deleted. On Solana a straight forward way to implement nullifiers is to create a PDA account with the nullifier as seed. @@ -120,7 +123,7 @@ ZK applications on Solana can use existing state Merkle trees to store state in | 100-byte PDA | ~1,600,000 lamports | 15,000 lamports | -Your circuit must include compressed accounts. Find [guides to compressed accounts in the documentation](/compressed-pdas/overview) and the [full example with zk implementation here](https://github.com/Lightprotocol/program-examples/blob/99d260f9f356743b8fe3501c684f7926930d6079/zk-id/circuits/compressed_account.circom). +Your circuit must include compressed accounts. Find [guides to compressed accounts in the documentation](/pda/compressed-pdas/overview) and the [full example with zk implementation here](https://github.com/Lightprotocol/program-examples/blob/99d260f9f356743b8fe3501c684f7926930d6079/zk-id/circuits/compressed_account.circom). ## Get Started & Examples