Sluice | Flutter App - Token Distribution With Holder Snapshots icon

Sluice | Flutter App - Token Distribution With Holder Snapshots

Go to Website
Hot or Not
Sluice | Flutter App - Token Distribution With Holder Snapshots

Description

AI disclosure: AI tools were used to assist with parts of the code, documentation and graphics of this item. The author directed, reviewed and tested every part before release. SLUICE is not affiliated with, endorsed by or sponsored by Solana, Helius, QuickNode, Alchemy, Dexscreener, Solscan, Apple, Google or Flutter; their names are used only to describe compatibility.

SLUICE Solana airdrop console source code on a MacBook and an iPhone: the dry-run report, the holder list and the operator fee of a sample round, with a button to try the live demo

Animated walkthrough of the SLUICE live demo: the holder snapshot, the pool exclusions, the dry run with the operator fee and the report, then the Try the live demo button

How to open the SLUICE demo: sluice-demo.mikodes.com, passcode sluice-demo, no sign-in, one sample round of 22 addresses with 2 excluded and 20 holders

Costs outside the SLUICE price: your own Solana RPC endpoint, an optional Helius key, network fees and token-account rent, hosting for the web build and app store accounts; no server, database or on-chain program

Launch bonus: free installation of SLUICE for the first three buyers: web build deployed on your hosting, your RPC endpoint and your name in the console

Claim the free SLUICE installation through the CodeCanyon author page, first three buyers only

Open the SLUICE live demo, the web build where nothing can be signed or sent

Read the SLUICE documentation: snapshots, exclusions, allocation, distribution and the audit trail

Open the SLUICE live demo at sluice-demo.mikodes.com: the demo build with one labelled sample round, passcode sluice-demo

How you earn with SLUICE: an operator fee of up to 2% on every airdrop round, running airdrops as a service for token teams, and rebranding it for clients under the Extended licence

How the money moves in SLUICE: a token project funds the pool, SLUICE splits it, your operator fee goes to your wallet and the rest goes to the holders

Money questions buyers ask about SLUICE: who gets the fee, who funds the pool, how the operator profits, percent or fixed fee, and that MIKODES takes no cut

SLUICE documentation: How the fee works

The operator fee in SLUICE: a rate per round capped at 200 basis points in code, transferred as its own batch, and named when it cannot be collected

The dry run report: holders in the snapshot, addresses excluded, the amount funded, the operator fee at funding and the cost of the transfers, every figure with its evidence

What is in the download: Flutter source for macOS, web, iOS and Android, the snapshot engine, allocation, direct distribution verified on chain, the audit trail and documentation

At a glance: a 200 basis point fee ceiling in code, direct transfers verified on chain, no keys in the package and no forecasts anywhere

Who the SLUICE source code is for: token projects paying holders, communities and treasuries dividing a pool, and Solana developers

How a round runs: snapshot the holders, dry run the allocation and costs, then distribute with your own signer

SLUICE documentation: Your first round, step by step

Installing SLUICE in four commands: unzip, flutter pub get, flutter test and flutter run with your own operator passcode, from the quick start guide

The SLUICE documentation: 16 pages including quick start, your first round, your fee, rebranding, deployment and troubleshooting

A tour of six SLUICE console screens from the demo build: holders, exclusions, tiers, wording presets, the operator fee and the report

The snapshot screen: holders folded by owner at the recorded slot, point-in-time or time-weighted, with coverage and the longest gap

SLUICE snapshot mode switching from the current slot to a time-weighted window with recorded balance samples

SLUICE exclusions: detection switches for program-owned pool vaults, then the list of what the last snapshot removed

The project form with the tier editor: three example tiers with a name, a minimum held and a multiplier

The vocabulary screen: distribution, rewards, revenue share, dividend or yield, or twenty-two labels of your own, with the numbers unchanged

SLUICE operator settings with a sample fee wallet and a sample fee of 100 bps: the key never leaves your own signer

SLUICE on three iPhones: the holder snapshot, the dry-run report and the tier editor

