Automated License Check

ALC enables developers to license smart contract libraries or decentralized applications (dApps) directly on-chain. A license token, such as an ERC-721 or ERC-1155, is required to call specific functions. This creates a pay-per-use or subscription model for software, where the license check is a pre-condition for execution. For example, a proprietary DeFi oracle feed could require a valid monthly license NFT to be held in the caller's wallet.

Beyond initial sales, ALC can enforce ongoing terms for digital art, music, or media NFTs. It can mandate that commercial use requires a separate commercial license, with fees automatically routed to the creator. This moves beyond simple transfer royalties to active usage-based royalties. Projects like Canonical (formerly Wildchain) have pioneered this for AI training data, where model trainers must hold a license to use licensed datasets.

ALC acts as a programmable gate for exclusive content or services. It verifies possession of a specific token (e.g., a community NFT, a subscription pass) before granting access. This is used for:

• Token-gated websites and articles.
• Exclusive Discord channels or live streams.
• Premium features within a dApp, like advanced analytics or higher API rate limits. The check is performed autonomously and immutably by the smart contract.

In regulated DeFi or enterprise contexts, ALC can ensure only whitelisted or KYC'd addresses interact with certain protocols. A compliance provider can issue verifiable credentials (e.g., as a Soulbound Token), and the smart contract's license check validates this credential before permitting a transaction. This enables permissioned DeFi pools or services that operate within specific legal frameworks without relying on a centralized gatekeeper.

Protocols can use ALC to offer premium modules or plugins. A base protocol might be free, but advanced features—like a special liquidation engine, a cross-chain bridge adapter, or a privacy mixer—require a license. This creates a modular business model where developers pay only for the capabilities they need. The license check is a lightweight function call that reverts the transaction if validation fails, ensuring strict enforcement.

An Automated License Check is a permission gate embedded within a smart contract's logic. Before executing a function (e.g., minting, staking, claiming), the contract queries the caller's wallet address against a license registry or NFT contract. Access is granted only if a valid, non-expired license token (like an NFT or SPL token) is found. This replaces manual whitelists with a decentralized, transparent, and composable system.

Licenses are typically implemented as non-fungible tokens (NFTs) using established standards to ensure interoperability.

• ERC-721 / ERC-1155 (Ethereum): The most common form, where holding a specific NFT collection grants access.
• SPL Token (Solana): Used similarly for Solana-based protocols.
• Soulbound Tokens (SBTs): Emerging standard for non-transferable licenses that represent persistent credentials or reputational status.

The system relies on two primary contract types:

• License Registry/Minter: The smart contract that issues, manages, and validates license tokens. It defines the rules for eligibility (e.g., fee payment, KYC completion).
• Gated Protocol Contract: The main application contract (e.g., a vault or minting engine) that calls the registry's hasLicense(address) view function. This enforcement is performed entirely on-chain within the transaction.

Licenses can have varying levels of complexity:

• Static Licenses: Grant perpetual or fixed-term access. Verification is a simple balance check.
• Dynamic Licenses: Incorporate expirations, usage tiers, or consumable features. The registry may track license states (active, expired, used) and require the gated contract to report usage, enabling pay-per-use or subscription models.

1. User Action: A user initiates a transaction on a gated dApp.
2. Pre-flight Check: The frontend may check the wallet for a license to provide early feedback.
3. On-Chain Verification: The protocol's smart contract executes the license check as the first step in its logic.
4. Execution or Revert: If the check passes, the transaction proceeds. If it fails, the transaction reverts with a clear error, consuming only gas for the failed check.

• Gated Minting: Restricting NFT mint access to pre-approved holders.
• Licensed Financial Vaults: Allowing only KYC'd users to deposit into regulated DeFi products.
• Software as a Service (SaaS): On-chain software where a valid license token is required to call certain API endpoints.
• Loyalty Programs: Granting exclusive features or rewards to long-term token holders.

An Automated License Check is a function call embedded within a protocol's smart contract that queries a user's wallet for a specific license NFT (e.g., ERC-7215) before allowing a transaction to proceed. This acts as a programmable gate, enabling permissioned access to functions like minting, staking, or claiming rewards. The check is performed on-chain and in real-time, ensuring compliance is enforced autonomously without manual intervention.

The ERC-7215 standard formalizes the concept of on-chain licenses. It defines a common interface for license NFTs and the functions protocols use to check them. Key components include:

• hasLicense(address holder, uint256 id): The standard function for Automated License Checks.
• License Registry: A contract that issues and manages license tokens.
• Revocability: Licenses can be programmatically revoked by the issuer, instantly removing access. This standardization allows different protocols to interoperate with a single license.

Automated License Checks enable new economic and governance models:

• Gated DeFi Pools: Restrict liquidity provision or borrowing to licensed participants.
• Licensed NFT Mints: Control access to minting events or allowlists via a verifiable license.
• Royalty Enforcement: Grant licensed marketplaces the right to trade NFTs with enforced creator fees, while blocking unlicensed platforms.
• Subscription Services: Provide time-bound access to a protocol's features, with the license expiring like a software subscription.

This mechanism fosters sustainable ecosystem development by:

• Monetizing Access: Protocols and creators can generate recurring revenue from license sales.
• Reducing Sybil Attacks: Licensing adds cost and identity to interactions, deterring spam and manipulation.
• Enabling Composability: A single license can grant access across multiple integrated protocols ("composable licensing").
• Aligning Incentives: Licenses create a direct stakeholder relationship between users and protocol developers.

A smart contract function using an Automated License Check typically includes a modifier or require statement:

solidityCopy
modifier requiresLicense(uint256 licenseId) {
    require(
        ILicenseRegistry(registry).hasLicense(msg.sender, licenseId),
        "License required"
    );
    _;
}
// Function usage
function mint() external requiresLicense(1) {
    // Minting logic
}

The call to hasLicense is the Automated License Check, querying the external registry contract.

• Soulbound Tokens (SBTs): Non-transferable tokens that could function as identity-based licenses.
• Access Control Lists (ACLs): Traditional permission systems that Automated License Checks generalize with transferable NFTs.
• Token-Gated Experiences: A broader category of gating content or access based on token ownership, where Automated License Check is the specific on-chain verification method.
• Digital Rights Management (DRM): The Web3-native, user-custodied analog to traditional digital rights systems.