MNEE

https://docs.mnee.io
Admin
MNEE is a USD-backed stablecoin designed for instant, low-cost transactions, providing developers...
Tokens:74,963
Snippets:421
Trust Score:7.9
Update:10 months ago
Show doc for...
Tokens:
Raw
### Install MNEE Typescript SDK

Source: https://docs.mnee.io/getting-started/quick-start

This command installs the MNEE Typescript SDK using npm. Ensure you have Node.js and npm installed on your system. This is the first step to using the SDK in your project.

```bash
npm i @mnee/ts-sdk
```

--------------------------------

### Setup and Configuration

Source: https://docs.mnee.io/dev-tools/llm-context

Information on how to install, initialize, and configure the MNEE SDK.

```APIDOC
## Setup and Configuration

### Installation and Initialization

```typescript
import Mnee from '@mnee/ts-sdk';

// Initialize MNEE SDK
const mnee = new Mnee({
  environment: 'production', // or 'sandbox' (required)
  apiKey: 'your-api-key'     // optional but recommended
});

// All types are also exported from the main module
import {
  MNEEBalance,
  MNEEUtxo,
  TransferResponse,
  HDWallet
  // ... and more
} from '@mnee/ts-sdk';
```

#### SdkConfig Type

```typescript
type SdkConfig = {
  environment: 'production' | 'sandbox';
  apiKey?: string;
};
```

### Configuration

The `config()` method retrieves the current MNEE service configuration including fee structure and system addresses.

```typescript
const config = await mnee.config();
```

#### Response Structure

```typescript
interface MNEEConfig {
  approver: string;      // Cosigner public key
  feeAddress: string;    // Fee collection address
  burnAddress: string;   // Burn operations address
  mintAddress: string;   // Mint operations address
  fees: FeeTier[];       // Fee structure tiers
}

interface FeeTier {
  min: number;    // Minimum amount (atomic units)
  max: number;    // Maximum amount (atomic units)
  fee: number;    // Fee amount (atomic units)
}
```
```

--------------------------------

### Configure MNEE Typescript SDK

Source: https://docs.mnee.io/getting-started/quick-start

This code snippet demonstrates how to configure the MNEE Typescript SDK with your API key and environment settings. It initializes the SDK and fetches the current configuration, which is useful for verifying your setup. Ensure your API key and environment ('sandbox' or 'production') are correctly set.

```typescript
import Mnee from '@mnee/ts-sdk';

const config = {
  environment: 'sandbox', // or 'production'
  apiKey: 'your-api-key'
};

const mnee = new Mnee(config);

mnee.config().then(mneeConfig => {
  console.log('MNEE Configuration:', mneeConfig);
});

```

--------------------------------

### Install and Run ngrok for Local Testing (Bash)

Source: https://docs.mnee.io/mnee-sdk/transfer-webhooks

Provides bash commands to install ngrok, start a local development server (assuming it runs on port 3000), and then expose that local server to the internet using ngrok. This allows for testing webhooks during local development by providing a publicly accessible URL.

```bash
# Install ngrok
npm install -g ngrok

# Start your local server on port 3000
npm run dev

# In another terminal, expose port 3000
ngrok http 3000

# Use the ngrok URL as your webhook
# https://abc123.ngrok.io/webhook
```

--------------------------------

### Send MNEE using Typescript SDK

Source: https://docs.mnee.io/getting-started/quick-start

This code snippet shows how to send MNEE using the MNEE Typescript SDK. It requires the recipient's address, the amount to send, and your WIF private key. The `transfer` method sends the MNEE and returns a response object. Ensure your wallet is funded and the private key is valid.

```typescript
const recipient = 'recipient-mnee-address';
const amount = 0.01; // Amount in MNEE as float (up to 5 decimals)
const wif = 'your-wif-private-key';

// Prepare the transfer request
const request = [
  {
    address: recipient,
    amount,
  },
];

// Send the payment
mnee.transfer(request, wif).then(response => {
  console.log('Transfer result:', response);
});

```

--------------------------------

### Install MNEE CLI

Source: https://docs.mnee.io/dev-tools/coin-faucet

Installs the MNEE CLI globally using npm. This is a prerequisite for interacting with the MNEE faucet and other CLI functionalities. Ensure Node.js and npm are installed.

```bash
npm i -g @mnee/cli
```

--------------------------------

### Get UTXOs for an Address with MNEE SDK in TypeScript

Source: https://docs.mnee.io/dev-tools/llm-context

Shows how to fetch Unspent Transaction Outputs (UTXOs) for a given address using `mnee.getUtxos()`. Includes examples for single address, pagination, multiple addresses, and optimized fetching for transfer amounts.

```typescript
// Single address (returns up to 10 UTXOs by default)
const utxos = await mnee.getUtxos('address');

// With pagination
const utxos = await mnee.getUtxos('address', 0, 100, 'desc');
// Parameters: address, page, size (max 1000), order ('asc' | 'desc')

// Multiple addresses
const utxos = await mnee.getUtxos(['address1', 'address2'], 0, 50);
// Returns: MNEEUtxo[]

// Get just enough UTXOS for a specific amount (optimized for transfers)
const requiredAmount = mnee.toAtomicAmount(5.0); // Convert 5 MNEE to atomic units
const enoughUtxos = await mnee.getEnoughUtxos('address', requiredAmount); // Returns: MNEEUtxo[] - stops fetching once sufficient amount is reached

// Get all Utxos for an address (comprehensive wallet view)
const allUtxos = await mnee.getAllUtxos('address'); // Returns: MNEEUtxo[] - fetchtes every UTXO for the address
```

