- pnpm workspace, shared tsconfig, vitest - common: ids, money (USDC base-unit math), Result/SettleKitError, time - domain types: product, customer, payment, entitlement, delivery, integration - 13 passing contract tests
1915 lines
32 KiB
Markdown
1915 lines
32 KiB
Markdown
Yes. The product becomes much stronger if it is **not only “crypto checkout”**, but a full **developer revenue operating system**.
|
||
|
||
The key idea:
|
||
|
||
> People should use this because it does the annoying work after payment: GitHub access, SaaS seats, API keys, license keys, subscriptions, file delivery, usage billing, customer portal, webhooks, and agent payments.
|
||
|
||
Payments alone are not enough. **Access automation is the product.**
|
||
|
||
I will expand the product as **SettleKit Commerce OS**.
|
||
|
||
---
|
||
|
||
# 1. New product positioning
|
||
|
||
## Old idea
|
||
|
||
```text
|
||
USDC checkout for Arc
|
||
```
|
||
|
||
Good, but too small.
|
||
|
||
## Better product
|
||
|
||
```text
|
||
SettleKit is the commerce OS for developers selling software, private repos,
|
||
SaaS, APIs, AI tools, datasets, templates, licenses, and agent services in USDC.
|
||
```
|
||
|
||
## Strong one-liner
|
||
|
||
> **Sell anything a developer can build: private GitHub repos, SaaS plans, APIs, AI tools, datasets, templates, licenses, Discord access, and agent services — with USDC checkout, automatic access delivery, and Arc/Circle payments.**
|
||
|
||
## What people actually need
|
||
|
||
Developers do not only need payment. They need:
|
||
|
||
```text
|
||
Payment → access → usage tracking → renewal → revocation → support → analytics
|
||
```
|
||
|
||
SettleKit should own that full flow.
|
||
|
||
---
|
||
|
||
# 2. Product should support these sale types
|
||
|
||
SettleKit should let sellers create these product types:
|
||
|
||
```ts
|
||
type ProductType =
|
||
| "saas_plan"
|
||
| "github_repo_access"
|
||
| "github_org_team_access"
|
||
| "api_access"
|
||
| "paid_api_call"
|
||
| "ai_agent_service"
|
||
| "digital_download"
|
||
| "code_template"
|
||
| "dataset"
|
||
| "license_key"
|
||
| "private_package"
|
||
| "discord_access"
|
||
| "support_plan"
|
||
| "course_or_content"
|
||
| "consulting_slot"
|
||
| "escrow_task";
|
||
```
|
||
|
||
This makes the platform feel necessary.
|
||
|
||
A developer should open SettleKit and think:
|
||
|
||
> “I can monetize my whole developer business here.”
|
||
|
||
---
|
||
|
||
# 3. Main product expansion
|
||
|
||
## Product 1 — GitHub repo sales
|
||
|
||
This is one of the strongest features.
|
||
|
||
### What sellers can sell
|
||
|
||
```text
|
||
- Private GitHub repo access
|
||
- Premium open-source repo access
|
||
- Paid starter templates
|
||
- Paid boilerplates
|
||
- Private SDKs
|
||
- Private AI agent code
|
||
- Private trading bots
|
||
- Private SaaS templates
|
||
- Private automation scripts
|
||
- Private course/project repositories
|
||
- Premium examples for open-source projects
|
||
```
|
||
|
||
### Seller flow
|
||
|
||
```text
|
||
1. Seller connects GitHub
|
||
2. Seller installs SettleKit GitHub App
|
||
3. Seller selects repo or organization team
|
||
4. Seller creates price:
|
||
- one-time
|
||
- monthly
|
||
- yearly
|
||
- lifetime
|
||
5. SettleKit creates hosted checkout page
|
||
6. Buyer pays in USDC
|
||
7. Buyer enters GitHub username
|
||
8. SettleKit invites buyer to repo/team
|
||
9. Buyer gets access page + receipt
|
||
10. If subscription expires, SettleKit removes access
|
||
```
|
||
|
||
### Buyer flow
|
||
|
||
```text
|
||
1. Open checkout link
|
||
2. Pay 25 USDC
|
||
3. Enter GitHub username
|
||
4. Accept GitHub invite
|
||
5. Access private repo
|
||
6. Receive updates while subscription is active
|
||
```
|
||
|
||
### Important honesty
|
||
|
||
For private repos, you can revoke **future access and updates**, but you cannot stop someone from using code they already cloned. So position it as:
|
||
|
||
```text
|
||
Paid access to private repo, updates, issues, releases, support, license key,
|
||
and community — not perfect DRM.
|
||
```
|
||
|
||
### Features needed
|
||
|
||
```text
|
||
- GitHub App install
|
||
- Repo selector
|
||
- Team selector
|
||
- Buyer GitHub username collection
|
||
- Invite buyer to repo
|
||
- Add buyer to team
|
||
- Remove buyer on expiry/refund
|
||
- Sync access every day
|
||
- License key attached to repo purchase
|
||
- Seat limits
|
||
- Access logs
|
||
- GitHub webhook support
|
||
- Failed invite handling
|
||
```
|
||
|
||
### Why people need it
|
||
|
||
Today a developer selling a private repo usually needs:
|
||
|
||
```text
|
||
Gumroad/LemonSqueezy/Polar + manual GitHub invite + spreadsheet + email + license keys
|
||
```
|
||
|
||
SettleKit makes it:
|
||
|
||
```text
|
||
Connect GitHub → create price → share link → access is automatic
|
||
```
|
||
|
||
That is a real painkiller.
|
||
|
||
---
|
||
|
||
# 4. Product 2 — SaaS plan purchases
|
||
|
||
SettleKit should let SaaS companies sell plans with USDC.
|
||
|
||
## What sellers can sell
|
||
|
||
```text
|
||
- SaaS subscriptions
|
||
- Lifetime deals
|
||
- Team seats
|
||
- Usage-based credits
|
||
- API access plans
|
||
- Premium feature unlocks
|
||
- Pro dashboard access
|
||
- White-label plans
|
||
```
|
||
|
||
## Seller flow
|
||
|
||
```text
|
||
1. Seller creates SaaS product
|
||
2. Seller creates plans:
|
||
- Free
|
||
- Pro
|
||
- Team
|
||
- Business
|
||
3. Seller defines entitlements:
|
||
- max_projects = 10
|
||
- max_api_calls = 100000
|
||
- feature_ai_export = true
|
||
- team_seats = 5
|
||
4. Seller installs SDK in their SaaS app
|
||
5. Buyer pays in USDC
|
||
6. Seller app checks entitlement through SettleKit
|
||
7. Buyer gets access instantly
|
||
```
|
||
|
||
## SaaS SDK example
|
||
|
||
```ts
|
||
import { settlekit } from "@settlekit/sdk";
|
||
|
||
const entitlement = await settlekit.entitlements.verify({
|
||
customerId: user.id,
|
||
feature: "ai_export",
|
||
});
|
||
|
||
if (!entitlement.allowed) {
|
||
throw new Error("Upgrade required");
|
||
}
|
||
```
|
||
|
||
## React paywall component
|
||
|
||
```tsx
|
||
import { Paywall } from "@settlekit/react";
|
||
|
||
export function ExportButton() {
|
||
return (
|
||
<Paywall feature="ai_export" fallback={<UpgradeButton />}>
|
||
<button>Export with AI</button>
|
||
</Paywall>
|
||
);
|
||
}
|
||
```
|
||
|
||
## SaaS features
|
||
|
||
```text
|
||
- Plan creation
|
||
- Seat management
|
||
- Organization billing
|
||
- Team invites
|
||
- Feature flags
|
||
- Entitlements
|
||
- Usage limits
|
||
- Renewal reminders
|
||
- Grace periods
|
||
- Upgrade/downgrade
|
||
- Customer portal
|
||
- Webhook events
|
||
```
|
||
|
||
## Why people need it
|
||
|
||
Crypto-native SaaS founders do not want to build billing, entitlement logic, license checks, renewal pages, and payment verification themselves.
|
||
|
||
SettleKit gives them:
|
||
|
||
```text
|
||
USDC checkout + subscription logic + access control + SDK
|
||
```
|
||
|
||
---
|
||
|
||
# 5. Product 3 — Paid APIs and x402 agent payments
|
||
|
||
This is your most unique Circle/Arc feature.
|
||
|
||
## What sellers can sell
|
||
|
||
```text
|
||
- Paid API calls
|
||
- AI model calls
|
||
- Dataset queries
|
||
- Web search API calls
|
||
- Code review API calls
|
||
- Market data
|
||
- Onchain analytics
|
||
- Image generation calls
|
||
- Agent tools
|
||
- Scraping endpoints
|
||
- Research endpoints
|
||
```
|
||
|
||
## Developer flow
|
||
|
||
```text
|
||
1. Developer creates paid API product
|
||
2. Developer sets price:
|
||
- 0.001 USDC per call
|
||
- 0.01 USDC per request
|
||
- 5 USDC per 10,000 credits
|
||
3. Developer wraps API route with SettleKit middleware
|
||
4. Human or AI agent calls endpoint
|
||
5. Endpoint returns HTTP 402 Payment Required
|
||
6. Buyer/agent pays
|
||
7. Endpoint returns response
|
||
8. Usage and revenue show in dashboard
|
||
```
|
||
|
||
## SDK example
|
||
|
||
```ts
|
||
import { withSettleKitPayment } from "@settlekit/x402";
|
||
|
||
export const GET = withSettleKitPayment({
|
||
price: "0.005",
|
||
currency: "USDC",
|
||
productId: "prod_research_api",
|
||
})(async function handler(req) {
|
||
return Response.json({
|
||
answer: "Paid research result",
|
||
});
|
||
});
|
||
```
|
||
|
||
## Why people need it
|
||
|
||
API businesses usually force buyers into:
|
||
|
||
```text
|
||
monthly subscription + API key + prepaid plan
|
||
```
|
||
|
||
But AI agents need:
|
||
|
||
```text
|
||
discover endpoint → pay small amount → get result
|
||
```
|
||
|
||
SettleKit should make paid APIs as easy as adding middleware.
|
||
|
||
---
|
||
|
||
# 6. Product 4 — Digital product sales
|
||
|
||
This makes the product useful beyond SaaS.
|
||
|
||
## What sellers can sell
|
||
|
||
```text
|
||
- PDF guides
|
||
- Courses
|
||
- Code templates
|
||
- Figma files
|
||
- Notion templates
|
||
- AI prompt packs
|
||
- Dataset files
|
||
- CSV exports
|
||
- Research reports
|
||
- Plugin downloads
|
||
- Boilerplate ZIPs
|
||
```
|
||
|
||
## Features
|
||
|
||
```text
|
||
- Upload file
|
||
- Create product page
|
||
- Set price in USDC
|
||
- Buyer pays
|
||
- Buyer gets signed download link
|
||
- Download expires
|
||
- Download count limit
|
||
- Receipt
|
||
- Customer portal
|
||
- Refund request
|
||
```
|
||
|
||
## Delivery rules
|
||
|
||
```text
|
||
- Expire link after 24 hours
|
||
- Limit to 5 downloads
|
||
- Allow merchant to regenerate link
|
||
- Revoke access after refund
|
||
```
|
||
|
||
## Why people need it
|
||
|
||
This competes with Gumroad-style flows, but with USDC and developer-native delivery.
|
||
|
||
---
|
||
|
||
# 7. Product 5 — License key system
|
||
|
||
License keys are essential for software sellers.
|
||
|
||
## What sellers can sell
|
||
|
||
```text
|
||
- Desktop apps
|
||
- CLI tools
|
||
- SaaS add-ons
|
||
- WordPress/plugins
|
||
- VS Code extensions
|
||
- AI tools
|
||
- Private SDKs
|
||
- Trading bots
|
||
- Automation software
|
||
```
|
||
|
||
## License key features
|
||
|
||
```text
|
||
- Generate license key after payment
|
||
- Validate license from app
|
||
- Machine activation limits
|
||
- Domain activation limits
|
||
- Expiration date
|
||
- Renewal date
|
||
- Revoke key
|
||
- Rotate key
|
||
- Offline validation token
|
||
- Customer portal view
|
||
```
|
||
|
||
## SDK example
|
||
|
||
```ts
|
||
const valid = await settlekit.licenseKeys.verify({
|
||
licenseKey: userLicenseKey,
|
||
productId: "prod_cli_tool",
|
||
machineId: machineFingerprint,
|
||
});
|
||
|
||
if (!valid.active) {
|
||
throw new Error("Invalid license");
|
||
}
|
||
```
|
||
|
||
## Why people need it
|
||
|
||
Developers selling paid software need license logic. Most do not want to build it.
|
||
|
||
SettleKit gives:
|
||
|
||
```text
|
||
Payment + key generation + verification API + customer portal
|
||
```
|
||
|
||
---
|
||
|
||
# 8. Product 6 — Private package access
|
||
|
||
This is another developer-specific feature.
|
||
|
||
## What sellers can sell
|
||
|
||
```text
|
||
- Private npm packages
|
||
- Private Python packages
|
||
- Private SDKs
|
||
- Paid libraries
|
||
- Internal templates
|
||
- Premium components
|
||
```
|
||
|
||
## Possible access methods
|
||
|
||
```text
|
||
- GitHub Packages access
|
||
- Private npm registry integration later
|
||
- Token-based package download
|
||
- Private release download
|
||
- Signed artifact links
|
||
```
|
||
|
||
## Buyer flow
|
||
|
||
```text
|
||
1. Buyer pays
|
||
2. Buyer receives package token/instructions
|
||
3. Buyer installs package
|
||
4. Subscription controls whether token remains valid
|
||
```
|
||
|
||
Example:
|
||
|
||
```bash
|
||
npm install @seller/premium-sdk
|
||
```
|
||
|
||
But access only works if the buyer has an active entitlement.
|
||
|
||
---
|
||
|
||
# 9. Product 7 — Discord/community access
|
||
|
||
Many developer products include community access.
|
||
|
||
## Seller flow
|
||
|
||
```text
|
||
1. Seller connects Discord
|
||
2. Seller selects server
|
||
3. Seller selects paid role
|
||
4. Buyer pays
|
||
5. Buyer connects Discord
|
||
6. SettleKit assigns role
|
||
7. Role is removed on expiry/refund
|
||
```
|
||
|
||
## What this supports
|
||
|
||
```text
|
||
- Paid support communities
|
||
- Private founder groups
|
||
- Premium AI tool communities
|
||
- Course communities
|
||
- Private alpha groups
|
||
- Developer support channels
|
||
```
|
||
|
||
This pairs well with GitHub repo sales:
|
||
|
||
```text
|
||
Buy repo → get GitHub access + Discord support + license key
|
||
```
|
||
|
||
---
|
||
|
||
# 10. Product 8 — Support plans
|
||
|
||
Developers and open-source maintainers can sell support.
|
||
|
||
## What sellers can sell
|
||
|
||
```text
|
||
- Priority support
|
||
- Private support channel
|
||
- Monthly office hours
|
||
- Bugfix retainers
|
||
- Consulting packages
|
||
- Code review packages
|
||
- Installation help
|
||
```
|
||
|
||
## Features
|
||
|
||
```text
|
||
- Support plan checkout
|
||
- Support entitlement
|
||
- Discord/GitHub issue label access
|
||
- Support SLA display
|
||
- Renewal reminders
|
||
- Customer portal
|
||
```
|
||
|
||
Example product:
|
||
|
||
```text
|
||
Premium Support for Open Source Library
|
||
Price: 99 USDC/month
|
||
Includes:
|
||
- Private Discord channel
|
||
- Priority GitHub issue response
|
||
- Monthly office hour
|
||
```
|
||
|
||
This is very useful for open-source maintainers.
|
||
|
||
---
|
||
|
||
# 11. Product 9 — Agent service marketplace
|
||
|
||
This is the future-facing part.
|
||
|
||
## What sellers list
|
||
|
||
```text
|
||
- Paid APIs
|
||
- AI tools
|
||
- Agent tools
|
||
- Research agents
|
||
- Data agents
|
||
- Code review agents
|
||
- Deployment agents
|
||
- Workflow agents
|
||
```
|
||
|
||
## Human-readable listing
|
||
|
||
```text
|
||
Name: Legal Document Parser
|
||
Price: 0.05 USDC/request
|
||
Input: PDF
|
||
Output: JSON summary
|
||
Payment: x402
|
||
Network: Arc
|
||
```
|
||
|
||
## Agent-readable listing
|
||
|
||
```json
|
||
{
|
||
"name": "Legal Document Parser",
|
||
"description": "Parses legal PDFs into structured JSON",
|
||
"price": "0.05",
|
||
"currency": "USDC",
|
||
"paymentProtocol": "x402",
|
||
"network": "arc",
|
||
"endpoint": "https://api.example.com/parse",
|
||
"inputSchema": {
|
||
"type": "object",
|
||
"properties": {
|
||
"pdfUrl": { "type": "string" }
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
## Why people need it
|
||
|
||
AI agents need a way to discover paid tools. Developers need a way to sell tools to agents.
|
||
|
||
SettleKit becomes:
|
||
|
||
```text
|
||
Marketplace + payment protocol + access layer
|
||
```
|
||
|
||
That is much stronger than checkout alone.
|
||
|
||
---
|
||
|
||
# 12. Product 10 — Escrow tasks for agents and freelancers
|
||
|
||
This can be a later but powerful product.
|
||
|
||
## What buyers can buy
|
||
|
||
```text
|
||
- Code review task
|
||
- Bug fix task
|
||
- Data cleaning task
|
||
- Research task
|
||
- Deployment task
|
||
- Website generation task
|
||
- AI agent job
|
||
```
|
||
|
||
## Flow
|
||
|
||
```text
|
||
1. Buyer creates task
|
||
2. Buyer funds escrow in USDC
|
||
3. Human or AI agent accepts task
|
||
4. Worker submits result
|
||
5. Buyer approves
|
||
6. Funds release
|
||
7. If rejected, refund/dispute path starts
|
||
```
|
||
|
||
This makes SettleKit not only a checkout system, but a commerce network for autonomous work.
|
||
|
||
---
|
||
|
||
# 13. Bundle products together
|
||
|
||
This is how you make people really need it.
|
||
|
||
Do not sell features separately. Let sellers create **bundles**.
|
||
|
||
## Example bundle 1 — SaaS starter kit seller
|
||
|
||
```text
|
||
Product: AI SaaS Boilerplate Pro
|
||
Price: 149 USDC one-time
|
||
|
||
Includes:
|
||
- Private GitHub repo access
|
||
- License key
|
||
- ZIP download
|
||
- Discord support role for 90 days
|
||
- Future repo updates for 1 year
|
||
```
|
||
|
||
## Example bundle 2 — paid AI API
|
||
|
||
```text
|
||
Product: Research API Pro
|
||
Price: 20 USDC prepaid credits
|
||
|
||
Includes:
|
||
- API key
|
||
- 20,000 API credits
|
||
- x402 pay-per-call support
|
||
- Usage dashboard
|
||
```
|
||
|
||
## Example bundle 3 — open-source maintainer
|
||
|
||
```text
|
||
Product: Premium Support
|
||
Price: 99 USDC/month
|
||
|
||
Includes:
|
||
- Private Discord channel
|
||
- Priority GitHub issue access
|
||
- Early release access
|
||
- 2 support tickets/month
|
||
```
|
||
|
||
## Example bundle 4 — B2B SaaS
|
||
|
||
```text
|
||
Product: Team Plan
|
||
Price: 300 USDC/month
|
||
|
||
Includes:
|
||
- 10 seats
|
||
- 1M API calls
|
||
- Premium features
|
||
- Customer portal
|
||
- Webhook integration
|
||
```
|
||
|
||
Bundles are important because they make SettleKit more than “checkout.”
|
||
|
||
---
|
||
|
||
# 14. The core engine: Universal Entitlements
|
||
|
||
This is the most important architecture idea.
|
||
|
||
Everything should become an entitlement.
|
||
|
||
```text
|
||
Payment gives entitlement.
|
||
Entitlement gives access.
|
||
Access can be GitHub, SaaS, API, file, Discord, license, package, or agent tool.
|
||
```
|
||
|
||
## Entitlement examples
|
||
|
||
```json
|
||
{
|
||
"customerId": "cus_123",
|
||
"productId": "prod_ai_saas_template",
|
||
"entitlementType": "github_repo_access",
|
||
"resourceId": "github_repo_456",
|
||
"status": "active",
|
||
"expiresAt": "2026-12-31T00:00:00Z"
|
||
}
|
||
```
|
||
|
||
```json
|
||
{
|
||
"customerId": "cus_789",
|
||
"productId": "prod_research_api",
|
||
"entitlementType": "api_credits",
|
||
"creditsRemaining": 10000,
|
||
"status": "active"
|
||
}
|
||
```
|
||
|
||
```json
|
||
{
|
||
"customerId": "cus_555",
|
||
"productId": "prod_saas_pro",
|
||
"entitlementType": "saas_feature",
|
||
"features": {
|
||
"ai_export": true,
|
||
"team_seats": 5,
|
||
"max_projects": 20
|
||
}
|
||
}
|
||
```
|
||
|
||
This one concept powers the whole product.
|
||
|
||
---
|
||
|
||
# 15. Product objects
|
||
|
||
Your system should have these main objects.
|
||
|
||
```text
|
||
Organization
|
||
User
|
||
Merchant
|
||
Customer
|
||
Product
|
||
Price
|
||
Bundle
|
||
CheckoutSession
|
||
Payment
|
||
Subscription
|
||
UsageMeter
|
||
CreditBalance
|
||
Entitlement
|
||
DeliveryAction
|
||
LicenseKey
|
||
ApiKey
|
||
GitHubInstallation
|
||
GitHubRepoAccess
|
||
DiscordRoleAccess
|
||
FileAsset
|
||
WebhookEndpoint
|
||
MarketplaceListing
|
||
AgentService
|
||
EscrowTask
|
||
PayoutWallet
|
||
RiskProfile
|
||
```
|
||
|
||
## Product
|
||
|
||
```ts
|
||
type Product = {
|
||
id: string;
|
||
merchantId: string;
|
||
name: string;
|
||
description: string;
|
||
type: ProductType;
|
||
status: "draft" | "active" | "archived";
|
||
deliveryMode: DeliveryMode;
|
||
};
|
||
```
|
||
|
||
## Price
|
||
|
||
```ts
|
||
type Price = {
|
||
id: string;
|
||
productId: string;
|
||
amount: string;
|
||
currency: "USDC";
|
||
interval?: "one_time" | "monthly" | "yearly";
|
||
usageBased?: boolean;
|
||
};
|
||
```
|
||
|
||
## Delivery action
|
||
|
||
```ts
|
||
type DeliveryAction =
|
||
| { type: "github_invite"; repoId: string }
|
||
| { type: "github_team_add"; teamId: string }
|
||
| { type: "license_key_create"; policyId: string }
|
||
| { type: "api_key_create"; scopes: string[] }
|
||
| { type: "file_access_grant"; fileId: string }
|
||
| { type: "discord_role_add"; roleId: string }
|
||
| { type: "saas_entitlement_create"; features: Record<string, unknown> }
|
||
| { type: "webhook_send"; url: string };
|
||
```
|
||
|
||
This lets one purchase trigger multiple actions.
|
||
|
||
---
|
||
|
||
# 16. New dashboard sections
|
||
|
||
Your merchant dashboard should expand to this:
|
||
|
||
```text
|
||
Dashboard
|
||
Products
|
||
Bundles
|
||
Checkout Links
|
||
Payments
|
||
Customers
|
||
Subscriptions
|
||
Usage Billing
|
||
Entitlements
|
||
License Keys
|
||
API Keys
|
||
Files
|
||
GitHub Access
|
||
Discord Access
|
||
SaaS Plans
|
||
Paid APIs
|
||
Agent Services
|
||
Marketplace
|
||
Webhooks
|
||
Payouts
|
||
Analytics
|
||
Settings
|
||
```
|
||
|
||
## Important page: Product builder
|
||
|
||
The product builder should ask:
|
||
|
||
```text
|
||
What are you selling?
|
||
|
||
[ ] SaaS plan
|
||
[ ] Private GitHub repo
|
||
[ ] API access
|
||
[ ] Paid API call
|
||
[ ] Digital download
|
||
[ ] License key
|
||
[ ] Discord/community access
|
||
[ ] AI agent service
|
||
[ ] Dataset
|
||
[ ] Bundle
|
||
```
|
||
|
||
Then it should ask:
|
||
|
||
```text
|
||
How should access be delivered?
|
||
|
||
[ ] Invite to GitHub repo
|
||
[ ] Add to GitHub team
|
||
[ ] Issue license key
|
||
[ ] Issue API key
|
||
[ ] Grant SaaS entitlement
|
||
[ ] Send webhook
|
||
[ ] Assign Discord role
|
||
[ ] Unlock file download
|
||
```
|
||
|
||
This is what makes the product feel powerful.
|
||
|
||
---
|
||
|
||
# 17. Folder expansion for this full product
|
||
|
||
Add these new packages and apps to the previous architecture.
|
||
|
||
```text
|
||
settlekit/
|
||
apps/
|
||
dashboard/
|
||
checkout/
|
||
api/
|
||
worker/
|
||
docs/
|
||
marketplace/
|
||
admin/
|
||
examples/
|
||
|
||
packages/
|
||
github/
|
||
discord/
|
||
saas/
|
||
delivery/
|
||
bundles/
|
||
entitlements/
|
||
license-keys/
|
||
api-keys/
|
||
file-delivery/
|
||
usage/
|
||
marketplace-core/
|
||
agent-services/
|
||
escrow/
|
||
payments/
|
||
arc/
|
||
circle/
|
||
x402/
|
||
webhooks/
|
||
risk/
|
||
notifications/
|
||
database/
|
||
common/
|
||
```
|
||
|
||
---
|
||
|
||
# 18. New package: `packages/github`
|
||
|
||
```text
|
||
packages/github/
|
||
src/
|
||
github-app-client.ts
|
||
github-oauth.ts
|
||
github-installations.ts
|
||
github-repositories.ts
|
||
github-teams.ts
|
||
github-invites.ts
|
||
github-access-granter.ts
|
||
github-access-revoker.ts
|
||
github-access-sync.ts
|
||
github-webhooks.ts
|
||
github-username-verification.ts
|
||
github-errors.ts
|
||
types.ts
|
||
|
||
test/
|
||
github-access-granter.test.ts
|
||
github-access-revoker.test.ts
|
||
github-access-sync.test.ts
|
||
|
||
package.json
|
||
```
|
||
|
||
## Responsibilities
|
||
|
||
```text
|
||
- Connect seller GitHub account/org
|
||
- Install GitHub App
|
||
- Fetch seller repos
|
||
- Fetch org teams
|
||
- Invite buyer to repo
|
||
- Add buyer to team
|
||
- Remove buyer after expiry
|
||
- Sync access status
|
||
- Handle failed invites
|
||
```
|
||
|
||
---
|
||
|
||
# 19. New package: `packages/discord`
|
||
|
||
```text
|
||
packages/discord/
|
||
src/
|
||
discord-client.ts
|
||
discord-oauth.ts
|
||
discord-guilds.ts
|
||
discord-roles.ts
|
||
discord-role-granter.ts
|
||
discord-role-revoker.ts
|
||
discord-access-sync.ts
|
||
discord-errors.ts
|
||
types.ts
|
||
|
||
test/
|
||
discord-role-granter.test.ts
|
||
discord-role-revoker.test.ts
|
||
|
||
package.json
|
||
```
|
||
|
||
## Responsibilities
|
||
|
||
```text
|
||
- Connect Discord server
|
||
- Select paid role
|
||
- Ask buyer to connect Discord
|
||
- Add role after payment
|
||
- Remove role on expiry/refund
|
||
```
|
||
|
||
---
|
||
|
||
# 20. New package: `packages/saas`
|
||
|
||
```text
|
||
packages/saas/
|
||
src/
|
||
saas-plan.ts
|
||
feature-flags.ts
|
||
seat-limits.ts
|
||
tenant-entitlements.ts
|
||
org-billing.ts
|
||
usage-limits.ts
|
||
customer-portal.ts
|
||
upgrade-downgrade.ts
|
||
grace-periods.ts
|
||
saas-webhooks.ts
|
||
types.ts
|
||
|
||
test/
|
||
feature-flags.test.ts
|
||
seat-limits.test.ts
|
||
tenant-entitlements.test.ts
|
||
|
||
package.json
|
||
```
|
||
|
||
## Responsibilities
|
||
|
||
```text
|
||
- SaaS plan definitions
|
||
- Feature entitlements
|
||
- Seat entitlements
|
||
- Usage limits
|
||
- Upgrade/downgrade logic
|
||
- Renewal/grace period logic
|
||
```
|
||
|
||
---
|
||
|
||
# 21. New package: `packages/delivery`
|
||
|
||
This is the action engine that runs after payment.
|
||
|
||
```text
|
||
packages/delivery/
|
||
src/
|
||
delivery-action.ts
|
||
delivery-plan.ts
|
||
delivery-runner.ts
|
||
delivery-status.ts
|
||
delivery-retry.ts
|
||
delivery-rollback.ts
|
||
delivery-logs.ts
|
||
|
||
actions/
|
||
grant-github-repo.ts
|
||
grant-github-team.ts
|
||
issue-license-key.ts
|
||
issue-api-key.ts
|
||
grant-file-access.ts
|
||
grant-discord-role.ts
|
||
create-saas-entitlement.ts
|
||
send-webhook.ts
|
||
send-email.ts
|
||
|
||
types.ts
|
||
errors.ts
|
||
|
||
test/
|
||
delivery-runner.test.ts
|
||
delivery-retry.test.ts
|
||
grant-github-repo.test.ts
|
||
|
||
package.json
|
||
```
|
||
|
||
## Why this matters
|
||
|
||
This package makes SettleKit powerful.
|
||
|
||
A purchase can trigger:
|
||
|
||
```text
|
||
payment.succeeded
|
||
→ grant GitHub access
|
||
→ issue license key
|
||
→ assign Discord role
|
||
→ create SaaS entitlement
|
||
→ send webhook
|
||
→ email buyer
|
||
```
|
||
|
||
---
|
||
|
||
# 22. New package: `packages/bundles`
|
||
|
||
```text
|
||
packages/bundles/
|
||
src/
|
||
bundle.ts
|
||
bundle-items.ts
|
||
bundle-pricing.ts
|
||
bundle-delivery-plan.ts
|
||
bundle-entitlements.ts
|
||
types.ts
|
||
|
||
test/
|
||
bundle-delivery-plan.test.ts
|
||
|
||
package.json
|
||
```
|
||
|
||
## Responsibilities
|
||
|
||
```text
|
||
- Create bundle products
|
||
- Attach many products to one checkout
|
||
- Generate many entitlements from one payment
|
||
```
|
||
|
||
Example:
|
||
|
||
```text
|
||
AI SaaS Template Bundle
|
||
- GitHub repo access
|
||
- License key
|
||
- Discord role
|
||
- File download
|
||
- 1 year of updates
|
||
```
|
||
|
||
---
|
||
|
||
# 23. New package: `packages/agent-services`
|
||
|
||
```text
|
||
packages/agent-services/
|
||
src/
|
||
agent-service.ts
|
||
agent-service-metadata.ts
|
||
agent-readable-schema.ts
|
||
agent-pricing.ts
|
||
agent-usage.ts
|
||
agent-discovery.ts
|
||
agent-reputation.ts
|
||
agent-payment-policy.ts
|
||
types.ts
|
||
|
||
test/
|
||
agent-service-metadata.test.ts
|
||
agent-pricing.test.ts
|
||
|
||
package.json
|
||
```
|
||
|
||
## Responsibilities
|
||
|
||
```text
|
||
- Let sellers list paid agent services
|
||
- Generate machine-readable metadata
|
||
- Connect agent service to x402 payment
|
||
- Track agent buyers and usage
|
||
```
|
||
|
||
---
|
||
|
||
# 24. New package: `packages/escrow`
|
||
|
||
```text
|
||
packages/escrow/
|
||
src/
|
||
escrow-task.ts
|
||
escrow-status.ts
|
||
escrow-funding.ts
|
||
escrow-release.ts
|
||
escrow-refund.ts
|
||
escrow-disputes.ts
|
||
task-submissions.ts
|
||
task-review.ts
|
||
types.ts
|
||
|
||
test/
|
||
escrow-release.test.ts
|
||
escrow-refund.test.ts
|
||
|
||
package.json
|
||
```
|
||
|
||
## Responsibilities
|
||
|
||
```text
|
||
- Fund task
|
||
- Assign worker/agent
|
||
- Submit work
|
||
- Approve work
|
||
- Release payment
|
||
- Refund if failed
|
||
```
|
||
|
||
This should be later, but it can become a big product.
|
||
|
||
---
|
||
|
||
# 25. Database additions
|
||
|
||
Add these tables.
|
||
|
||
```text
|
||
github_installations
|
||
github_repositories
|
||
github_teams
|
||
github_repo_access_grants
|
||
github_access_sync_runs
|
||
|
||
discord_connections
|
||
discord_guilds
|
||
discord_roles
|
||
discord_role_grants
|
||
|
||
saas_plans
|
||
saas_features
|
||
saas_seats
|
||
saas_entitlement_rules
|
||
|
||
bundles
|
||
bundle_items
|
||
|
||
delivery_plans
|
||
delivery_actions
|
||
delivery_runs
|
||
delivery_logs
|
||
|
||
agent_services
|
||
agent_service_metadata
|
||
agent_buyers
|
||
agent_usage_events
|
||
|
||
escrow_tasks
|
||
escrow_fundings
|
||
escrow_submissions
|
||
escrow_releases
|
||
escrow_disputes
|
||
```
|
||
|
||
---
|
||
|
||
# 26. API endpoints to add
|
||
|
||
## GitHub
|
||
|
||
```text
|
||
POST /v1/integrations/github/installations
|
||
GET /v1/integrations/github/installations
|
||
GET /v1/integrations/github/repositories
|
||
GET /v1/integrations/github/teams
|
||
POST /v1/github/access/grant
|
||
POST /v1/github/access/revoke
|
||
POST /v1/github/access/sync
|
||
```
|
||
|
||
## Discord
|
||
|
||
```text
|
||
POST /v1/integrations/discord/connect
|
||
GET /v1/integrations/discord/guilds
|
||
GET /v1/integrations/discord/roles
|
||
POST /v1/discord/access/grant
|
||
POST /v1/discord/access/revoke
|
||
```
|
||
|
||
## SaaS
|
||
|
||
```text
|
||
POST /v1/saas/plans
|
||
GET /v1/saas/plans
|
||
POST /v1/saas/features
|
||
POST /v1/saas/entitlements/verify
|
||
POST /v1/saas/seats
|
||
POST /v1/saas/seats/remove
|
||
```
|
||
|
||
## Bundles
|
||
|
||
```text
|
||
POST /v1/bundles
|
||
GET /v1/bundles
|
||
GET /v1/bundles/:id
|
||
PATCH /v1/bundles/:id
|
||
POST /v1/bundles/:id/publish
|
||
```
|
||
|
||
## Delivery
|
||
|
||
```text
|
||
GET /v1/delivery-runs
|
||
GET /v1/delivery-runs/:id
|
||
POST /v1/delivery-runs/:id/retry
|
||
POST /v1/delivery-actions/test
|
||
```
|
||
|
||
## Agent services
|
||
|
||
```text
|
||
POST /v1/agent-services
|
||
GET /v1/agent-services
|
||
GET /v1/agent-services/:id
|
||
PATCH /v1/agent-services/:id
|
||
POST /v1/agent-services/:id/publish
|
||
GET /v1/agent-services/:id/metadata.json
|
||
```
|
||
|
||
## Escrow
|
||
|
||
```text
|
||
POST /v1/escrow/tasks
|
||
GET /v1/escrow/tasks
|
||
POST /v1/escrow/tasks/:id/fund
|
||
POST /v1/escrow/tasks/:id/submit
|
||
POST /v1/escrow/tasks/:id/approve
|
||
POST /v1/escrow/tasks/:id/refund
|
||
```
|
||
|
||
---
|
||
|
||
# 27. New dashboard pages
|
||
|
||
Add these to `apps/dashboard`.
|
||
|
||
```text
|
||
apps/dashboard/app/org/[orgSlug]/
|
||
github/
|
||
page.tsx
|
||
install/
|
||
page.tsx
|
||
repositories/
|
||
page.tsx
|
||
teams/
|
||
page.tsx
|
||
access/
|
||
page.tsx
|
||
|
||
discord/
|
||
page.tsx
|
||
servers/
|
||
page.tsx
|
||
roles/
|
||
page.tsx
|
||
access/
|
||
page.tsx
|
||
|
||
saas/
|
||
plans/
|
||
page.tsx
|
||
features/
|
||
page.tsx
|
||
seats/
|
||
page.tsx
|
||
entitlements/
|
||
page.tsx
|
||
|
||
bundles/
|
||
page.tsx
|
||
new/
|
||
page.tsx
|
||
[bundleId]/
|
||
page.tsx
|
||
|
||
delivery/
|
||
runs/
|
||
page.tsx
|
||
logs/
|
||
page.tsx
|
||
|
||
agent-services/
|
||
page.tsx
|
||
new/
|
||
page.tsx
|
||
[serviceId]/
|
||
page.tsx
|
||
|
||
escrow/
|
||
tasks/
|
||
page.tsx
|
||
[taskId]/
|
||
page.tsx
|
||
```
|
||
|
||
---
|
||
|
||
# 28. Product builder UX
|
||
|
||
The dashboard should have one main button:
|
||
|
||
```text
|
||
+ Create Product
|
||
```
|
||
|
||
Then show:
|
||
|
||
```text
|
||
What do you want to sell?
|
||
|
||
1. SaaS plan
|
||
2. Private GitHub repo
|
||
3. Private GitHub organization/team
|
||
4. API access
|
||
5. Paid API call
|
||
6. AI agent service
|
||
7. Digital download
|
||
8. Code template
|
||
9. License key
|
||
10. Discord/community access
|
||
11. Support plan
|
||
12. Bundle
|
||
```
|
||
|
||
Then:
|
||
|
||
```text
|
||
How do you want to charge?
|
||
|
||
1. One-time payment
|
||
2. Monthly subscription
|
||
3. Yearly subscription
|
||
4. Prepaid credits
|
||
5. Pay per API call
|
||
6. Custom quote
|
||
```
|
||
|
||
Then:
|
||
|
||
```text
|
||
What should happen after payment?
|
||
|
||
1. Invite buyer to GitHub repo
|
||
2. Add buyer to GitHub team
|
||
3. Issue license key
|
||
4. Issue API key
|
||
5. Grant SaaS feature access
|
||
6. Unlock file download
|
||
7. Assign Discord role
|
||
8. Send webhook to my app
|
||
9. Send email instructions
|
||
```
|
||
|
||
This UX makes the product easy to understand.
|
||
|
||
---
|
||
|
||
# 29. Make people need it: killer use cases
|
||
|
||
## Use case 1 — “Sell my private repo in 5 minutes”
|
||
|
||
Target:
|
||
|
||
```text
|
||
Indie hackers, template sellers, AI boilerplate sellers, open-source maintainers
|
||
```
|
||
|
||
Promise:
|
||
|
||
```text
|
||
Connect GitHub. Pick repo. Set price. Share link. We handle access.
|
||
```
|
||
|
||
This is probably your best first viral wedge.
|
||
|
||
---
|
||
|
||
## Use case 2 — “Add USDC billing to my SaaS without building billing”
|
||
|
||
Target:
|
||
|
||
```text
|
||
Crypto SaaS, Web3 SaaS, AI SaaS, B2B tools
|
||
```
|
||
|
||
Promise:
|
||
|
||
```text
|
||
Create plans, check entitlements, sell subscriptions, manage seats.
|
||
```
|
||
|
||
---
|
||
|
||
## Use case 3 — “Monetize my API with one middleware”
|
||
|
||
Target:
|
||
|
||
```text
|
||
API developers, data companies, AI tool builders
|
||
```
|
||
|
||
Promise:
|
||
|
||
```text
|
||
Wrap your endpoint. Agents and humans pay per call.
|
||
```
|
||
|
||
---
|
||
|
||
## Use case 4 — “Sell a complete developer bundle”
|
||
|
||
Target:
|
||
|
||
```text
|
||
Course creators, template sellers, developer educators
|
||
```
|
||
|
||
Promise:
|
||
|
||
```text
|
||
One checkout can deliver GitHub repo + ZIP + license key + Discord role.
|
||
```
|
||
|
||
---
|
||
|
||
## Use case 5 — “Let AI agents buy my service”
|
||
|
||
Target:
|
||
|
||
```text
|
||
Future-facing AI infra builders
|
||
```
|
||
|
||
Promise:
|
||
|
||
```text
|
||
Make your API discoverable and payable by autonomous agents.
|
||
```
|
||
|
||
---
|
||
|
||
# 30. What makes this different from Polar, Creem, Gumroad, Stripe, Paddle
|
||
|
||
Do not compete only as “another checkout.”
|
||
|
||
Your differentiation:
|
||
|
||
```text
|
||
1. Arc-native USDC payments
|
||
2. Circle Gateway/x402 agent payments
|
||
3. GitHub repo access automation
|
||
4. Developer-specific entitlements
|
||
5. SaaS feature gating SDK
|
||
6. Paid API middleware
|
||
7. License/API key server
|
||
8. Bundle delivery engine
|
||
9. Marketplace for humans and agents
|
||
10. Open-source core
|
||
```
|
||
|
||
## Positioning table
|
||
|
||
| User pain | Existing workaround | SettleKit solution |
|
||
| -------------------- | ------------------------------- | ----------------------------------- |
|
||
| Sell private repo | Payment tool + manual invite | Pay → automatic GitHub access |
|
||
| Sell SaaS | Build billing system | Plans + entitlements SDK |
|
||
| Sell API | API key + Stripe/custom billing | Paid API middleware + x402 |
|
||
| Sell template | Gumroad + manual support | Checkout + GitHub + files + license |
|
||
| Sell support | Discord manual roles | Pay → Discord role + renewal |
|
||
| Sell to AI agents | Not easy | x402 + USDC per request |
|
||
| Manage access expiry | Manual spreadsheet | Automatic entitlement revocation |
|
||
|
||
---
|
||
|
||
# 31. The “must-use” features
|
||
|
||
These are the features that make people stick.
|
||
|
||
## 1. Universal access automation
|
||
|
||
```text
|
||
Payment automatically grants access.
|
||
Refund/expiry automatically removes access.
|
||
```
|
||
|
||
## 2. Bundle delivery
|
||
|
||
```text
|
||
One payment can deliver multiple things.
|
||
```
|
||
|
||
Example:
|
||
|
||
```text
|
||
GitHub repo + license key + Discord role + file download + API credits
|
||
```
|
||
|
||
## 3. Customer portal
|
||
|
||
Buyers can manage everything:
|
||
|
||
```text
|
||
- Receipts
|
||
- License keys
|
||
- API keys
|
||
- Downloads
|
||
- GitHub access
|
||
- Discord access
|
||
- Subscriptions
|
||
- Usage credits
|
||
```
|
||
|
||
## 4. Merchant dashboard
|
||
|
||
Sellers can see:
|
||
|
||
```text
|
||
- Revenue
|
||
- Customers
|
||
- Active access
|
||
- Expiring subscriptions
|
||
- Failed delivery actions
|
||
- API usage
|
||
- GitHub access status
|
||
```
|
||
|
||
## 5. Entitlement API
|
||
|
||
SaaS apps can depend on SettleKit:
|
||
|
||
```text
|
||
Can this user access feature X?
|
||
How many seats do they have?
|
||
How many credits remain?
|
||
```
|
||
|
||
Once sellers integrate entitlements, SettleKit becomes core infrastructure.
|
||
|
||
## 6. Paid API middleware
|
||
|
||
Developers do not need to understand complex payment flows.
|
||
|
||
```text
|
||
withPayment({ price: "0.01 USDC" })(handler)
|
||
```
|
||
|
||
## 7. Marketplace
|
||
|
||
Sellers get discovery, not only infrastructure.
|
||
|
||
That makes the product more valuable.
|
||
|
||
---
|
||
|
||
# 32. Pricing strategy for this expanded product
|
||
|
||
## Free
|
||
|
||
```text
|
||
$0/month
|
||
3 products
|
||
1 GitHub repo product
|
||
basic checkout
|
||
community support
|
||
1% transaction fee
|
||
```
|
||
|
||
## Creator
|
||
|
||
```text
|
||
$19/month
|
||
20 products
|
||
GitHub repo sales
|
||
digital downloads
|
||
license keys
|
||
Discord access
|
||
0.75% transaction fee
|
||
```
|
||
|
||
## Pro
|
||
|
||
```text
|
||
$49/month
|
||
SaaS plans
|
||
API keys
|
||
subscriptions
|
||
webhooks
|
||
bundles
|
||
customer portal
|
||
0.5% transaction fee
|
||
```
|
||
|
||
## Business
|
||
|
||
```text
|
||
$199/month
|
||
team seats
|
||
usage billing
|
||
paid APIs
|
||
x402 payments
|
||
advanced analytics
|
||
webhook replay
|
||
0.25% transaction fee
|
||
```
|
||
|
||
## Enterprise
|
||
|
||
```text
|
||
Custom
|
||
private deployment
|
||
custom compliance
|
||
custom integrations
|
||
SLA
|
||
dedicated support
|
||
```
|
||
|
||
## Marketplace fee
|
||
|
||
```text
|
||
5%–15% on marketplace-discovered sales
|
||
```
|
||
|
||
---
|
||
|
||
# 33. Full expanded product roadmap
|
||
|
||
## Phase 1 — Core commerce
|
||
|
||
```text
|
||
- Products
|
||
- Prices
|
||
- Checkout
|
||
- USDC payments
|
||
- Customer portal
|
||
- Entitlements
|
||
- Webhooks
|
||
- Merchant dashboard
|
||
```
|
||
|
||
## Phase 2 — GitHub and digital sellers
|
||
|
||
```text
|
||
- GitHub App
|
||
- Private repo sales
|
||
- GitHub team access
|
||
- License keys
|
||
- File downloads
|
||
- Bundles
|
||
- Discord access
|
||
```
|
||
|
||
This is the best adoption phase.
|
||
|
||
## Phase 3 — SaaS billing
|
||
|
||
```text
|
||
- SaaS plans
|
||
- Feature entitlements
|
||
- Seat management
|
||
- Usage limits
|
||
- SDK checks
|
||
- Upgrade/downgrade
|
||
- Renewal flows
|
||
```
|
||
|
||
## Phase 4 — Paid APIs and agent payments
|
||
|
||
```text
|
||
- API keys
|
||
- Usage metering
|
||
- x402 middleware
|
||
- Circle Gateway nanopayments
|
||
- Agent buyer records
|
||
- Paid API dashboard
|
||
```
|
||
|
||
## Phase 5 — Marketplace
|
||
|
||
```text
|
||
- Public seller profiles
|
||
- Product listings
|
||
- Paid API listings
|
||
- Agent-readable metadata
|
||
- Ratings/reviews
|
||
- Marketplace fee
|
||
```
|
||
|
||
## Phase 6 — Enterprise and escrow
|
||
|
||
```text
|
||
- Escrow tasks
|
||
- B2B invoices
|
||
- Treasury wallet approvals
|
||
- KYB integrations
|
||
- Compliance/risk dashboards
|
||
- Private deployments
|
||
```
|
||
|
||
---
|
||
|
||
# 34. Strong landing page message
|
||
|
||
Use this kind of copy:
|
||
|
||
```text
|
||
Sell your software in USDC.
|
||
|
||
SettleKit lets developers sell private GitHub repos, SaaS subscriptions,
|
||
API access, AI tools, templates, datasets, license keys, and digital downloads.
|
||
|
||
Connect GitHub, create a product, set a USDC price, and share your checkout link.
|
||
We handle payment verification, access delivery, subscriptions, license keys,
|
||
webhooks, and customer portals.
|
||
```
|
||
|
||
## Landing page sections
|
||
|
||
```text
|
||
Hero:
|
||
Sell software, APIs, and private repos in USDC
|
||
|
||
Use cases:
|
||
Private GitHub repos
|
||
SaaS plans
|
||
Paid APIs
|
||
AI agent services
|
||
Digital downloads
|
||
License keys
|
||
Discord communities
|
||
|
||
How it works:
|
||
Create product → Set price → Buyer pays → Access delivered
|
||
|
||
Developer tools:
|
||
SDKs, webhooks, entitlements, x402 middleware
|
||
|
||
Marketplace:
|
||
Get discovered by humans and AI agents
|
||
|
||
Open source:
|
||
Self-host or use hosted cloud
|
||
```
|
||
|
||
---
|
||
|
||
# 35. Final expanded product definition
|
||
|
||
SettleKit should become:
|
||
|
||
```text
|
||
SettleKit Commerce OS
|
||
|
||
1. USDC checkout
|
||
2. Arc settlement
|
||
3. Circle Gateway/x402 payments
|
||
4. GitHub repo sales
|
||
5. GitHub team access
|
||
6. SaaS plan billing
|
||
7. Feature entitlement SDK
|
||
8. API key issuance
|
||
9. License key issuance
|
||
10. Digital downloads
|
||
11. Discord role access
|
||
12. Paid API middleware
|
||
13. AI agent service payments
|
||
14. Usage billing
|
||
15. Prepaid credits
|
||
16. Bundles
|
||
17. Customer portal
|
||
18. Merchant dashboard
|
||
19. Marketplace
|
||
20. Admin/risk tools
|
||
```
|
||
|
||
The simplest powerful pitch:
|
||
|
||
> **“SettleKit lets developers sell private repos, SaaS, APIs, templates, and AI tools in USDC — and automatically delivers access after payment.”**
|
||
|
||
That is the product people need.
|