Why a round holds up: determinism, documented rounding, resume without paying twice, re-derivation from the snapshot hash and CSV exports

The stack behind the Flutter console: Dart 3.11, Solana JSON-RPC, optional Helius enumeration, direct transfers verified on chain and Dexscreener market data

What SLUICE works with: any SPL token, Token-2022, Solana mainnet, your own RPC endpoint, four platforms; not for Ethereum, BNB Chain, Tron, claim pages or custody

SLUICE has no licence activation, no domain lock and no calls home: the full source code runs against your own endpoint

What the download includes and what you bring: Flutter source, tests and documentation against hosting, API plans and network fees

What you can change in the SLUICE source code: name, logo and bundle IDs, colours, wording, the operator fee, tiers and rules, and the endpoints

SLUICE documentation: Rebrand it in an afternoon

Paid setup service from MIKODES: web deploy, endpoints, rebranding, App Store and Google Play publishing, a macOS build and new features

Ask MIKODES for a setup quote through the CodeCanyon author page

Good to know before buying SLUICE: direct transfers only, you sign with your own tools, time-weighted samples, an operator tool, macOS and web on desktop, one operator per install

SLUICE FAQ: your wallet signs, a fee of up to 2% per round, the Extended licence when you charge, which wallets can sign, holder limits and six months of support

Which CodeCanyon licence SLUICE needs: Regular for your own project, Extended when you charge clients or take a fee

Buy SLUICE with confidence: try the live demo and docs, ask before buying, help if it does not run, Envato refund policy and free updates

SLUICE requirements: Flutter 3.41 and Dart 3.11, Android SDK 36 with JDK 17, Xcode 26 or newer for iOS and macOS, Chrome for the web build, your own Solana RPC endpoint, an optional Helius key and a funding wallet; no server

SLUICE documentation: Install and run it

Declarations for SLUICE: AI tools assisted and the author reviewed and tested every part, not affiliated with Solana or the providers, non-custodial with no key or server, not financial advice, preview images are demo-build captures

SLUICE v1.0.0, the first marketplace release of this Flutter source code for Solana token distribution

SLUICE 1.0.0 changelog: snapshots, exclusions, pro-rata and tiered allocation, the operator fee capped at 200 bps, verified transfer batches and the audit trail

SLUICE is current: version 1.0.0, Flutter 3.41, 415 passing automated tests and free updates

About MIKODES: a crypto source code studio with items on CodeCanyon since 2019 and 20 items in its portfolio

Why buy from MIKODES: answered questions, six months of support included, documentation written from the code, a live demo of this item and direct contact with the founder

Custom work by MIKODES: rebranding and setup, new features such as CSV import or automated rounds, and integrations such as a holder bot or a holder dashboard

Ask MIKODES for custom work through the CodeCanyon author page

MIKODES portfolio on CodeCanyon

Contact MIKODES through the author profile on CodeCanyon

See more MIKODES source-code items on CodeCanyon

Pre-sale questions go to the Comments tab of this item; buyers are supported through the Support tab

What ships with the item: documentation, a live demo, a changelog every release and item support

SLUICE is complete Flutter source code for running Solana airdrops and SPL token distributions: snapshot the holders, remove liquidity pools and burn wallets automatically, split the pool pro-rata or by tier, and pay every holder by direct transfer that your own wallet signs. You can charge an operator fee of up to 2% per round. No server and no keys in the code. Web, macOS, iOS and Android.

Live demo

AppLinkAccess
SLUICE console, web build (live demo)sluice-demo.mikodes.comThe real Flutter web build in demo mode: a DEMO strip on every screen, one sample round, no chain access, nothing can be signed or sent. Operator passcode: sluice-demo.
Documentationsluice-demo.mikodes.com/docs/Install, snapshots, exclusions, allocation, distribution, the fee and the audit trail. Public, no purchase needed.

Demo instructions

