Provides comprehensive wallet, token, and smart contract utilities for the Abstract network, enabling users to check balances, transfer tokens, deploy ERC-20 contracts, and manage Abstract Global Wallets (smart contract accounts).
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Society Abstract MCP check the USDC balance of vitalik.eth"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
FastMCP TypeScript server providing comprehensive wallet, token and smart contract utilities for Abstract Testnet/Mainnet
ab_get_balance - Balance CheckerGet native ETH or ERC-20 token balance for any address with ENS support.
Parameters:
address (required): Wallet address or ENS name to check balance for
tokenAddress (optional): ERC-20 contract address for token balance
tokenSymbol (optional): Token symbol (e.g., "USDC") for well-known tokens
Example Usage:
// Get native ETH balance
{ address: "0x1234...abcd" }
// Get ERC-20 balance by contract
{ address: "vitalik.eth", tokenAddress: "0xA0b86a33E6F..." }
// Get balance by token symbol
{ address: "0x1234...abcd", tokenSymbol: "USDC" }Returns: Human-readable balance as string (e.g., "1.234567")
ab_transfer_token - Token TransferTransfer native ETH or ERC-20 tokens to another address with ENS support.
Parameters:
to (required): Recipient address or ENS name
amount (required): Amount to transfer in human-readable format
tokenAddress (optional): ERC-20 contract address for token transfers
tokenSymbol (optional): Token symbol for well-known tokens
Example Usage:
// Transfer native ETH
{ to: "0x1234...abcd", amount: "0.1" }
// Transfer ERC-20 by contract
{ to: "vitalik.eth", amount: "100", tokenAddress: "0xA0b86a33E6F..." }
// Transfer by token symbol
{ to: "0x1234...abcd", amount: "50", tokenSymbol: "USDC" }Returns: Transaction hash of the successful transfer
ab_deploy_token_erc20 - ERC-20 Token DeploymentDeploy a new ERC-20 BasicToken contract to Abstract network.
Parameters:
name (required): Token name (e.g., "DemoToken")
symbol (required): Token symbol/ticker (e.g., "DMT")
initialSupply (required): Total supply in wei (18 decimals) as string
Example Usage:
// Deploy 1000 tokens (1000 * 10^18 wei)
{
name: "MyToken",
symbol: "MTK",
initialSupply: "1000000000000000000000"
}Returns: Deployed contract address and deployment details
ab_agw_create_wallet - Abstract Global Wallet CreationDeploy a new Abstract Global Wallet (smart contract account) for a given signer.
Parameters:
signer (optional): EOA signer address or ENS name. If omitted, uses server wallet as initial signer
Example Usage:
// Create AGW with specific signer
{ signer: "0x1234...abcd" }
// Create AGW with server wallet as signer
{ }Returns: Smart account address and deployment transaction hash
ab_generate_wallet - EOA Wallet GenerationGenerate a brand-new Externally Owned Account (EOA) with private key and address.
Parameters:
random_string (required): Any string for entropy (can be anything)
Example Usage:
{ random_string: "my-random-seed" }Returns:
privateKey: 0x-prefixed 32-byte hex string
address: Checksummed Ethereum/Abstract address
⚠️ Security Note: Store the private key securely and never log it.
Related MCP server: Base MCP Server
{
"mcpServers": {
"society-abstract-mcp": {
"command": "npx",
"args": ["-y", "society-abstract-mcp@0.1.4"],
"env": {
"ABSTRACT_PRIVATE_KEY": "your-private-key-here",
"ABSTRACT_RPC_URL": "https://api.testnet.abs.xyz",
"TESTNET": "true",
"PORT": "3101",
"MCP_DISABLE_PINGS": "true"
}
}
}
}{
"mcpServers": {
"society-abstract-mcp-local": {
"command": "node",
"args": ["/path/to/your/society_abstract_mcp/dist/server.js"],
"env": {
"ABSTRACT_PRIVATE_KEY": "your-private-key-here",
"ABSTRACT_RPC_URL": "https://api.testnet.abs.xyz",
"TESTNET": "true",
"PORT": "3101",
"MCP_DISABLE_PINGS": "true"
}
}
}
}# 1. Install dependencies
npm install
# 2. Build the project
npm run build
# 3. Run development server
npm run dev
# 4. Run tests
npm run test
# 5. Run integration tests (requires funds)
INTEGRATION=1 npm run test:intRequired for MCP Client:
ABSTRACT_PRIVATE_KEY: EOA private key that pays gas fees
ABSTRACT_RPC_URL: Abstract network RPC URL
TESTNET: "true" for testnet, "false" for mainnet
Optional for MCP Client:
PORT: HTTP port for the MCP server (default: 3101)
MCP_DISABLE_PINGS: "true" to disable ping messages
Note: No .env file needed for production. All variables should be passed by the MCP client.
# Build for production
npm run build
# Start production server
npm start
# Build outputs to dist/ with:
# - ESM modules
# - TypeScript definitions
# - Copied JavaScript assetsUnit Tests: npm run test (mocked, no gas required)
Integration Tests: INTEGRATION=1 npm run test:int (requires testnet funds)
Balance Checker: npm run balance (multi-network balance tool)
Framework: FastMCP with TypeScript
Networks: Abstract Testnet/Mainnet
Standards: ERC-20 tokens, Abstract Global Wallets
Dependencies: viem, zksync-ethers, @abstract-foundation/agw-client
Build Target: ES2022 (Node.js ≥ 16.14)
Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request
This project is licensed under the MIT License - see the LICENSE file for details.
Issues: GitHub Issues
Documentation: This README and inline code documentation
Community: Join our Telegram
Deploy a new Abstract Global Wallet (smart-contract account) for a given signer.
The tool wraps @abstract-foundation/agw-client’s deployAccount helper.
Returns both the smart-account address and the deployment tx hash (undefined when the account already exists).
| Name | Required | Description | Default |
|---|---|---|---|
| signer | No | EOA signer address or ENS. If omitted, uses the server wallet’s account as the initial signer |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide destructiveHint=true, indicating this is a write operation. The description adds valuable context beyond annotations: it specifies that the tool wraps an external helper ('@abstract-foundation/agw-client’s deployAccount'), describes the return values (address and tx hash), and notes that the tx hash may be 'undefined' if the account already exists. This enhances understanding of the tool's behavior without contradicting annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first sentence, followed by implementation details and return values in subsequent sentences. Each sentence adds value without redundancy, making it efficient and well-structured for quick comprehension.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (deploying a smart-contract with destructive hint) and lack of output schema, the description provides good coverage: it explains the action, underlying helper, and return values. However, it could benefit from more details on error conditions or deployment prerequisites to be fully complete for a destructive operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema description coverage, the schema fully documents the single parameter 'signer'. The description adds marginal value by reinforcing the parameter's role ('for a given signer') and implying its optional nature, but doesn't provide additional syntax or format details. Since there's only one parameter, the baseline is high, and the description adequately complements the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Deploy a new Abstract Global Wallet') and resource ('smart-contract account') with the target ('for a given signer'). It distinguishes from sibling tools like 'ab_generate_wallet' by specifying this creates a smart-contract account rather than a regular wallet, and from 'ab_deploy_token_erc20' by focusing on wallet deployment versus token deployment.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when needing a smart-contract account for a signer, but doesn't explicitly state when to use this tool versus alternatives like 'ab_generate_wallet' for non-smart wallets or other deployment tools. No explicit exclusions or prerequisites are mentioned, leaving some ambiguity about the decision context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Deploy an ERC-20 BasicToken to the Abstract network.
PARAMETERS
name – token name (e.g. "DemoToken")
symbol – token symbol/ticker (e.g. "DMT")
initialSupply – numeric string of total supply in wei (18 decimals)
FLOW
Uses proven zksync-ethers deployment method via subprocess
Returns the deployed contract address
SECURITY / LIMITATIONS
Make sure the deployer wallet (ABSTRACT_PRIVATE_KEY / PRIVATE_KEY) has enough funds on the target network
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Token name | |
| symbol | Yes | Token symbol / ticker | |
| initialSupply | Yes | Initial token supply, in wei (e.g. 1000000000000000000000 for 1000 tokens) | |
| debug | No | Return verbose error information instead of throwing |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds valuable behavioral context beyond the destructiveHint annotation. It discloses the deployment method ('proven zksync-ethers deployment method via subprocess'), return value ('Returns the deployed contract address'), and security prerequisites ('deployer wallet must have enough funds'). While annotations cover the destructive nature, the description provides implementation details and constraints that help the agent understand the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (PARAMETERS, FLOW, SECURITY/LIMITATIONS) and front-loads the core purpose. While somewhat verbose, each section serves a purpose. The structure helps with readability, though some content duplication with the schema reduces efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive deployment tool with no output schema, the description provides good contextual completeness. It covers the deployment method, return value, and security prerequisites. The main gap is the undocumented debug parameter, but overall it gives the agent sufficient understanding of what the tool does and what to expect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema description coverage, the schema already documents all parameters thoroughly. The description's PARAMETERS section repeats information already in the schema (name, symbol, initialSupply definitions) without adding meaningful semantic context. The debug parameter isn't mentioned at all in the description. Baseline 3 is appropriate when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Deploy an ERC-20 BasicToken') and target resource ('to the Abstract network'), distinguishing it from sibling tools like balance checking or transfers. It provides a complete verb+resource+scope statement that leaves no ambiguity about the tool's function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context through the SECURITY/LIMITATIONS section mentioning deployer wallet requirements, but doesn't explicitly state when to use this tool versus alternatives. No sibling tool comparisons or explicit when/when-not guidance is provided, leaving usage context somewhat implied rather than clearly defined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate a brand-new Externally Owned Account (EOA).
RETURNS • privateKey – 0x-prefixed 32-byte hex string • address – checksummed Ethereum/Abstract address
COMMON USES • Let agents spin up their own keypairs before funding or deploying smart-accounts.
SECURITY • The private key is returned in plaintext. Ensure the caller stores it securely and never logs it.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide destructiveHint=false and a title, but the description adds valuable behavioral context beyond that: it discloses security implications ('private key is returned in plaintext'), storage requirements ('Ensure the caller stores it securely'), and logging restrictions ('never logs it'). It doesn't contradict annotations and adds meaningful operational guidance.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly structured with clear sections (RETURNS, COMMON USES, SECURITY), each containing only essential information. Every sentence earns its place: the first states the purpose, subsequent bullets detail outputs and usage context, and the security warning is critical. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 0-parameter tool with annotations covering safety (destructiveHint=false) but no output schema, the description provides excellent coverage: purpose, return values (privateKey, address), usage context, and critical security warnings. The only minor gap is not explicitly stating this is a read-only operation (though implied by generation without side effects).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline would be 4. The description appropriately doesn't discuss parameters since none exist, and the schema clearly states 'No parameters required.' No additional parameter information is needed or provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states 'Generate a brand-new Externally Owned Account (EOA)' - a specific verb ('Generate') and resource ('EOA'). It clearly distinguishes from sibling tools like ab_agw_create_wallet (likely a different wallet type), ab_deploy_token_erc20 (deployment), ab_get_balance (query), and ab_transfer_token (transaction).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The 'COMMON USES' section provides clear context: 'Let agents spin up their own keypairs before funding or deploying smart-accounts.' This indicates when to use this tool (pre-funding/pre-deployment) but doesn't explicitly state when NOT to use it or name specific alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch the current on-chain balance for a wallet.
CAPABILITIES • Native ETH balance (default) • ERC-20 balance via tokenAddress OR well-known tokenSymbol (lookup table) • ENS name resolution for the target address
EXAMPLES
Native balance → { address: "vitalik.eth" }
ERC-20 balance via symbol → { address: "0x123…", tokenSymbol: "USDC" }
ERC-20 via contract → { address: "0xabc…", tokenAddress: "0xA0b8…" }
RETURNS • Human-readable string (e.g. "12.3456")
SECURITY • Read-only operation, no gas spent; safe to run frequently.
| Name | Required | Description | Default |
|---|---|---|---|
| address | Yes | Target wallet (address or ENS) to query | |
| tokenAddress | No | ERC-20 token address | |
| tokenSymbol | No | Token symbol to resolve (e.g. USDC) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide readOnlyHint=true, and the description reinforces this with 'Read-only operation, no gas spent; safe to run frequently.' It adds valuable context beyond annotations: ENS name resolution capability, human-readable return format, and safety for frequent use. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (CAPABILITIES, EXAMPLES, RETURNS, SECURITY), front-loaded with the core purpose, and every sentence adds value without redundancy. It efficiently communicates essential information in a compact format.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no output schema), the description is highly complete: it covers purpose, usage, parameters, return format, and security. The only minor gap is lack of explicit error handling or rate limit details, but annotations and context provide sufficient coverage for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds significant value by explaining parameter usage through examples: address accepts ENS names, tokenSymbol uses a lookup table, and tokenAddress is for direct contract specification. This clarifies semantics beyond the schema's basic descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Fetch the current on-chain balance') and resource ('for a wallet'), distinguishing it from sibling tools like create_wallet, deploy_token, generate_wallet, and transfer_token which involve creation, deployment, or transfer operations rather than querying existing balances.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool: for fetching wallet balances (native ETH or ERC-20 tokens) and when to use specific parameters (tokenAddress vs tokenSymbol). It implicitly distinguishes from siblings by focusing on read-only balance queries rather than write operations like creation or transfers.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Transfer value from the caller’s wallet to another address.
FUNCTIONALITY • Native ETH transfer (simple payment) • ERC-20 transfer (requires tokenAddress or known tokenSymbol) • ENS resolution for recipient
VALIDATION & LOGGING • Ensures wallet signer configured, token decimals fetched automatically • Logs tx hash on success so the agent can create explorer links
COMMON USE-CASES • Payout scripted rewards • Move workshop faucet tokens to students • Automation flows needing programmatic payment
| Name | Required | Description | Default |
|---|---|---|---|
| to | Yes | Recipient address or ENS name | |
| amount | Yes | Amount to transfer (human units) | |
| tokenAddress | No | ||
| tokenSymbol | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds valuable behavioral context beyond the destructiveHint annotation. It discloses that the tool performs ENS resolution, automatically fetches token decimals, logs transaction hashes for explorer links, and requires a configured wallet signer. These are practical implementation details not captured in annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured with clear sections (FUNCTIONALITY, VALIDATION & LOGGING, COMMON USE-CASES). Each sentence earns its place by providing distinct information without redundancy. The front-loaded purpose statement immediately communicates the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive tool with no output schema and incomplete parameter documentation, the description does well overall. It covers key behavioral aspects and parameter semantics. However, it doesn't explicitly mention error conditions, gas considerations, or what happens with native ETH transfers (no tokenAddress/tokenSymbol needed), leaving some gaps in completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With only 50% schema description coverage (two parameters undocumented), the description compensates well. It explains that tokenAddress or tokenSymbol are needed for ERC-20 transfers, clarifies that amount uses 'human units' (not wei), and mentions ENS support for the 'to' parameter. This adds meaningful context beyond the minimal schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('transfer value') and resources ('from the caller's wallet to another address'). It distinguishes itself from sibling tools like ab_get_balance (which reads balances) and ab_deploy_token_erc20 (which creates tokens) by focusing on value transfer operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The 'COMMON USE-CASES' section provides clear context for when to use this tool (payout rewards, move faucet tokens, automation flows). However, it doesn't explicitly state when NOT to use it or mention specific alternatives among the sibling tools, such as using ab_get_balance first to check funds.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.4ab_agw_create_walletab_deploy_token_erc20ab_generate_walletab_get_balanceab_transfer_tokenScored across 5 tools
Each tool has a clearly distinct purpose: creating a smart-contract wallet, deploying an ERC-20 token, generating an EOA wallet, fetching balances, and transferring tokens. There is no overlap in functionality, and the descriptions clearly differentiate their roles in the blockchain interaction workflow.
All tools follow a consistent 'ab_' prefix with descriptive verb_noun patterns (e.g., create_wallet, deploy_token, generate_wallet, get_balance, transfer_token). This uniformity makes the toolset predictable and easy to navigate, with no deviations in naming conventions.
With 5 tools, the set is well-scoped for interacting with the Abstract network, covering key operations like wallet management, token deployment, balance queries, and transfers. Each tool serves a distinct and necessary function without being overly sparse or bloated.
The toolset provides comprehensive coverage for core blockchain interactions, including creation, deployment, querying, and transferring. A minor gap exists in lacking update or delete operations for deployed contracts or wallets, but agents can work around this as these are less common in typical workflows.
Provide AI agents and automation tools with contextual access to blockchain data including balance…
OpenAI-compatible LLM MCP (7 tools); chat via balance key or x402 USDC on Base
Read-only on-chain intelligence for AI agents on Base: balances, tokens, gas, tx status.
Read-only on-chain intelligence for AI agents on Base: balances, tokens, gas, tx status.