blockchain-expert — Claude Code skill: what it does, how to install
The blockchain-expert skill guides blockchain, Web3, Solidity, smart contract, and DeFi work. Use it when an agent needs domain context for design, review, or implementation.
Apache-2.0 296 installs ★ 45 updated 2026-10-12
npx skills add personamanagmentlayer/pcl --skill blockchain-expert -a claude-codeWhat blockchain-expert does
blockchain-expert gives the agent coverage of ledger concepts, consensus, hashing, keys, transaction checks, and block structure. It also addresses Solidity development, security patterns, upgradeable contracts, testing, auditing, and gas usage.
The skill includes Solidity examples for an ERC-20 token, a staking pool, and an AMM. Its subject areas also include dApps, NFTs, Layer 2 systems, bridges, and wallet integration. The declared tools are Read, Write, and Edit. The sample contracts import @openzeppelin/contracts, so the ERC20, Ownable, and ReentrancyGuard packages need to resolve before that code can compile.
What it helps with
- map a Web3 application architecture
- write a Solidity token contract
- review a smart contract for security flaws
- design staking or AMM logic
- reduce gas use in Solidity code
Example prompts for the agent
- Review this Web3 application and suggest a contract architecture.
- Check
contracts/SimpleToken.solfor access-control and security issues. - Refactor this Solidity contract to reduce gas use, then explain the changes.
How to install blockchain-expert
1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill blockchain-expert -a claude-code2Manually: put the files in place
~/.claude/skills/blockchain-expert/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/blockchain-expert/
1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill blockchain-expert -a codex2Manually: put the files in place
.agents/skills/blockchain-expert/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill blockchain-expert -a cursor2Manually: put the files in place
.cursor/skills/blockchain-expert/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install personamanagmentlayer/pcl stdlib/domains/blockchain-expert2Manually: put the files in place
.github/skills/blockchain-expert/SKILL.md1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill blockchain-expert -a gemini-cli2Platform CLI
gemini skills install https://github.com/personamanagmentlayer/pcl --path stdlib/domains/blockchain-expertManually: put the files in place
.devin/skills/blockchain-expert/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill blockchain-expert -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about blockchain-expert
How do I install blockchain-expert in Claude Code?
Run npx skills add personamanagmentlayer/pcl --skill blockchain-expert -a claude-code, then check ~/.claude/skills/blockchain-expert/SKILL.md.
What does blockchain-expert do?
It provides guidance for blockchain development, Web3, Solidity, smart contracts, DeFi, and cryptocurrency systems. The package also contains token, staking, and AMM examples.
What is needed for the Solidity examples?
The examples import @openzeppelin/contracts components such as ERC20, Ownable, and ReentrancyGuard. Those imports must resolve for the shown code to compile.
Source text
SKILL.md · Apache-2.0
---
name: blockchain-expert
version: 1.1.0
description: >-
Expert-level blockchain, Web3, smart contracts, DeFi, and cryptocurrency development. Use
when the user mentions Web3, smart contracts, DeFi, Ethereum, or Solidity, or when the
task involves Blockchain Fundamentals, Web3 & DeFi, Smart Contract Security, or Gas
Optimization.
category: domains
tags: [blockchain, web3, smart-contracts, defi, ethereum, solidity]
allowed-tools:
- Read
- Write
- Edit
---
# Blockchain Expert
Expert guidance for blockchain development, smart contracts, Web3 applications, DeFi protocols, and cryptocurrency systems.
## Core Concepts
### Blockchain Fundamentals
- Distributed ledger technology
- Consensus mechanisms (PoW, PoS, PoA)
- Cryptographic hashing
- Public/private key cryptography
- Transaction validation
- Block structure and chain
### Smart Contracts
- Solidity programming
- Gas optimization
- Security patterns
- Upgradeable contracts
- Testing and auditing
- Contract interactions
### Web3 & DeFi
- Decentralized applications (dApps)
- DeFi protocols (AMM, lending, staking)
- NFTs and token standards
- Layer 2 solutions
- Cross-chain bridges
- Wallet integration
## Smart Contract Development
```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract SimpleToken is ERC20, Ownable, ReentrancyGuard {
uint256 public constant MAX_SUPPLY = 1000000 * 10**18;
mapping(address => bool) public minters;
event MinterAdded(address indexed minter);
event MinterRemoved(address indexed minter);
modifier onlyMinter() {
require(minters[msg.sender], "Not a minter");
_;
}
constructor() ERC20("SimpleToken", "SMPL") {
minters[msg.sender] = true;
}
function mint(address to, uint256 amount) external onlyMinter {
require(totalSupply() + amount <= MAX_SUPPLY, "Max supply exceeded");
_mint(to, amount);
}
function burn(uint256 amount) external {
_burn(msg.sender, amount);
}
function addMinter(address minter) external onlyOwner {
minters[minter] = true;
emit MinterAdded(minter);
}
function removeMinter(address minter) external onlyOwner {
minters[minter] = false;
emit MinterRemoved(minter);
}
}
// Staking Contract
contract StakingPool is ReentrancyGuard {
IERC20 public stakingToken;
IERC20 public rewardToken;
uint256 public rewardRate = 100; // Reward tokens per second
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
mapping(address => uint256) public balances;
uint256 private _totalSupply;
constructor(address _stakingToken, address _rewardToken) {
stakingToken = IERC20(_stakingToken);
rewardToken = IERC20(_rewardToken);
}
function rewardPerToken() public view returns (uint256) {
if (_totalSupply == 0) {
return rewardPerTokenStored;
}
return rewardPerTokenStored +
(((block.timestamp - lastUpdateTime) * rewardRate * 1e18) / _totalSupply);
}
function earned(address account) public view returns (uint256) {
return ((balances[account] *
(rewardPerToken() - userRewardPerTokenPaid[account])) / 1e18) +
rewards[account];
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = block.timestamp;
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
function stake(uint256 amount) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply += amount;
balances[msg.sender] += amount;
stakingToken.transferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply -= amount;
balances[msg.sender] -= amount;
stakingToken.transfer(msg.sender, amount);
}
function getReward() external nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (reward > 0) {
rewards[msg.sender] = 0;
rewardToken.transfer(msg.sender, reward);
}
}
}
```
## DeFi: AMM Implementation
```solidity
// Simple Automated Market Maker (like Uniswap)
contract SimpleAMM is ReentrancyGuard {
IERC20 public token0;
IERC20 public token1;
uint256 public reserve0;
uint256 public reserve1;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
event Swap(address indexed user, address tokenIn, uint256 amountIn, uint256 amountOut);
event AddLiquidity(address indexed user, uint256 amount0, uint256 amount1);
event RemoveLiquidity(address indexed user, uint256 amount0, uint256 amount1);
constructor(address _token0, address _token1) {
token0 = IERC20(_token0);
token1 = IERC20(_token1);
}
function addLiquidity(uint256 amount0, uint256 amount1)
external
nonReentrant
returns (uint256 shares)
{
token0.transferFrom(msg.sender, address(this), amount0);
token1.transferFrom(msg.sender, address(this), amount1);
if (totalSupply == 0) {
shares = sqrt(amount0 * amount1);
} else {
shares = min(
(amount0 * totalSupply) / reserve0,
(amount1 * totalSupply) / reserve1
);
}
require(shares > 0, "Shares = 0");
_mint(msg.sender, shares);
_update(
token0.balanceOf(address(this)),
token1.balanceOf(address(this))
);
emit AddLiquidity(msg.sender, amount0, amount1);
}
function removeLiquidity(uint256 shares)
external
nonReentrant
returns (uint256 amount0, uint256 amount1)
{
uint256 balance0 = token0.balanceOf(address(this));
uint256 balance1 = token1.balanceOf(address(this));
amount0 = (shares * balance0) / totalSupply;
amount1 = (shares * balance1) / totalSupply;
require(amount0 > 0 && amount1 > 0, "Amount = 0");
_burn(msg.sender, shares);
_update(balance0 - amount0, balance1 - amount1);
token0.transfer(msg.sender, amount0);
token1.transfer(msg.sender, amount1);
emit RemoveLiquidity(msg.sender, amount0, amount1);
}
function swap(address tokenIn, uint256 amountIn)
external
nonReentrant
returns (uint256 amountOut)
{
require(tokenIn == address(token0) || tokenIn == address(token1), "Invalid token");
bool isToken0 = tokenIn == address(token0);
(IERC20 tokenIn_, IERC20 tokenOut, uint256 reserveIn, uint256 reserveOut) =
isToken0
? (token0, token1, reserve0, reserve1)
: (token1, token0, reserve1, reserve0);
tokenIn_.transferFrom(msg.sender, address(this), amountIn);
// 0.3% fee
uint256 amountInWithFee = (amountIn * 997) / 1000;
// x * y = k formula
amountOut = (reserveOut * amountInWithFee) / (reserveIn + amountInWithFee);
tokenOut.transfer(msg.sender, amountOut);
_update(
token0.balanceOf(address(this)),
token1.balanceOf(address(this))
);
emit Swap(msg.sender, tokenIn, amountIn, amountOut);
}
function _mint(address to, uint256 amount) private {
balanceOf[to] += amount;
totalSupply += amount;
}
function _burn(address from, uint256 amount) private {
balanceOf[from] -= amount;
totalSupply -= amount;
}
function _update(uint256 _reserve0, uint256 _reserve1) private {
reserve0 = _reserve0;
reserve1 = _reserve1;
}
function sqrt(uint256 y) private pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
function min(uint256 x, uint256 y) private pure returns (uint256) {
return x <= y ? x : y;
}
}
```
## Web3 Integration
```typescript
import { ethers } from 'ethers';
import { Contract, Provider, Signer } from 'ethers';
class Web3Client {
private provider: Provider;
private signer?: Signer;
constructor(rpcUrl: string) {
this.provider = new ethers.JsonRpcProvider(rpcUrl);
}
async connectWallet(): Promise<string> {
// Connect to MetaMask
if (typeof window.ethereum !== 'undefined') {
const provider = new ethers.BrowserProvider(window.ethereum);
await provider.send('eth_requestAccounts', []);
this.signer = await provider.getSigner();
return await this.signer.getAddress();
}
throw new Error('No wallet found');
}
async getBalance(address: string): Promise<string> {
const balance = await this.provider.getBalance(address);
return ethers.formatEther(balance);
}
async sendTransaction(to: string, amount: string): Promise<string> {
if (!this.signer) throw new Error('Wallet not connected');
const tx = await this.signer.sendTransaction({
to,
value: ethers.parseEther(amount),
});
const receipt = await tx.wait();
return receipt?.hash || '';
}
getContract(address: string, abi: any[]): Contract {
return new ethers.Contract(address, abi, this.signer || this.provider);
}
async callContract(
contractAddress: string,
abi: any[],
method: string,
args: any[]
): Promise<any> {
const contract = this.getContract(contractAddress, abi);
return await contract[method](...args);
}
async estimateGas(
contractAddress: string,
abi: any[],
method: string,
args: any[]
): Promise<bigint> {
const contract = this.getContract(contractAddress, abi);
return await contract[method].estimateGas(...args);
}
}
```
## Best Practices
### Smart Contract Security
- Use OpenZeppelin contracts for standards
- Implement reentrancy guards
- Check for integer overflow/underflow (use Solidity 0.8+)
- Validate all inputs
- Use pull over push for payments
- Implement circuit breakers for emergencies
- Comprehensive testing and auditing
### Gas Optimization
- Use `uint256` over smaller types
- Pack storage variables
- Use `calldata` for function parameters
- Minimize storage operations
- Use events for data that doesn't need on-chain storage
- Batch operations when possible
### Development
- Use Hardhat/Foundry for development
- Write comprehensive tests
- Use test networks before mainnet
- Implement upgrade patterns carefully
- Monitor contract events
- Document all functions
## Anti-Patterns
❌ No reentrancy protection
❌ Unchecked external calls
❌ Using `tx.origin` for authorization
❌ Floating pragma versions
❌ No access control
❌ Storing sensitive data on-chain
❌ No gas limit considerations
## Resources
- Ethereum: https://ethereum.org/en/developers/
- Solidity: https://docs.soliditylang.org/
- OpenZeppelin: https://www.openzeppelin.com/
- Hardhat: https://hardhat.org/
- Ethers.js: https://docs.ethers.org/
© personamanagmentlayer · Apache-2.0 · personamanagmentlayer/pcl