--------------------------------

### Install MNEE CLI

Source: https://docs.mnee.io/dev-tools/mnee-cli

Installs the MNEE CLI globally using npm. This command is essential for accessing all MNEE wallet and token management functionalities from your terminal.

```bash
npm install -g @mnee/cli
```

--------------------------------

### Implementing a Webhook Endpoint (Express.js Example)

Source: https://docs.mnee.io/mnee-sdk/transfer-webhooks

Example implementation of a webhook handler using Express.js to process incoming MNEE transaction status updates.

```APIDOC
## Webhook Handler Implementation (Express.js)

### Description
This example demonstrates how to set up an Express.js server to listen for and process MNEE transfer webhook callbacks.

### Code Example
```typescript
import express from 'express';

const app = express();
app.use(express.json());

app.post('/webhook', async (req, res) => {
  const webhookData = req.body;
  
  console.log(`Transaction ${webhookData.id} status: ${webhookData.status}`);
  
  switch (webhookData.status) {
    case 'BROADCASTING':
      // Handle broadcasting status
      await updateDatabase(webhookData.id, 'broadcasting');
      break;
      
    case 'SUCCESS':
      // Handle successful broadcast
      await updateDatabase(webhookData.id, 'success', webhookData.tx_id);
      await notifyUser(webhookData.id, 'Your transaction has been broadcast!');
      break;
      
    case 'MINED':
      // Handle transaction mined
      await updateDatabase(webhookData.id, 'confirmed', webhookData.tx_id);
      await notifyUser(webhookData.id, 'Your transaction has been confirmed!');
      break;
      
    case 'FAILED':
      // Handle failed transaction
      await updateDatabase(webhookData.id, 'failed', null, webhookData.errors);
      await notifyUser(webhookData.id, `Transaction failed: ${webhookData.errors}`);
      break;
  }
  
  // Always respond with 200 to acknowledge receipt
  res.status(200).json({ received: true });
});

async function updateDatabase(id, status, tx_id = null, errors = null) {
  // Placeholder for database update logic
  console.log(`Updating DB for ${id}: status=${status}, tx_id=${tx_id}, errors=${errors}`);
}

async function notifyUser(id, message) {
  // Placeholder for user notification logic
  console.log(`Notifying user for ${id}: ${message}`);
}

app.listen(3000, () => {
  console.log('Webhook server listening on port 3000');
});
```
```

--------------------------------

### Get Enough UTXOs for MNEE Transfer (TypeScript)

Source: https://docs.mnee.io/mnee-sdk/get-enough-utxos

Demonstrates how to use the `getEnoughUtxos` method to obtain a specific number of UTXOs for a given MNEE address and a required token amount. Includes basic error handling for insufficient balances.

```typescript
const address = '1G6CB3Ch4zFkPmuhZzEyChQmrQPfi86qk3';
const requiredAmount = 500000; // 5.00000 MNEE in atomic units

try {
  const utxos = await mnee.getEnoughUtxos(address, requiredAmount);
  console.log('UTXOs for transfer:', utxos);
  console.log('Number of UTXOs needed:', utxos.length);
} catch (error) {
  console.error('Insufficient balance:', error.message);
}
```

--------------------------------

### TypeScript MNEE API Transfer with Webhook

Source: https://docs.mnee.io/dev-tools/llm-context

Example of initiating a transfer operation using the MNEE API and configuring a callback URL for receiving webhook notifications about the transaction status.

```typescript
const response = await mnee.transfer(recipients, wif, {
  broadcast: true,
  callbackUrl: 'https://your-api.com/webhook'
});
```

--------------------------------

### Get Balances using Batch (TypeScript)

Source: https://docs.mnee.io/dev-tools/llm-context

Executes a batch request to retrieve the balances for a list of addresses. It takes an array of addresses and optional batch configuration options.

```typescript
const result = await batch.getBalances(addresses, options);
// Returns: BatchResult<MNEEBalance>
```

--------------------------------

### GET /v1/config

Source: https://docs.mnee.io/api-reference/mnee-api

Retrieves the MNEE configuration and fee structure, including details about approvers, decimals, fee addresses, burn addresses, mint addresses, fees, and token IDs.

```APIDOC
## GET /v1/config

### Description
Get MNEE configuration and fee structure.

### Method
GET

### Endpoint
/v1/config

### Parameters
#### Query Parameters
- **auth_token** (apiKey) - Required - Your API Key for authentication.

### Request Example
```json
{
  "auth_token": "YOUR_API_KEY"
}
```

### Response
#### Success Response (200)
- **approver** (string) - The address of the approver.
- **decimals** (integer) - The number of decimal places for MNEE tokens.
- **feeAddress** (string) - The address where fees are collected.
- **burnAddress** (string) - The address where tokens are burned.
- **mintAddress** (string) - The address where tokens are minted.
- **fees** (array) - An array of fee objects, each containing `fee` (integer), `max` (integer), and `min` (integer).
- **tokenId** (string) - The unique identifier for the MNEE token.

#### Response Example
```json
{
  "approver": "0xApproverAddress",
  "decimals": 8,
  "feeAddress": "0xFeeAddress",
  "burnAddress": "0xBurnAddress",
  "mintAddress": "0xMintAddress",
  "fees": [
    {
      "fee": 100,
      "max": 10000,
      "min": 100
    }
  ],
  "tokenId": "MNEE_TOKEN_ID"
}
```

#### Error Response (400)
- **code** (integer) - The error code.
- **message** (string) - The error message.

#### Response Example
```json
{
  "code": 400,
  "message": "Bad Request"
}
```
```