Open sluice-demo.mikodes.com. It is the real Flutter web build, compiled in demo mode (SLUICE_DEMO=true).

  • E-mail and password: none – the app has no accounts and no server to sign in to.
  • Operator passcode: sluice-demo – the console asks for it first. In the demo the operator settings are read-only, so one visitor cannot change what the next one sees.
  • What you can see there: one sample round, the SLUICE Demo Pool: 22 sample addresses (every one starts with Demo), of which 2 are excluded (the pool vault and the treasury), 20 are eligible holders and 18 are paid after the per-holder minimum. Every figure is computed by the product from that sample set. The demo reads no chain and connects no wallet, so nothing can be signed or sent. Recording a balance sample is disabled in the demo (the sample project already carries 30 daily samples), and only the sample project can be dry-run, because the demo reads no chain.
  • Documentation – sign-in: none. sluice-demo.mikodes.com/docs/ is public.

Costs not included in the price

The item price covers the source code and its documentation. Third-party API services such as Solana RPC providers or Helius may involve usage costs, which are the buyer’s responsibility; they are billed separately, by their providers, on your own accounts. Check each provider’s current pricing.

  • Solana JSON-RPC provider (Helius, QuickNode, Alchemy or your own node): needed to read holders and confirm signatures; its plan above the free tier is billed by the provider to you.
  • Helius API key (optional) for paginated holder enumeration: the free tier covers most holder sets; very large ones need a paid plan.
  • Dexscreener public API, used to label pool vaults for exclusions: keyless and free to call, no account; its rate limits apply. If it cannot be reached the round still works and says which check did not run.
  • Static web hosting and a domain, only if you host the web build: paid by you.
  • Apple Developer Program (yearly membership) and Google Play Console (one-time registration fee), only to publish the iOS, macOS or Android apps: paid by you.
  • Solana network fees and token-account rent for every distribution: paid by your funding wallet, which signs; the dry run estimates them first.

Not needed at all: a WalletConnect / Reown project, Firebase, an on-chain program, a database or a server. SLUICE has no backend.

Features

  • Snapshot: holders at the current slot, or time-weighted over a window of 1 to 365 days from balance samples you record; one holder per wallet.
  • Exclusions: pool vaults found by how they are owned (an off-curve authority has no private key), an AMM program registry you can verify on chain, burn addresses and your own list.
  • Allocation: pro-rata or by tier (balance multipliers or fixed shares), in integer base units with a documented rounding rule.
  • Payout: unsigned direct-transfer batches (TransferChecked with Compute Budget) for your own signer; a batch counts as paid only when its finalized transaction matches exactly.
  • Operator fee: a percentage, a flat amount or both per round, capped at 2% (200 bps) in code, paid as its own transfer and never skipped silently.
  • Audit: dry run with evidence for every figure, round journal and safe resume, tamper check on the stored snapshot, CSV and JSON exports and an audit bundle.

Screenshots and preview images show the demo build: one sample round with sample holder addresses (all starting with Demo), every figure computed by the product, the DEMO strip left in frame. They are presentation material, are not part of the download, and no figure in them is a promise of a result. Device frames are illustrations.

Good to know before you buy

  • Payouts are direct SPL transfers from your funding wallet. There is no claim page and no on-chain program.
  • SLUICE prepares unsigned transfer batches as JSON; no signing script ships. You sign them with tooling you control (your own script, a hardware-wallet flow or a multisig) and paste the signatures back, and SLUICE verifies each batch on chain.
  • Balances cannot be read at a past date from a normal RPC. For a time-weighted round, record balance samples during the window (for example once a day).
  • It is an operator tool, not an app for holders: holders do nothing and need no app.
  • Desktop targets are macOS and the web; Windows and Linux desktop builds are not configured.
  • There are no user accounts: one operator per install, behind a passcode.

FAQ

Does SLUICE ever hold the pool or a private key?
No. It hands over unsigned instruction batches for your own signing tooling, and a test asserts that no shipped source carries an API key or a fee wallet. The funding wallet that holds the pool stays yours.

