Standard library

The standard library ships inside the compiler. Import a module with a path that starts with std/:

import "std/interfaces/erc20";
import "std/evm";
import "std/token/erc20";
import "std/access/ownable";
 
contract Token is {
  use ERC20 exposing {
    view function balanceOf(account : address) : uint;
    function transfer(to : address; value : uint) : bool
      raises ERC20InvalidSender | ERC20InvalidReceiver | ERC20InsufficientBalance;
  }
 
  use Ownable;
 
  hook ERC20.beforeTransfer is skip;
  hook ERC20.afterTransfer is skip;
 
  storage is record {
    minted : uint;
  }
 
  deploy()
    raises OwnableInvalidOwner
  is {
    ERC20.init("Token", "TKN");
    Ownable.init(Evm.sender());
  }
 
  external function mint(const to : address; const value : uint)
    raises OwnableUnauthorizedAccount | ERC20InvalidReceiver | ERC20InsufficientBalance
  is {
    Ownable.checkOwner();
    ERC20.mint(to, value);
    storage.minted := storage.minted + value;
  }
}

Every module follows the ordinary rules for modules:

• Modules declare the standard interfaces; contracts choose what to expose. A module's externals carry the standard's ABI names, and no internal function shares one. A view that only reads storage has no internal twin: a contract reads the storage, ERC20.erc20.balances[account]. balanceOf is an external of IERC20, which a token exposes with use ERC20 exposing IERC20, and announces through ERC-165 with supports IERC20. A contract that needs different behavior writes its own entrypoint instead, and exposes the rest with the interfaces the module's file declares for its parts, such as IERC20Views, IOwnable, and IPausable; only whole standards are in std/interfaces. lithe stubs file.lithe ERC20 prints a module's whole block.
• Each module owns its storage, at an ERC-7201 root named lithe.std.<module>: lithe.std.erc20, lithe.std.ownable, and so on. Contracts don't redeclare a module's schema, and two modules never collide.
• Extensions add behavior, and never change a base module silently. A pause, a cap, or a fee is written in the contract's own transfer, around the module's pieces.
• Errors and events match OpenZeppelin's, or Solady's where OpenZeppelin has no such module, so wallets, explorers, and indexers decode them as they already do.

Modules

What isn't here

• A reentrancy guard. nonreentrant is a language feature, and deferred calls already run after a transition's own effects.
• Byte and arithmetic primitives. Bytes.concat, Bytes.word, String.lower, String.escapeJson, Base64.encode, Uint.mulDiv, and the rest are built-ins, because the compiler does them better than a library could. Anything that builds a string a byte at a time is one: a library can only join slices.
• Applications, such as AMMs, lending markets, or auctions. They are too opinionated for a foundation.