--------------------------------

### TypeScript: Fetch and Display All UTXOs for an Address

Source: https://docs.mnee.io/mnee-sdk/get-all-utxos

This TypeScript code demonstrates how to use the `getAllUtxos` method to retrieve all UTXOs for a specific MNEE address. It includes error handling and calculates the total balance in both atomic units and MNEE.

```typescript
const address = '1G6CB3Ch4zFkPmuhZzEyChQmrQPfi86qk3';

try {
  const utxos = await mnee.getAllUtxos(address);
  console.log('All UTXOs:', utxos);
  console.log('Total UTXOs found:', utxos.length);

  // Calculate total balance
  const totalBalance = utxos.reduce((sum, utxo) => sum + utxo.data.bsv21.amt, 0);
  console.log('Total balance (atomic):', totalBalance);
  console.log('Total balance (MNEE):', mnee.fromAtomicAmount(totalBalance));
} catch (error) {
  console.error('Error fetching UTXOs:', error.message);
}
```

--------------------------------

### Verify Token Configuration Details (TypeScript)

Source: https://docs.mnee.io/mnee-sdk/config

Shows how to access and log specific token configuration properties like the token ID and decimals. This helps in understanding the unit conversion between MNEE and its atomic units.

```typescript
const config = await mnee.config();
console.log(`Token ID: ${config.tokenId}`);
console.log(`Decimals: ${config.decimals}`);
console.log(`1 MNEE = ${Math.pow(10, config.decimals)} atomic units`);
```

--------------------------------

### Get UTXOs using Batch (TypeScript)

Source: https://docs.mnee.io/dev-tools/llm-context

Executes a batch request to retrieve Unspent Transaction Outputs (UTXOs) for a list of addresses. It accepts addresses and optional batch configuration options.

```typescript
const result = await batch.getUtxos(addresses, options);
// Returns: BatchResult<BatchUtxoResult>
```

--------------------------------

### Get Multiple Address Balances with MNEE SDK in TypeScript

Source: https://docs.mnee.io/dev-tools/llm-context

Demonstrates how to retrieve balances for multiple addresses simultaneously using the `mnee.balances()` method, which accepts an array of addresses and returns an array of `MNEEBalance` objects.

```typescript
const balances = await mnee.balances(['address1', 'address2']);
// Returns: MNEEBalance[]
```

--------------------------------

### Initialize MNEE SDK and HDWallet (TypeScript)

Source: https://docs.mnee.io/dev-tools/llm-context

Sets up the MNEE SDK instance with environment and API key, and imports the HDWallet class for hierarchical deterministic wallet functionalities.

```typescript
import Mnee, { HDWallet } from '@mnee/ts-sdk';

const mnee = new Mnee({
  environment: 'production',  // required
  apiKey: 'your-api-key'      // optional but recommended
});
```

--------------------------------

### TypeScript/Express.js: Implement Webhook Endpoint

Source: https://docs.mnee.io/mnee-sdk/transfer-webhooks

An example of an Express.js server setup to handle incoming webhook POST requests from the MNEE API. It parses the JSON payload, logs the transaction status, and performs actions based on the status ('BROADCASTING', 'SUCCESS', 'MINED', 'FAILED'). It always responds with a 200 status code to acknowledge receipt.

```typescript
import express from 'express';

const app = express();
app.use(express.json());

app.post('/webhook', async (req, res) => {
  const webhookData = req.body;
  
  console.log(`Transaction ${webhookData.id} status: ${webhookData.status}`);
  
  switch (webhookData.status) {
    case 'BROADCASTING':
      // Transaction is being broadcast
      await updateDatabase(webhookData.id, 'broadcasting');
      break;
      
    case 'SUCCESS':
      // Transaction successfully broadcast
      await updateDatabase(webhookData.id, 'success', webhookData.tx_id);
      await notifyUser(webhookData.id, 'Your transaction has been broadcast!');
      break;
      
    case 'MINED':
      // Transaction mined into a block
      await updateDatabase(webhookData.id, 'confirmed', webhookData.tx_id);
      await notifyUser(webhookData.id, 'Your transaction has been confirmed!');
      break;
      
    case 'FAILED':
      // Transaction failed
      await updateDatabase(webhookData.id, 'failed', null, webhookData.errors);
      await notifyUser(webhookData.id, `Transaction failed: ${webhookData.errors}`);
      break;
  }
  
  // Always respond with 200 to acknowledge receipt
  res.status(200).json({ received: true });
});

app.listen(3000, () => {
  console.log('Webhook server listening on port 3000');
});
```

--------------------------------

### Initialize MNEE SDK with TypeScript

Source: https://docs.mnee.io/dev-tools/llm-context