How does the operator earn from it?
You set a fee per round: a percentage, a flat amount, or both, up to 2% of the round combined, enforced in code. It is taken from the funded pool before division and sent to your own wallet as its own transfer. It ships at zero with no wallet set, so a fresh install charges nothing. What it comes to depends on the rounds you run.

What stops a holder arguing with the result?
Every figure in the dry run names the evidence it was measured from, the round re-derives from its stored snapshot hash, each paid batch is checked against its on-chain transaction, and the audit bundle lets anyone re-run the division. Where the numbers do not settle a question, the report says so instead of guessing.

How are holders paid?
By direct SPL transfers from the funding wallet, prepared as unsigned batches for your own wallet to sign. Holders do not have to do anything, and no on-chain program is needed. After signing, you attach each signature to its batch and SLUICE checks the transaction on chain before it counts the batch as paid.

Can I weight holders by tier or by time held?
Yes. Tiers are edited in the project form (balance multipliers or fixed portions of the pool). For time weighting, record balance samples in the console during the window – for example once a day – and run the dry run over the last N days. A past balance cannot be read on an ordinary RPC endpoint, so samples have to be taken during the window.

What happens if a distribution is interrupted?
The round journal records what was finalised. On resume a finalised batch is never handed out again, checked by recipient rather than by position, and the operator fee batch is covered by the same rule.

Can I change the wording for my own community?
Yes. Five presets (distribution, rewards, revenue share, dividend, yield) or twenty-two labels of your own. They rename the main labels (the action button, the project form, the dry-run report, the holder ledger and the rate figures); engine warnings, batch states and exports keep the default words, and the documentation lists which is which. A test renders the dry run under every preset and requires the same numbers, so the words never move a figure.

What is not included?
Hosting, a domain or any backend – SLUICE has none by design; third-party API plans and developer accounts; blockchain network fees and token-account rent, which the funding wallet pays and the dry run estimates first. SLUICE pays by direct transfer only, and it does not read balances at a past slot.

What support is included?
Six months of item support from the purchase date are included with the purchase under Envato’s item support policy, and the support period can be extended through Envato. Support covers questions about how the item works and fixes for bugs in the code as delivered; customisation, third-party services and your own hosting are not. Never send private keys, seed phrases, keystores or API keys in a support message – they are never needed and will never be asked for.

Regular or Extended licence?
Use the Regular licence when nobody is charged for using your deployment, for example airdrops for your own token. If you charge anyone, including an operator fee taken from a client project’s pool, you need the Extended licence under Envato’s licence terms.

Credits
Solana, Token-2022, Helius, Dexscreener and Solscan are named to describe compatibility; the names and marks belong to their owners. No font file is bundled – the app uses the platform UI font – and the icons are Material Icons shipped with the Flutter SDK. Every Dart package used is listed with its licence in the credits page of the documentation and in the third-party licence file in the download.

Which wallets can sign the payouts?
SLUICE never signs. It exports each batch as unsigned instructions in JSON, and you sign with tooling you control: a script of your own, a hardware-wallet flow or a multisig. No signing script ships with the item. You then attach each signature and SLUICE checks the transaction on chain before it counts the batch as paid.

How many holders can it handle?
The public default endpoint works for small holder sets. For large ones use an RPC endpoint on your own account and, optionally, a Helius key for paginated holder enumeration; the free tier covers most sets.

