open-index/open-npm huggingface dataset:
npm package: @monaco-protocol/admin-client
Description: Admin interface package for the Monaco Protocol on Solana
Author: Monaco Protocol
Latest version: 12.0.1

# Monaco Protocol Admin Client

NPM package to interface with admin functionality for the Monaco Protocol program on the [Solana network](https://solana.com/developers). The Monaco Protocol provides a decentralized liquidity network for wagering on binary-outcome events.

The package opens up admin-facing interactions with the protocol including:

- Create markets
- Manage markets
- Manage admin permissions

# Documentation

All endpoints exported by the library contain detailed doc strings and examples confirming to the JSDoc format. These doc strings can be viewed separately in the [docs](./docs/) directory.

## Generating Docs

Docs are generated using [documentationjs](https://github.com/documentationjs/documentation). 

```
npm run generateDocs
```

# Client Response Format

All endpoints in the client return the same response format:

```
export type ClientResponse<T> = {
  success: boolean;
  errors: object[];
  data: T;
};
```

Each endpoint defines its own data type used in the response, for example: `createOrderUiStake` returns `Promise<ClientResponse<CreateOrderResponse>>`

```
export type CreateOrderResponse = {
  orderPk: PublicKey;
  tnxID: string | void;
};
```

## Errors

Errors are purposely left loosely typed as an `object[]` so that the client can remain as agnostic as possible and pass through unfiltered errors regardless of origin.

If any error is encountered during a request, the client will return `success: false` and data may come back `undefined`.
npm package: @monaco-protocol/client
Description: Interface package for the Monaco Protocol on Solana
Author: Monaco Protocol
Latest version: 12.0.1

# Monaco Protocol Client

NPM package to interface with the Monaco Protocol program on the [Solana network](https://solana.com/developers). The Monaco Protocol provides a decentralized liquidity network for wagering on binary-outcome events.

The package opens up the consumer-facing interactions with the protocol to facilitate exchanged-based applications including:

- Get markets by status/event/wagering token
- Place orders for markets
- Cancel orders
- Get market position for wallets
- Get wallet token balances

The package does not contain functionality to administer markets on the protocol. Admin functionality will be exposed through a separate package - coming soon.

# Getting Started

Examples for working with the client can be found in the [Monaco Protocol SDK Examples](https://github.com/MonacoProtocol/sdk/tree/main/examples) repository.

# Documentation

All endpoints exported by the library contain detailed doc strings and examples confirming to the JSDoc format. These doc strings can be viewed separately in the [docs](./docs/) directory.

Supplementary documentation can be accessed from the [Monaco Protocol SDK](https://github.com/MonacoProtocol/sdk/tree/main/examples).

## Generating Docs

Docs are generated using [documentationjs](https://github.com/documentationjs/documentation). 

```
npm run generateDocs
```

# Client Response Format

All endpoints in the client return the same response format:

```
export type ClientResponse<T> = {
  success: boolean;
  errors: object[];
  data: T;
};
```

Each endpoint defines its own data type used in the response, for example: `createOrderUiStake` returns `Promise<ClientResponse<CreateOrderResponse>>`

```
export type CreateOrderResponse = {
  orderPk: PublicKey;
  tnxID: string | void;
};
```

## Errors

Errors are purposely left loosely typed as an `object[]` so that the client can remain as agnostic as possible and pass through unfiltered errors regardless of origin.

If any error is encountered during a request, the client will return `success: false` and data may come back `undefined`.
npm package: @monaco-protocol/client-account-types
Description: Client types package for the Monaco Protocol accounts
Author: Monaco Protocol
Latest version: 13.0.0-dev.1727991662

# Monaco Protocol Client Account Types

This package provides type declarations for most Monaco Protocol accounts. These are used by `@monaco-protocol/client` but also maybe useful if using the account data generated by the client elsewhere in your stack.

It also provides _Primitive_ variants of these types, where external types have been converted to primitive types, e.g., `BN` to `number` or `Date` where appropriate, and `PublicKey` to `string` (Base58).

# Documentation

The type declartions should be self documenting. [documentationjs](https://github.com/documentationjs/documentation) doesn't yet seem to support `interface` correctly.

To generate the docs as they are you can run
```
npm run generateDocs
```
npm package: @monaco-temp/monaco-editor-core
Description: A browser based code editor
Author: Microsoft Corporation
Latest version: 0.22.3

# monaco-editor-core

> This npm module is a building block for the [monaco-editor](https://www.npmjs.com/package/monaco-editor)
npm module and unless you are doing something special (e.g. authoring a monaco editor language that can be shipped
and consumed independently), it is best to consume the [monaco-editor](https://www.npmjs.com/package/monaco-editor) module
that contains this module and adds languages supports.

The Monaco Editor is the code editor that powers [VS Code](https://github.com/microsoft/vscode),
a good page describing the code editor's features is [here](https://code.visualstudio.com/docs/editor/editingevolved).

This npm module contains the core editor functionality, as it comes from the [vscode repository](https://github.com/microsoft/vscode).

## License
[MIT](https://github.com/microsoft/vscode/blob/master/LICENSE.txt)
npm package: @monad-agent-kit/ai-langchain
Description: LangChain integration for Monad Agent Kit
Latest version: 0.1.1

# @monad-agent-kit/ai-langchain

[LangChain](https://js.langchain.com) integration for [Monad Agent Kit](https://github.com/mertkaradayi/monad-agent-kit) — converts all registered agent actions into LangChain tools.

## Installation

```bash
bun add @monad-agent-kit/core @monad-agent-kit/ai-langchain @langchain/core
```

## Usage

```typescript
import { MonadAgentKit } from "@monad-agent-kit/core"
import { tokenPlugin } from "@monad-agent-kit/plugin-token"
import { defiPlugin } from "@monad-agent-kit/plugin-defi"
import { createLangChainTools } from "@monad-agent-kit/ai-langchain"
import { ChatOpenAI } from "@langchain/openai"
import { AgentExecutor, createToolCallingAgent } from "langchain/agents"
import { ChatPromptTemplate } from "@langchain/core/prompts"

// 1. Set up the agent with plugins
const agent = new MonadAgentKit({ privateKey: process.env.PRIVATE_KEY })
await agent.use(tokenPlugin)
await agent.use(defiPlugin)

// 2. Convert all actions to LangChain tools
const tools = createLangChainTools(agent)

// 3. Use with a LangChain agent
const llm = new ChatOpenAI({ model: "gpt-4" })
const prompt = ChatPromptTemplate.fromMessages([
  ["system", "You are a helpful blockchain assistant."],
  ["human", "{input}"],
  ["placeholder", "{agent_scratchpad}"],
])

const langchainAgent = createToolCallingAgent({ llm, tools, prompt })
const executor = AgentExecutor.fromAgentAndTools({ agent: langchainAgent, tools })

const result = await executor.invoke({
  input: "What is my MON balance?",
})
```

## How It Works

`createLangChainTools()` takes a `MonadAgentKit` instance and returns an array of `DynamicStructuredTool` objects:

- Action `name` becomes the tool name
- Action `description` becomes the tool description
- Action `parameters` (JSON Schema) are converted to Zod schemas
- Tool execution calls `agent.execute()` and returns JSON-stringified results

Any plugins registered before calling `createLangChainTools()` will have their actions included.

## Peer Dependencies

- `@langchain/core` >= 0.3.0

## License

MIT
npm package: @monad-agent-kit/ai-vercel
Description: Vercel AI SDK integration for Monad Agent Kit
Latest version: 0.1.1

# @monad-agent-kit/ai-vercel

[Vercel AI SDK](https://sdk.vercel.ai) integration for [Monad Agent Kit](https://github.com/mertkaradayi/monad-agent-kit) — converts all registered agent actions into Vercel AI tools.

## Installation

```bash
bun add @monad-agent-kit/core @monad-agent-kit/ai-vercel ai
```

## Usage

```typescript
import { MonadAgentKit } from "@monad-agent-kit/core"
import { tokenPlugin } from "@monad-agent-kit/plugin-token"
import { defiPlugin } from "@monad-agent-kit/plugin-defi"
import { createVercelAITools } from "@monad-agent-kit/ai-vercel"
import { generateText } from "ai"
import { createOpenRouter } from "@openrouter/ai-sdk-provider"

// 1. Set up the agent with plugins
const agent = new MonadAgentKit({ privateKey: process.env.PRIVATE_KEY })
await agent.use(tokenPlugin)
await agent.use(defiPlugin)

// 2. Convert all actions to Vercel AI tools
const tools = createVercelAITools(agent)

// 3. Use with any Vercel AI-compatible model
const openrouter = createOpenRouter({ apiKey: process.env.OPENROUTER_API_KEY })

const result = await generateText({
  model: openrouter("anthropic/claude-sonnet-4"),
  tools,
  maxSteps: 10,
  prompt: "Check my MON balance, then swap 0.1 MON for USDC",
})

console.log(result.text)
```

## How It Works

`createVercelAITools()` takes a `MonadAgentKit` instance and converts every registered action into a Vercel AI SDK tool:

- Action `name` becomes the tool name
- Action `description` becomes the tool description
- Action `parameters` (JSON Schema) are converted to Zod schemas
- Tool execution calls `agent.execute()` and returns the result

Any plugins registered before calling `createVercelAITools()` will have their actions included.

## Compatible Models

Works with any model provider supported by Vercel AI SDK:

- OpenRouter (Claude, GPT-4, Llama, etc.)
- OpenAI
- Anthropic
- Google Gemini
- And more

## Peer Dependencies

- `ai` >= 6.0.0 (Vercel AI SDK)

## License

MIT
npm package: @monad-agent-kit/plugin-nft
Description: NFT plugin for Monad Agent Kit - ERC-721 operations
Latest version: 0.1.1

# @monad-agent-kit/plugin-nft

NFT operations plugin for [Monad Agent Kit](https://github.com/mertkaradayi/monad-agent-kit) — query, transfer, and get metadata for ERC-721 NFTs.

## Installation

```bash
bun add @monad-agent-kit/core @monad-agent-kit/plugin-nft
```

## Usage

```typescript
import { MonadAgentKit } from "@monad-agent-kit/core"
import { nftPlugin } from "@monad-agent-kit/plugin-nft"

const agent = new MonadAgentKit({ privateKey: "0x..." })
await agent.use(nftPlugin)
```

## Actions

### getNFTs

Query ERC-721 NFTs owned by an address.

```typescript
const result = await agent.execute("getNFTs", {
  contractAddress: "0x...",
  address: "0x...", // optional, defaults to agent wallet
})
// result.data = { nfts: [{ tokenId: "1", contractAddress: "0x..." }], count: 1 }
```

### transferNFT

Transfer an ERC-721 NFT to another address.

```typescript
await agent.execute("transferNFT", {
  contractAddress: "0x...",
  tokenId: "42",
  to: "0x...",
})
```

### getNFTMetadata

Get metadata for a specific NFT including name, symbol, tokenURI, and parsed metadata.

```typescript
const result = await agent.execute("getNFTMetadata", {
  contractAddress: "0x...",
  tokenId: "42",
})
// result.data = { name: "My NFT", symbol: "MNFT", tokenURI: "ipfs://...", metadata: { ... } }
```

## Exports

```typescript
import {
  nftPlugin,             // Plugin object
  getNFTsAction,         // Individual actions
  transferNFTAction,
  getNFTMetadataAction,
  erc721Abi,             // Standard ERC-721 ABI
} from "@monad-agent-kit/plugin-nft"
```

## License

MIT
npm package: @monad-agent-kit/plugin-token
Description: Token plugin for Monad Agent Kit - ERC20 and native MON operations
Latest version: 0.1.1

# @monad-agent-kit/plugin-token

Token operations plugin for [Monad Agent Kit](https://github.com/mertkaradayi/monad-agent-kit) — transfer, balance, approve, and allowance for native MON and ERC-20 tokens.

## Installation

```bash
bun add @monad-agent-kit/core @monad-agent-kit/plugin-token
```

## Usage

```typescript
import { MonadAgentKit } from "@monad-agent-kit/core"
import { tokenPlugin } from "@monad-agent-kit/plugin-token"

const agent = new MonadAgentKit({ privateKey: "0x..." })
await agent.use(tokenPlugin)
```

## Actions

### transfer

Send native MON or ERC-20 tokens.

```typescript
// Send native MON
await agent.execute("transfer", {
  to: "0x...",
  amount: "1.5",
})

// Send ERC-20 token
await agent.execute("transfer", {
  to: "0x...",
  amount: "100",
  token: "0x...", // ERC-20 contract address
})
```

### batchTransfer

Execute multiple transfers in a single call. Supports mixed native MON and ERC-20 transfers.

```typescript
await agent.execute("batchTransfer", {
  transfers: [
    { to: "0xAlice", amount: "1.0" },                          // MON
    { to: "0xBob", amount: "50", token: "0xUSDC" },            // ERC-20
    { to: "0xCharlie", amount: "2.0" },                        // MON
  ],
})
```

### getBalance

Check token balance for any address.

```typescript
// Native MON balance (own wallet)
await agent.execute("getBalance", {})

// ERC-20 balance for another address
await agent.execute("getBalance", {
  address: "0x...",
  token: "0x...",
})
```

### approve

Set ERC-20 spending allowance.

```typescript
await agent.execute("approve", {
  token: "0x...",
  spender: "0x...",
  amount: "1000",
})
```

### getAllowance

Check current ERC-20 allowance.

```typescript
await agent.execute("getAllowance", {
  token: "0x...",
  spender: "0x...",
  owner: "0x...", // optional, defaults to agent wallet
})
```

## Exports

```typescript
import {
  tokenPlugin,         // Plugin object
  transferAction,      // Individual actions
  batchTransferAction,
  balanceAction,
  approveAction,
  allowanceAction,
  erc20Abi,            // Standard ERC-20 ABI
} from "@monad-agent-kit/plugin-token"
```

## License

MIT
npm package: @monad-agent-kit/plugin-tokens
Description: Token information plugin for Monad Agent Kit - token metadata, pricing, and portfolio
Latest version: 0.1.1

# @monad-agent-kit/plugin-tokens

Token information plugin for [Monad Agent Kit](https://github.com/mertkaradayi/monad-agent-kit) — token metadata, real-time pricing, portfolio tracking, transaction history, gas estimation, and agent analytics.

## Installation

```bash
bun add @monad-agent-kit/core @monad-agent-kit/plugin-tokens
```

## Usage

```typescript
import { MonadAgentKit } from "@monad-agent-kit/core"
import { tokensPlugin } from "@monad-agent-kit/plugin-tokens"

const agent = new MonadAgentKit({ privateKey: "0x..." })
await agent.use(tokensPlugin)
```

## Actions

### getTokenInfo

Get token metadata (name, symbol, decimals, total supply).

```typescript
await agent.execute("getTokenInfo", { token: "0xUSDC" })
// { name: "USD Coin", symbol: "USDC", decimals: 6, totalSupply: "243783269.384573" }
```

### getTokenPrice

Get real-time token price via DEX quote.

```typescript
await agent.execute("getTokenPrice", { token: "0xWMON" })
// { price: "0.0185", quoteToken: "USDC", source: "kuru" }
```

### getPortfolio

Get wallet balances with USD values. Uses Multicall3 batching for efficiency, checks 48 known tokens.

```typescript
await agent.execute("getPortfolio", {
  includePrices: true,
  alchemyApiKey: "...", // optional, enables token discovery on testnet
})
// { tokens: [{ symbol: "MON", balance: "5.0", usdValue: "0.09" }, ...], totalUsdValue: "7.65" }
```

### getTransactionHistory

Get wallet transaction history (native and token transfers).

```typescript
await agent.execute("getTransactionHistory", {
  limit: 20,
  type: "all", // "native" | "token" | "all"
})
```

### getFirstActivity

Find when a wallet was first active on-chain.

```typescript
await agent.execute("getFirstActivity", { address: "0x..." })
// { blockNumber: 12345, timestamp: 1706745600, transactionHash: "0x..." }
```

### estimateGas

Estimate gas cost before executing a transaction.

```typescript
await agent.execute("estimateGas", {
  to: "0x...",
  value: "1000000000000000000", // 1 MON in wei
})
// { gasLimit: "21000", gasCost: "0.000042", gasCostUsd: "0.0000008" }
```

### simulateTransaction

Dry-run a transaction to preview success/failure and gas cost without sending it.

```typescript
await agent.execute("simulateTransaction", {
  to: "0x...",
  data: "0x...",
})
// { success: true, gasUsed: "45000", returnData: "0x..." }
```

### getActionHistory

Query the agent's action execution history from the in-memory transaction log.

```typescript
await agent.execute("getActionHistory", {
  action: "transfer",
  success: true,
  limit: 10,
})
```

### getActionStats

Get aggregate statistics about the agent's action history.

```typescript
await agent.execute("getActionStats", {})
// { total: 42, successful: 40, failed: 2, uniqueActions: 5, withTransaction: 15 }
```

## Constants

```typescript
import { KNOWN_TOKENS, STABLECOINS, getKnownTokens } from "@monad-agent-kit/plugin-tokens"

// Get all known tokens for a chain
const tokens = getKnownTokens(143) // mainnet
```

## License

MIT
npm package: @monad-crypto/token-list
Description: Official Monad token list with full TypeScript types
Latest version: 2.35.0

# @monad-crypto/token-list

[![npm](https://img.shields.io/npm/v/@monad-crypto/token-list)](https://www.npmjs.com/package/@monad-crypto/token-list)
[![license](https://img.shields.io/npm/l/@monad-crypto/token-list)](./LICENSE)

This package provides a publicly maintained registry of tokens on Monad. This token list is for informational and convenience purposes only. The inclusion of any token, asset, or contract address in this list does not constitute an endorsement, recommendation, or representation as to the safety, legitimacy, or value of such token. Use of this package and its contents is entirely at your own risk.

## Install

```sh
npm install @monad-crypto/token-list
# or
pnpm add @monad-crypto/token-list
# or
yarn add @monad-crypto/token-list
# or
bun add @monad-crypto/token-list
```

Requires Node.js 18 or later.

## Quick Start

```ts
import { mainnetTokenList } from "@monad-crypto/token-list";

// The full list object
console.log(mainnetTokenList.tokens); // Token[]

// Find a specific token
const usdc = mainnetTokenList.tokens.find((token) => token.symbol === "USDC");
```

## Token Interface

Each entry in the `tokens` array follows this structure:

```ts
interface Token {
  chainId: 143 | 10143;    // 143 = mainnet, 10143 = testnet
  address: `0x${string}`;  // checksum address
  name: string;            // e.g. "USD Coin"
  symbol: string;          // e.g. "USDC"
  decimals: number;        // e.g. 6
  logoURI: string;         // hosted image URL
  extensions?: {
    coinGeckoId?: string;
    bridgeInfo?: {
      protocol: "LayerZero OFT" | "Wormhole" | "Circle CCTP" | /* … */;
      bridgeAddress: `0x${string}`;
    };
    // token address on other chains, keyed by chain ID
    crossChainAddresses?: Record<string, { address: `0x${string}` }>;
  };
}
```

The `extensions` field is only present for tokens that have additional metadata. Bridged tokens include `bridgeInfo` and their canonical addresses on other chains in `crossChainAddresses`.

## License

MIT