Demonstrates how to import and initialize the MNEE SDK using TypeScript. It shows the required `environment` parameter and optional `apiKey`. It also highlights the export of common types from the main module.

```typescript
import Mnee from '@mnee/ts-sdk';

// Initialize MNEE SDK
const mnee = new Mnee({
  environment: 'production', // or 'sandbox' (required)
  apiKey: 'your-api-key'     // optional but recommended
});

// All types are also exported from the main module
import {
  MNEEBalance,
  MNEEUtxo,
  TransferResponse,
  HDWallet
  // ... and more
} from '@mnee/ts-sdk';
```

--------------------------------

### Initialize Mnee SDK with API Key (TypeScript)

Source: https://docs.mnee.io/getting-started/authentication

This snippet shows how to initialize the Mnee TypeScript SDK by providing your API key and specifying the environment. Ensure you replace 'YOUR_API_KEY_HERE' with your actual key. The SDK is used to interact with Mnee services.

```typescript
import Mnee from '@mnee/ts-sdk';

const mnee = new Mnee({
  environment: 'sandbox', // or 'production'
  apiKey: 'YOUR_API_KEY_HERE',
});
```

--------------------------------

### Monitor Mnee Transactions with TransactionMonitor Class (TypeScript)

Source: https://docs.mnee.io/mnee-sdk/get-transaction-status

The TransactionMonitor class facilitates real-time tracking of Mnee transaction statuses. It uses `setInterval` to periodically poll for updates and notifies a callback function upon status changes or errors. It handles starting, stopping, and stopping all monitoring tasks, and requires an instance of the Mnee SDK to interact with the blockchain.

```typescript
class TransactionMonitor {
  constructor(mnee) {
    this.mnee = mnee;
    this.monitoring = new Map();
  }
  
  async monitor(ticketId, callback, intervalMs = 2000) {
    if (this.monitoring.has(ticketId)) {
      console.log('Already monitoring:', ticketId);
      return;
    }
    
    const interval = setInterval(async () => {
      try {
        const status = await this.mnee.getTxStatus(ticketId);
        
        // Notify callback of status change
        callback(ticketId, status);
        
        // Stop monitoring if transaction is complete
        if (['SUCCESS', 'MINED', 'FAILED'].includes(status.status)) {
          this.stop(ticketId);
        }
      } catch (error) {
        console.error(`Error checking ${ticketId}:`, error);
        callback(ticketId, { status: 'ERROR', error: error.message });
        this.stop(ticketId);
      }
    }, intervalMs);
    
    this.monitoring.set(ticketId, interval);
  }
  
  stop(ticketId) {
    const interval = this.monitoring.get(ticketId);
    if (interval) {
      clearInterval(interval);
      this.monitoring.delete(ticketId);
      console.log('Stopped monitoring:', ticketId);
    }
  }
  
  stopAll() {
    for (const [ticketId, interval] of this.monitoring) {
      clearInterval(interval);
    }
    this.monitoring.clear();
    console.log('Stopped all monitoring');
  }
}

// Usage
const monitor = new TransactionMonitor(mnee);

monitor.monitor(ticketId, (id, status) => {
  console.log(`${id}: ${status.status}`);
  if (status.status === 'SUCCESS') {
    console.log('Transaction successful!', status.tx_id);
  }
});

```

--------------------------------

### Setup MNEE SDK and HD Wallet

Source: https://docs.mnee.io/utils/hd-wallet

Initializes the MNEE SDK with environment and API key, and creates an HD wallet instance using a mnemonic phrase and derivation path. The mnemonic is a BIP39 phrase (12-24 words), and the derivation path follows BIP44 standards. An optional cacheSize can be specified for address caching.

```typescript
import Mnee, { HDWallet } from '@mnee/ts-sdk';

// Initialize MNEE SDK
const mnee = new Mnee({
    environment: 'sandbox', 
    apiKey: 'your-api-key'
});

const mnemonic = 'your twelve word mnemonic phrase here ...';
const hdWallet = mnee.HDWallet(mnemonic, {
  derivationPath: "m/44'/236'/0'",
  cacheSize: 1000  // Optional: number of addresses to cache
});
```

--------------------------------

### Get Transaction Status

Source: https://docs.mnee.io/mnee-sdk/get-transaction-status

Retrieves the current status of a transaction that was submitted asynchronously using its ticketId.

```APIDOC
## GET /websites/mnee_io/getTxStatus

### Description
Retrieves the current status of a transaction that was submitted asynchronously. You can use the `ticketId` received from `transfer`, `transferMulti`, or `submitRawTx` operations to track the transaction's progress.

### Method
GET

### Endpoint
`/websites/mnee_io/getTxStatus`

### Parameters
#### Query Parameters
- **ticketId** (string) - Required - The ticket ID returned from a transfer or submitRawTx operation.

### Response
#### Success Response (200)
Returns a `TransferStatus` object containing the transaction's current state.
- **id** (string) - The ticket ID.
- **tx_id** (string) - The blockchain transaction ID.
- **tx_hex** (string) - The raw transaction hex.
- **action_requested** (string) - The action that was requested (e.g., 'transfer').
- **status** (string) - The current status of the transaction. Possible values: 'BROADCASTING', 'SUCCESS', 'MINED', 'FAILED'.
- **createdAt** (string) - ISO timestamp when the ticket was created.
- **updatedAt** (string) - ISO timestamp of the last update.
- **errors** (string | null) - Error details if the status is 'FAILED'.

### Response Example
```json
{
  "id": "5d4b9bfb-4dee-4f9b-bb0c-6b068572fae3",
  "tx_id": "0xabcdef1234567890",
  "tx_hex": "0x0100000001...",
  "action_requested": "transfer",
  "status": "BROADCASTING",
  "createdAt": "2023-10-27T10:00:00Z",
  "updatedAt": "2023-10-27T10:05:00Z",
  "errors": null
}
```

### Status Values
- **BROADCASTING**: Transaction is being broadcast to the network.
- **SUCCESS**: Transaction has been successfully broadcast and accepted by the network.
- **MINED**: Transaction has been confirmed in a block.
- **FAILED**: Transaction failed. Check the `errors` field for details.
```