Declarations

  • AI tools: yes. AI tools were used to assist with parts of the code, documentation and graphics of this item. The author directed, reviewed and tested every part before release: flutter analyze reports no issues and flutter test passes, including tests that assert no API key, credential or fee wallet is in the shipped source and that every figure shown is measured rather than projected. The dependencies are the public packages listed in pubspec.yaml and licenses/THIRD-PARTY-LICENSES.md.
  • Not affiliated: Solana, the SPL Token programs, Helius, QuickNode, Alchemy, Dexscreener, Solscan, Apple, Google and Flutter are third parties, named or shown only to describe compatibility. This item is not affiliated with, endorsed by or sponsored by any of them; the names, logos and marks belong to their owners.
  • Non-custodial and keyless: SLUICE holds no private key, produces no signature and has no server: it emits unsigned instruction batches as JSON for the project’s own wallet to sign. The console that sets the projects, the funding wallet and the operator fee is compiled in only with an operator passcode and opens only after it is entered. The operator fee ships at a zero rate with an empty wallet, and its ceiling is a constant in the code rather than a form rule. No author ID, API key or wallet address ships in the download.
  • Distributions and the law: distributing tokens, revenue shares or holder rewards is regulated differently from country to country. This item is software, not legal, tax or financial advice, and every figure it shows is measured from public on-chain data, never a forecast.
  • Preview material: the screenshots, the cover and the preview images are real captures of this item’s demo build (SLUICE_DEMO=true), composed by the author’s own build scripts. The holder set in them is sample data whose addresses all start with Demo; every figure is computed by the product from it. They are presentation material, not part of the download, and no figure in them is a result or a forecast.

Requirements

  • Flutter 3.41 or newer on the stable channel (Dart 3.11.1 or newer). pubspec.yaml declares Flutter >=3.41.0 as its lower bound; verified with Flutter 3.41.4 and Dart 3.11.1
  • Android builds: Android Studio Narwhal 2025.1.1 or newer, Android SDK Platform 36 (compileSdk = 36), Android Gradle Plugin 8.11.1, Gradle 8.14 and JDK 17
  • macOS and iOS builds: Xcode 26 or newer on a Mac (checked with Xcode 26.4.1 and Xcode 27.1). macOS 12.0 minimum, iOS 15.0 minimum. Windows and Linux targets are not configured; on a Windows PC run the shell commands from WSL or Git Bash
  • Web build: a current Google Chrome. A browser has no keystore, so the endpoints and the Helius key typed into the web build last for the session
  • A Solana JSON-RPC endpoint on your own account – the shared public endpoint rate limits hard and often refuses getProgramAccounts
  • An optional Helius API key for paginated holder enumeration (the free tier covers most holder sets); without it SLUICE falls back to getProgramAccounts, which is the first call to fail on a large holder set
  • A funding wallet that holds the pool and signs every batch – SLUICE never holds its key – and signing tooling you control (a script, a hardware wallet or a multisig)
  • No on-chain program is needed: every recipient is paid by a direct SPL transfer from the funding wallet
  • No Node.js, database or server is needed: SLUICE has no backend

Changelog

v1.0.0 (first release)

  • First marketplace release: the engine and the operator console.
  • Snapshot at the current slot, or time-weighted over a window from balance samples recorded in the console.
  • Exclusions by off-curve detection, an AMM program registry, burn addresses and operator lists.
  • Pro-rata and tiered computation (with a tier editor) in integer base units with documented rounding and dust rules.
  • An operator fee that ships empty, is capped at 200 basis points in code and is transferred as its own batch.
  • Direct transfer batches with Compute Budget instructions, each verified on chain against its recorded transfers before it counts as paid.
  • Dry run, audit trail, audit bundle, reproducibility check, round journal and resume.
  • Five vocabulary presets.
  • The SLUICE product icon on every platform.
  • The console is compiled in only with an operator passcode.
  • The web build has a strict Content-Security-Policy and stores no key or endpoint.
  • The full release notes are a page in the documentation.
AuthorMikodes
Price$199
Sales0
Rating0 (0)
PublishedNov 3, 2026
Last UpdateNov 3, 2026
Compatible SoftwareFlutter 3.x
Demo Urlhttps://sluice-demo.mikodes.com
Mobile Files IncludedDart, YAML, JavaScript JSON, .java, .kotlin, .plist, .swift

Categories

Tags

airdropaudit-trailcrypto-payoutsdartdefiflutterholder-rewardsnon-custodialrevenue-sharesnapshotsolanaspl-tokentiered-rewardstoken-distributionweb3

External listing. code.market does not sell this product and does not process payment for it. Pricing, payment, delivery, licensing, refunds, and support are handled by the third-party merchant on its own website. We may earn an affiliate commission from a referral. Details.