--------------------------------

### Initialize MNEE SDK for Batch Operations (TypeScript)

Source: https://docs.mnee.io/utils/batch-operations

Sets up the MNEE SDK client for making batch API requests. Requires environment and API key. Assumes the 'mnee' instance is available for subsequent operations.

```typescript
import Mnee from '@mnee/ts-sdk';

// Initialize MNEE SDK
const mnee = new Mnee({
    environment: 'sandbox', 
    apiKey: 'your-api-key'
});

// For examples below, assume mnee is already set up
```

--------------------------------

### Get UTXOs for Multiple Addresses (TypeScript)

Source: https://docs.mnee.io/mnee-sdk/get-utxos

Retrieves UTXOs from multiple MNEE addresses simultaneously. You can specify the number of UTXOs to fetch and the sort order.

```typescript
const addresses = ['1G6CB3Ch4zFkPmuhZzEyChQmrQPfi86qk3', '1BFaJwJz5KPYGe28afDkGswbuKK6uK8hzQ'];

// Returns up to 10 UTXOs by default
const utxos = await mnee.getUtxos(addresses);
console.log('UTXOs from all addresses:', utxos);

// Get more UTXOs by specifying size
const moreUtxos = await mnee.getUtxos(addresses, 0, 100, 'desc');
console.log('First 100 UTXOs (newest first):', moreUtxos);
```

--------------------------------

### Create MNEE Sandbox Wallet

Source: https://docs.mnee.io/dev-tools/coin-faucet

Creates a new MNEE wallet, specifically for the sandbox environment. Users must select 'Sandbox' during the creation process to obtain test tokens. This command initializes a local wallet.

```bash
mnee create
```

--------------------------------

### Authenticate with MNEE Developer Portal

Source: https://docs.mnee.io/dev-tools/mnee-cli

Commands for authentication with the MNEE Developer Portal. Includes logging in, logging out, viewing current user information, and requesting sandbox tokens via the faucet.

```bash
mnee login
mnee logout
mnee whoami
mnee faucet
mnee faucet -a <address>
mnee faucet --address <address>
```

--------------------------------

### Get UTXOs for a Single Address (TypeScript)

Source: https://docs.mnee.io/mnee-sdk/get-utxos

Retrieves up to 10 Unspent Transaction Outputs (UTXOs) for a given MNEE address. This is the most basic usage, returning a default set of spendable tokens.

```typescript
const address = '1G6CB3Ch4zFkPmuhZzEyChQmrQPfi86qk3';

// Returns up to 10 UTXOs by default
const utxos = await mnee.getUtxos(address);
console.log('UTXOs:', utxos);
```

--------------------------------

### Perform a Simple Transfer with MNEE SDK in TypeScript

Source: https://docs.mnee.io/dev-tools/llm-context

Provides an example of executing a simple MNEE transfer using the `mnee.transfer()` method. It shows how to define recipients with addresses and amounts, provide sender's private key, and includes optional parameters for broadcasting and webhook callbacks.

```typescript
const recipients: SendMNEE[] = [
  { address: 'recipient1', amount: 10.5 },
  { address: 'recipient2', amount: 5.25 }
];

const response = await mnee.transfer(
  recipients,
  'sender-private-key-wif',
  { broadcast: true, callbackUrl: 'https://your-api.com/webhook' }  // optional
);
// Returns: TransferResponse

// Get transaction ID from status
const status = await mnee.getTxStatus(response.ticketId);
console.log('Transaction ID:', status.tx_id);
```

--------------------------------

### Get MNEE Configuration

Source: https://docs.mnee.io/mnee-sdk/config

Retrieves the current configuration for the MNEE service. This configuration includes essential parameters such as the token ID, current fees, and other settings required for interacting with the MNEE network.

```APIDOC
## GET /config

### Description
Retrieves the current configuration for the MNEE service. This configuration includes essential parameters such as the token ID, current fees, and other settings required for interacting with the MNEE network.

### Method
GET

### Endpoint
/config

### Parameters
#### Query Parameters
None

#### Request Body
None

### Request Example
```typescript
import Mnee from '@mnee/ts-sdk';

const config = {
  environment: 'sandbox', // or 'production'
  apiKey: 'your-api-key', // optional
};
const mnee = new Mnee(config);

mnee.config().then(mneeConfig => {
  console.log('MNEE Configuration:', mneeConfig);
});
```

### Response
#### Success Response (200)
- **approver** (string) - The public key of the MNEE approver/cosigner service
- **feeAddress** (string) - The address where transaction fees are sent
- **burnAddress** (string) - The address used for burning MNEE tokens
- **mintAddress** (string) - The address used for minting new MNEE tokens
- **fees** (array) - Array of fee tiers based on transaction amount
  - **min** (number) - Minimum amount for this fee tier (in atomic units)
  - **max** (number) - Maximum amount for this fee tier (in atomic units)
  - **fee** (number) - Fee amount for this tier (in atomic units)
- **decimals** (number) - Number of decimal places for MNEE (5 decimals = 100,000 atomic units per MNEE)
- **tokenId** (string) - The unique identifier for the MNEE token on the blockchain

#### Response Example
```json
{
  "approver": "020a177d6a5e6f3a8689acd2e313bd1cf0dcf5a243d1cc67b7218602aee9e04b2f",
  "feeAddress": "19Vq2TV8aVhFNLQkhDMdnEQ7zT96x6F3PK",
  "burnAddress": "1FGEBTUu7EqWWK5DKrG6pxjEGLahpATnA8",
  "mintAddress": "1inHbiwj2jrEcZPiSYnfgJ8FmS1Bmk4Dh",
  "fees": [
    { "min": 0, "max": 1000000, "fee": 100 },
    { "min": 1000001, "max": 9007199254740991, "fee": 1000 }
  ],
  "decimals": 5,
  "tokenId": "ae59f3b898ec61acbdb6cc7a245fabeded0c094bf046f35206a3aec60ef88127_0"
}
```
```

--------------------------------

### Get Enough UTXOs

Source: https://docs.mnee.io/mnee-sdk/get-enough-utxos

Retrieves a specific number of UTXOs for a given MNEE address and token amount. This method is optimized for transfers, as it stops fetching UTXOs once the required amount is reached.

```APIDOC
## POST /api/getEnoughUtxos

### Description
Fetches a minimal set of UTXOs for a MNEE address that collectively meet or exceed a specified token amount. This is efficient for initiating token transfers.

### Method
POST

### Endpoint
/api/getEnoughUtxos

### Parameters
#### Request Body
- **address** (string) - Required - The MNEE address to fetch UTXOs for.
- **totalAtomicTokenAmount** (number) - Required - The required amount in atomic units (1 MNEE = 100,000 atomic units).

### Request Example
```json
{
  "address": "1G6CB3Ch4zFkPmuhZzEyChQmrQPfi86qk3",
  "totalAtomicTokenAmount": 500000
}
```

### Response
#### Success Response (200)
- **utxos** (array) - An array of MNEEUtxo objects containing just enough UTXOs to meet or exceed the required amount.
  - **MNEEUtxo Structure**:
    - **data** (object)
      - **bsv21** (object)
        - **amt** (number) - Amount in atomic units.
        - **dec** (number) - Decimal places.
        - **icon** (string) - Token icon.
        - **id** (string) - Token ID.
        - **op** (string) - Operation type.
        - **sym** (string) - Token symbol.
      - **cosign** (object)
        - **address** (string) - Cosigner address.
        - **cosigner** (string) - Cosigner identifier.
    - **height** (number) - Block height.
    - **idx** (number) - Transaction index.
    - **outpoint** (string) - Transaction outpoint (txid_vout).
    - **satoshis** (number) - Satoshi amount.
    - **script** (string) - Script hex.
    - **txid** (string) - Transaction ID.
    - **vout** (number) - Output index.

#### Response Example
```json
{
  "utxos": [
    {
      "data": {
        "bsv21": {
          "amt": 1000000,
          "dec": 5,
          "icon": "",
          "id": "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
          "op": "0x3c",
          "sym": "MNEE"
        },
        "cosign": {
          "address": "another_address",
          "cosigner": "cosigner_id"
        }
      },
      "height": 1000,
      "idx": 0,
      "outpoint": "txid1_0",
      "satoshis": 1000000,
      "script": "script_hex_1",
      "txid": "txid1",
      "vout": 0
    }
  ]
}
```

#### Error Response (400)
- **message** (string) - "Insufficient MNEE balance. Max transfer amount: X.XXXXX"

### Error Handling
Throws an error if the specified MNEE address does not have sufficient tokens to meet the `totalAtomicTokenAmount`.
```

--------------------------------

### Create an HD Wallet Instance (TypeScript)

Source: https://docs.mnee.io/dev-tools/llm-context

Initializes an HDWallet instance using a mnemonic phrase and optional configuration like derivation path and cache size. This object manages keys and addresses.

```typescript
const hdWallet = mnee.HDWallet(mnemonic, {
  derivationPath: "m/44'/236'/0'",  // BIP44 path
  cacheSize: 1000                    // Optional cache size
});
```

--------------------------------

### Get UTXOs with Pagination and Sorting (TypeScript)

Source: https://docs.mnee.io/mnee-sdk/get-utxos

Fetches UTXOs for a single address with control over pagination and sorting. You can specify the page number, the number of UTXOs per page, and the sort order ('asc' or 'desc').

```typescript
const address = '1G6CB3Ch4zFkPmuhZzEyChQmrQPfi86qk3';

// Get first page with 20 UTXOs
const page1 = await mnee.getUtxos(address, 0, 20);
console.log('First 20 UTXOs:', page1);

// Get second page
const page2 = await mnee.getUtxos(address, 1, 20);
console.log('Next 20 UTXOs:', page2);

// Get UTXOs in ascending order (oldest first)
const ascUtxos = await mnee.getUtxos(address, 0, 50, 'asc');
console.log('Oldest UTXOs first:', ascUtxos);
```

--------------------------------

### Login to MNEE Dev Portal

Source: https://docs.mnee.io/dev-tools/coin-faucet

Connects the MNEE CLI to the developer portal. This step is necessary to authenticate your account and enable features like requesting faucet tokens. Ensure you have a developer account.

```bash
mnee login
```

--------------------------------

### GET /getAllUtxos

Source: https://docs.mnee.io/mnee-sdk/get-all-utxos

Retrieves all Unspent Transaction Outputs (UTXOs) for a specified MNEE address. This method automatically handles pagination to fetch all available UTXOs, making it suitable for complete balance calculations and detailed wallet analysis.

```APIDOC
## GET /getAllUtxos

### Description
Retrieves all Unspent Transaction Outputs (UTXOs) for a MNEE address. This method automatically paginates through all available results to ensure every UTXO is fetched, which is ideal for comprehensive balance calculations and wallet management.

### Method
GET

### Endpoint
/getAllUtxos

### Parameters
#### Query Parameters
- **address** (string) - Required - The MNEE address to fetch UTXOs for.

### Request Example
```
GET /getAllUtxos?address=1G6CB3Ch4zFkPmuhZzEyChQmrQPfi86qk3
```

### Response
#### Success Response (200)
- **utxos** (array) - An array of MNEEUtxo objects, each representing an unspent transaction output.
  - **height** (number) - The block height at which the transaction occurred.
  - **idx** (number) - The index of the output within the transaction.
  - **outpoint** (string) - The transaction outpoint in the format 'txid_vout'.
  - **satoshis** (number) - The amount of satoshis in the UTXO.
  - **script** (string) - The script hex of the output.
  - **txid** (string) - The transaction ID.
  - **vout** (number) - The output index.
  - **data** (object) - Additional data associated with the UTXO.
    - **bsv21** (object) - BSV21 token data.
      - **amt** (number) - The token amount in atomic units.
      - **dec** (number) - The number of decimal places for the token.
      - **icon** (string) - The URL or identifier for the token icon.
      - **id** (string) - The unique identifier for the token.
      - **op** (string) - The operation type associated with the token.
      - **sym** (string) - The symbol of the token.
    - **cosign** (object) - Cosigner information.
      - **address** (string) - The address of the cosigner.
      - **cosigner** (string) - The identifier of the cosigner.

#### Response Example
```json
[
  {
    "height": 780000,
    "idx": 0,
    "outpoint": "a1b2c3d4e5..._0",
    "satoshis": 10000,
    "script": "...",
    "txid": "a1b2c3d4e5...",
    "vout": 0,
    "data": {
      "bsv21": {
        "amt": 5000000000,
        "dec": 8,
        "icon": "url_to_icon",
        "id": "TOKENID123",
        "op": "TRANSFER",
        "sym": "MYTOKEN"
      },
      "cosign": {
        "address": "cosigner_address",
        "cosigner": "cosigner_id"
      }
    }
  }
]
```

### Error Handling
- **400 Bad Request**: Invalid address format or other request errors.
- **500 Internal Server Error**: Server-side issues preventing UTXO retrieval.

#### Error Response Example
```json
{
  "error": "Invalid MNEE address provided."
}
```
```

--------------------------------

### Retrieve MNEE Configuration using TypeScript

Source: https://docs.mnee.io/dev-tools/llm-context

Shows how to call the `config()` method on an initialized MNEE SDK instance to retrieve the current service configuration. This includes fee structures and system addresses.

```typescript
const config = await mnee.config();
```

--------------------------------

### Webhook Best Practices

Source: https://docs.mnee.io/mnee-sdk/transfer-webhooks

Essential best practices for implementing a robust webhook handler, including returning 200 OK and ensuring idempotency.

```APIDOC
## Webhook Best Practices

### Description
Guidelines to ensure reliable and efficient handling of MNEE transfer webhooks.

### 1. Always Return 200 OK

Always respond with a 200 status code to acknowledge receipt of the webhook, even if your internal processing encounters an error. This prevents the MNEE API from retrying the webhook unnecessarily.

```typescript
app.post('/webhook', async (req, res) => {
  try {
    await processWebhook(req.body);
  } catch (error) {
    console.error('Webhook processing failed:', error);
  }
  
  res.status(200).json({ received: true });
});
```

### 2. Implement Idempotency

Design your webhook handler to be idempotent, meaning that processing the same webhook multiple times should have the same effect as processing it once. This is crucial because webhooks may be sent more than once for the same event.

```typescript
async function processWebhook(data) {
  // Check if this specific update (id, status, and timestamp) has already been processed
  const processed = await checkIfProcessed(data.id, data.status, data.updatedAt);
  if (processed) {
    console.log(`Already processed ${data.id} at status ${data.status}`);
    return;
  }
  
  // Process the update (e.g., update database, send notifications)
  await updateTransactionStatus(data);
  
  // Mark this update as processed to prevent reprocessing
  await markAsProcessed(data.id, data.status, data.updatedAt);
}

async function checkIfProcessed(id, status, updatedAt) {
  // Placeholder for checking if the update has been processed
  // This might involve querying a database for a record with matching id, status, and timestamp
  return false; // Assume not processed for example
}

async function updateTransactionStatus(data) {
  // Placeholder for the actual business logic to update transaction status
  console.log(`Updating transaction status for ${data.id} to ${data.status}`);
}

async function markAsProcessed(id, status, updatedAt) {
  // Placeholder for marking the update as processed in your system
  console.log(`Marking update as processed for ${id} at ${updatedAt}`);
}
```
```

--------------------------------

### Get Basic Transaction Status - TypeScript

Source: https://docs.mnee.io/mnee-sdk/get-transaction-status

Retrieves the current status of a transaction using its `ticketId`. It returns an object containing the status, transaction ID, and raw transaction hex. This is useful for immediate status checks after submitting a transaction.

```typescript
const ticketId = '5d4b9bfb-4dee-4f9b-bb0c-6b068572fae3'; // From transfer response
const status = await mnee.getTxStatus(ticketId); 
console.log('Transaction status:', status.status); console.log('Transaction ID:', status.tx_id);
```

--------------------------------

### Get Transaction Status with Retry Logic - TypeScript

Source: https://docs.mnee.io/mnee-sdk/get-transaction-status

Fetches transaction status with a specified number of retries and exponential backoff. This function improves resilience by automatically retrying the `getTxStatus` call in case of temporary network issues or service unavailability. If all retries fail, the original error is re-thrown.

```typescript
async function getTxWithRetry(ticketId, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const status = await mnee.getTxStatus(ticketId);
      return status;
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      
      // Wait before retry (exponential backoff)
      await new Promise(resolve => setTimeout(resolve, Math.pow(2, i) * 1000));
    }
  }
}
```

--------------------------------

### Manage Private Keys (Export, Import)

Source: https://docs.mnee.io/dev-tools/mnee-cli

Commands for securely handling private keys. 'Export' provides the private key in WIF format after password confirmation, while 'import' allows adding an existing WIF key to MNEE.

```bash
mnee export
mnee import
```

--------------------------------

### GET /v1/tx/{txid}

Source: https://docs.mnee.io/api-reference/mnee-api

Retrieves the raw transaction data for a given transaction ID.

```APIDOC
## GET /v1/tx/{txid}

### Description
Retrieve transaction data by its transaction ID.

### Method
GET

### Endpoint
/v1/tx/{txid}

### Path Parameters
- **txid** (string) - Required - The transaction ID.

### Response
#### Success Response (200)
- **transactionData** (mnee.TransactionData) - The transaction data object.

#### Transaction Data Object (`mnee.TransactionData`)
- **rawtx** (string) - The raw transaction hex string.

#### Response Example
```json
{
  "rawtx": "raw_transaction_hex_string"
}
```

#### Error Response (400)
- **code** (integer) - Error code.
- **message** (string) - Error message.

```

--------------------------------

### Manage MNEE Wallets (Create, Address, Balance, History)

Source: https://docs.mnee.io/dev-tools/mnee-cli

Core commands for wallet management including creating new wallets, viewing the active wallet's address, checking MNEE balance, and retrieving transaction history. Options for unconfirmed and fresh history are available.

```bash
mnee create
mnee address
mnee balance
mnee history
mnee history -u
mnee history -f
```

--------------------------------

### GET /v1/sync

Source: https://docs.mnee.io/api-reference/mnee-api

Gathers a list of all MNEE transactions. You can filter transactions by a minimum score and limit the number of results.

```APIDOC
## GET /v1/sync

### Description
Gather a list of all MNEE transactions.

### Method
GET

### Endpoint
/v1/sync

### Parameters
#### Query Parameters
- **auth_token** (apiKey) - Required - Your API Key for authentication.
- **from** (integer) - Optional - Minimum score to filter transactions.
- **limit** (integer) - Optional - Maximum number of transactions to return. Defaults to 1000.

### Request Example
```json
{
  "auth_token": "YOUR_API_KEY",
  "from": 100,
  "limit": 50
}
```

### Response
#### Success Response (200)
- **blkHash** (string) - The hash of the block containing the transaction.
- **blkTime** (integer) - The timestamp of the block.
- **height** (integer) - The height of the block.
- **idx** (integer) - The index of the transaction within the block.
- **outs** (array) - An array of integers representing transaction outputs.
- **rawtx** (string) - The raw transaction data.
- **receivers** (array) - An array of strings representing the receivers of the transaction.
- **score** (number) - The score of the transaction.
- **senders** (array) - An array of strings representing the senders of the transaction.
- **txid** (string) - The transaction ID.

#### Response Example
```json
[
  {
    "blkHash": "0xBlockHash",
    "blkTime": 1678886400,
    "height": 1000,
    "idx": 0,
    "outs": [10000],
    "rawtx": "0xRawTxData",
    "receivers": ["0xReceiverAddress"],
    "score": 150.5,
    "senders": ["0xSenderAddress"],
    "txid": "0xTxId"
  }
]
```

#### Error Response (400)
- **code** (integer) - The error code.
- **message** (string) - The error message.

#### Response Example
```json
{
  "code": 400,
  "message": "Bad Request"
}
```
```
Tokens:
Raw