n8n-nodes-agnicwallet 1.0.0

package/README.md

@@ -0,0 +1,305 @@
+# n8n-nodes-agnicwallet
+
+[![NPM Version](https://img.shields.io/npm/v/n8n-nodes-agnicwallet)](https://www.npmjs.com/package/n8n-nodes-agnicwallet)
+[![License](https://img.shields.io/npm/l/n8n-nodes-agnicwallet)](https://github.com/agnicpay/agnicwallet-project/blob/main/LICENSE)
+
+N8N community node for AgnicWallet - automated Web3 payments for X402-enabled APIs.
+
+Make HTTP requests to X402-enabled APIs with automatic blockchain payment handling via AgnicWallet. No manual wallet management, no complex crypto operations - just authenticate and automate.
+
+## What is X402?
+
+[X402](https://www.x402.org/) is an open standard for HTTP-based payments. APIs return a `402 Payment Required` status with payment details, and your wallet automatically handles the payment to unlock the resource.
+
+## What is AgnicWallet?
+
+AgnicWallet is a non-custodial Web3 wallet service built on [Privy](https://privy.io) that handles blockchain payments automatically. Connect once, then all X402 payments happen seamlessly in the background.
+
+## Features
+
+- ✅ **Automatic X402 payment handling** - No manual wallet interactions
+- ✅ **OAuth2 authentication** - Secure connection to your AgnicWallet
+- ✅ **API Key support** - For programmatic access and CI/CD
+- ✅ **Multiple HTTP methods** - GET, POST, PUT, DELETE
+- ✅ **Custom headers** - Add any headers your API needs
+- ✅ **JSON body support** - For POST/PUT requests
+- ✅ **Payment metadata** - See exactly what you paid and when
+- ✅ **Monthly spending limits** - Built-in safety controls
+- ✅ **Base Sepolia support** - Currently supports USDC on Base Sepolia testnet
+
+## Installation
+
+### For self-hosted N8N:
+
+```bash
+npm install -g n8n-nodes-agnicwallet
+```
+
+Then restart N8N:
+
+```bash
+n8n start
+```
+
+### For Docker:
+
+Add to your Dockerfile:
+
+```dockerfile
+FROM n8nio/n8n:latest
+
+USER root
+RUN npm install -g n8n-nodes-agnicwallet
+USER node
+```
+
+### For n8n.cloud:
+
+Not yet available. This node must first be approved as a community node by the N8N team.
+
+## Setup
+
+### 1. Create AgnicWallet Account
+
+1. Go to [AgnicWallet](https://agnicwallet-project.vercel.app)
+2. Sign up with email/social login (powered by Privy)
+3. Your embedded wallet is created automatically
+
+### 2. Connect to N8N
+
+#### Option A: OAuth2 (Recommended)
+
+1. In N8N, add the **AgnicWallet X402 Request** node
+2. Select **OAuth2** authentication
+3. Click **Connect my account**
+4. Authorize AgnicWallet in the popup
+5. Done! Your wallet is connected
+
+#### Option B: API Key
+
+1. Log in to [AgnicWallet](https://agnicwallet-project.vercel.app)
+2. Go to **Settings** → **API Tokens**
+3. Generate a new token
+4. In N8N, select **API Key** authentication
+5. Paste your token
+6. Done!
+
+## Usage
+
+### Basic Example: ChatGPT via X402
+
+Configure the node:
+
+- **Method:** `POST`
+- **URL:** `https://agnicbillo-proxy.asad-safari.workers.dev/v1/custom/chatgpt/v1/chat/completions`
+- **Headers:**
+  - Name: `X-AgnicBillo-Key`
+  - Value: `agb_qroy8w9rb5lnpcla8ydl`
+- **Body:**
+  ```json
+  {
+    "model": "gpt-3.5-turbo",
+    "messages": [
+      {"role": "user", "content": "Hello!"}
+    ]
+  }
+  ```
+
+**What happens:**
+1. Node makes POST request
+2. Receives `402 Payment Required`
+3. Automatically signs payment with your wallet
+4. Retries with payment proof
+5. Returns ChatGPT response with payment metadata
+
+**Response:**
+```json
+{
+  "id": "chatcmpl-...",
+  "choices": [
+    {
+      "message": {
+        "role": "assistant",
+        "content": "Hello! How can I help you?"
+      }
+    }
+  ],
+  "_agnicWallet": {
+    "paymentMade": true,
+    "amountPaid": 0.01,
+    "timestamp": "2025-10-28T13:46:44.079Z"
+  }
+}
+```
+
+### Example: Protected Content
+
+Simple GET request with payment:
+
+- **Method:** `GET`
+- **URL:** `https://www.x402.org/protected`
+
+Node automatically handles the $0.01 payment and returns the protected content.
+
+### Example: Dynamic Content
+
+Use N8N expressions for dynamic requests:
+
+- **Body:**
+  ```json
+  {
+    "model": "gpt-3.5-turbo",
+    "messages": [
+      {"role": "user", "content": "{{ $json.userMessage }}"}
+    ]
+  }
+  ```
+
+This pulls the message from previous nodes in your workflow.
+
+## Configuration Options
+
+### Authentication
+- **OAuth2** (recommended) - Secure account connection
+- **API Key** - For automation and CI/CD
+
+### HTTP Methods
+- GET
+- POST
+- PUT
+- DELETE
+
+### Headers
+Add multiple custom headers as key-value pairs
+
+### Body (POST/PUT only)
+JSON body for sending data to the API
+
+## How It Works
+
+1. **Make request** - Node sends HTTP request to X402 API
+2. **Check for 402** - If API returns `402 Payment Required`, node extracts payment details
+3. **Sign payment** - Node calls AgnicWallet backend to sign payment with your wallet
+4. **Retry request** - Node retries with `X-PAYMENT` header containing payment proof
+5. **Return response** - API validates payment and returns protected resource
+
+## Payment Details
+
+- **Network:** Base Sepolia (testnet)
+- **Token:** USDC
+- **Typical cost:** $0.01 per request
+- **Monthly limit:** $100 (configurable)
+- **Payment method:** EIP-3009 TransferWithAuthorization (gasless)
+
+## Security
+
+- **Non-custodial** - Your keys, your crypto (via Privy)
+- **OAuth2** - Industry-standard authentication
+- **Spending limits** - Monthly caps prevent overspending
+- **Payment review** - See all payments in AgnicWallet dashboard
+- **Revocable access** - Disconnect N8N anytime
+
+## Troubleshooting
+
+### "Payment signing failed"
+
+**Causes:**
+- AgnicWallet credentials not connected
+- Insufficient USDC balance
+- Backend server down
+
+**Solutions:**
+1. Reconnect credentials in N8N
+2. Check balance at [AgnicWallet](https://agnicwallet-project.vercel.app)
+3. Check backend status
+
+### "Request failed after payment"
+
+**Causes:**
+- Invalid URL
+- Wrong headers
+- Malformed JSON body
+
+**Solutions:**
+1. Verify URL is correct
+2. Check required headers for the API
+3. Validate JSON syntax
+
+### "Body field not visible"
+
+The body field only appears when Method is **POST** or **PUT**. For GET requests, no body is shown (HTTP standard).
+
+## Examples & Workflows
+
+See [example workflows](https://github.com/agnicpay/agnicwallet-project/tree/main/examples) in the GitHub repository.
+
+## API Reference
+
+### Node Properties
+
+| Property | Type | Required | Description |
+|----------|------|----------|-------------|
+| authentication | options | Yes | OAuth2 or API Key |
+| method | options | Yes | HTTP method |
+| url | string | Yes | X402 API endpoint |
+| headers | collection | No | Custom headers |
+| body | json | No* | JSON body (*POST/PUT only) |
+
+## Limitations
+
+- **Networks:** Currently Base Sepolia only (mainnet coming soon)
+- **Body types:** JSON only (form-encoded coming soon)
+- **Query params:** Use in URL for now (dedicated field coming soon)
+
+See [ENHANCEMENT_PLAN.md](https://github.com/agnicpay/agnicwallet-project/blob/main/n8n-nodes-agnicwallet/nodes/X402HttpRequest/ENHANCEMENT_PLAN.md) for upcoming features.
+
+## Contributing
+
+Contributions welcome! Please open issues or PRs at [GitHub](https://github.com/agnicpay/agnicwallet-project).
+
+## Support
+
+- **Issues:** [GitHub Issues](https://github.com/agnicpay/agnicwallet-project/issues)
+- **Docs:** [Full Documentation](https://github.com/agnicpay/agnicwallet-project)
+- **X402 Standard:** [x402.org](https://www.x402.org/)
+
+## License
+
+MIT - See [LICENSE](https://github.com/agnicpay/agnicwallet-project/blob/main/LICENSE)
+
+## Links
+
+- [NPM Package](https://www.npmjs.com/package/n8n-nodes-agnicwallet)
+- [GitHub Repository](https://github.com/agnicpay/agnicwallet-project)
+- [AgnicWallet Dashboard](https://agnicwallet-project.vercel.app)
+- [X402 Protocol](https://www.x402.org/)
+- [N8N Documentation](https://docs.n8n.io)
+
+## Roadmap
+
+### v1.1.0
+- Query parameters support
+- Form-encoded body
+- Timeout configuration
+
+### v1.2.0
+- Multiple networks (Base mainnet, Polygon, etc.)
+- Retry logic
+- Rate limiting
+
+### v2.0.0
+- File upload support
+- Streaming responses
+- Webhook triggers
+
+## Acknowledgments
+
+Built with:
+- [N8N](https://n8n.io) - Workflow automation
+- [Privy](https://privy.io) - Embedded wallets
+- [X402 Protocol](https://www.x402.org/) - HTTP payment standard
+- [Base](https://base.org) - L2 blockchain
+
+---
+
+Made with ❤️ by the AgnicWallet team

package/dist/credentials/AgnicWalletApi.credentials.d.ts

@@ -0,0 +1,8 @@
+import { IAuthenticateGeneric, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class AgnicWalletApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+}

package/dist/credentials/AgnicWalletApi.credentials.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgnicWalletApi = void 0;
+class AgnicWalletApi {
+    constructor() {
+        this.name = 'agnicWalletApi';
+        this.displayName = 'AgnicWallet API';
+        this.documentationUrl = 'https://docs.agnicwallet.com/n8n';
+        this.properties = [
+            {
+                displayName: 'User ID',
+                name: 'userId',
+                type: 'string',
+                default: '',
+                required: true,
+                description: 'Your AgnicWallet user ID (from dashboard)',
+                placeholder: 'user_2kX9mNz8pQw7VbC',
+            },
+            {
+                displayName: 'API Token',
+                name: 'apiToken',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                required: true,
+                description: 'Your AgnicWallet API token (starts with agnic_tok_)',
+                placeholder: 'agnic_tok_sk_live_...',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    'X-Agnic-Token': '={{$credentials.apiToken}}',
+                },
+            },
+        };
+    }
+}
+exports.AgnicWalletApi = AgnicWalletApi;

package/dist/credentials/AgnicWalletOAuth2Api.credentials.d.ts

@@ -0,0 +1,8 @@
+import { ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class AgnicWalletOAuth2Api implements ICredentialType {
+    name: string;
+    extends: string[];
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+}

package/dist/credentials/AgnicWalletOAuth2Api.credentials.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgnicWalletOAuth2Api = void 0;
+class AgnicWalletOAuth2Api {
+    constructor() {
+        this.name = 'agnicWalletOAuth2Api';
+        this.extends = ['oAuth2Api'];
+        this.displayName = 'AgnicWallet OAuth2 API';
+        this.documentationUrl = 'https://docs.agnicwallet.com/oauth';
+        this.properties = [
+            {
+                displayName: 'Grant Type',
+                name: 'grantType',
+                type: 'hidden',
+                default: 'authorizationCode',
+            },
+            {
+                displayName: 'Authorization URL',
+                name: 'authUrl',
+                type: 'string',
+                default: 'https://agnicwallet-project.onrender.com/oauth/authorize',
+                required: true,
+                description: 'The OAuth2 authorization endpoint',
+            },
+            {
+                displayName: 'Access Token URL',
+                name: 'accessTokenUrl',
+                type: 'string',
+                default: 'https://agnicwallet-project.onrender.com/oauth/token',
+                required: true,
+                description: 'The OAuth2 token endpoint',
+            },
+            {
+                displayName: 'Client ID',
+                name: 'clientId',
+                type: 'string',
+                default: 'n8n_default',
+                required: true,
+                description: 'OAuth2 Client ID (default: n8n_default)',
+            },
+            {
+                displayName: 'Client Secret',
+                name: 'clientSecret',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                description: 'OAuth2 Client Secret (optional for PKCE)',
+            },
+            {
+                displayName: 'Scope',
+                name: 'scope',
+                type: 'string',
+                default: 'payments:sign balance:read',
+                description: 'OAuth2 scopes',
+            },
+            {
+                displayName: 'Auth URI Query Parameters',
+                name: 'authQueryParameters',
+                type: 'string',
+                default: '',
+                description: 'Additional query parameters for authorization URL',
+            },
+            {
+                displayName: 'Authentication',
+                name: 'authentication',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Body',
+                        value: 'body',
+                    },
+                    {
+                        name: 'Header',
+                        value: 'header',
+                    },
+                ],
+                default: 'body',
+                description: 'How to send credentials',
+            },
+            {
+                displayName: 'Use PKCE',
+                name: 'usePKCE',
+                type: 'boolean',
+                default: true,
+                description: 'Whether to use PKCE (Proof Key for Code Exchange)',
+            },
+        ];
+    }
+}
+exports.AgnicWalletOAuth2Api = AgnicWalletOAuth2Api;

package/dist/nodes/X402HttpRequest/X402HttpRequest.node.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class X402HttpRequest implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/X402HttpRequest/X402HttpRequest.node.js

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.X402HttpRequest = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+class X402HttpRequest {
+    constructor() {
+        this.description = {
+            displayName: 'AgnicWallet X402 Request',
+            name: 'agnicWalletX402Request',
+            group: ['transform'],
+            version: 1,
+            description: 'Make HTTP requests to X402-enabled APIs with automatic payment via AgnicWallet',
+            defaults: {
+                name: 'AgnicWallet X402',
+            },
+            usableAsTool: true,
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'agnicWalletOAuth2Api',
+                    required: false,
+                    displayOptions: {
+                        show: {
+                            authentication: ['oAuth2'],
+                        },
+                    },
+                },
+                {
+                    name: 'agnicWalletApi',
+                    required: false,
+                    displayOptions: {
+                        show: {
+                            authentication: ['apiKey'],
+                        },
+                    },
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Authentication',
+                    name: 'authentication',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'OAuth2',
+                            value: 'oAuth2',
+                            description: 'Recommended: Connect your account',
+                        },
+                        {
+                            name: 'API Key',
+                            value: 'apiKey',
+                            description: 'For CI/CD or programmatic access',
+                        },
+                    ],
+                    default: 'oAuth2',
+                    description: 'How to authenticate with AgnicWallet',
+                },
+                {
+                    displayName: 'Method',
+                    name: 'method',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'GET',
+                            value: 'GET',
+                        },
+                        {
+                            name: 'POST',
+                            value: 'POST',
+                        },
+                        {
+                            name: 'PUT',
+                            value: 'PUT',
+                        },
+                        {
+                            name: 'DELETE',
+                            value: 'DELETE',
+                        },
+                    ],
+                    default: 'GET',
+                    description: 'The HTTP method to use',
+                },
+                {
+                    displayName: 'URL',
+                    name: 'url',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    placeholder: 'https://api.example.com/endpoint',
+                    description: 'The URL of the X402-enabled API',
+                },
+                {
+                    displayName: 'Headers',
+                    name: 'headers',
+                    type: 'fixedCollection',
+                    typeOptions: {
+                        multipleValues: true,
+                    },
+                    default: {},
+                    options: [
+                        {
+                            name: 'header',
+                            displayName: 'Header',
+                            values: [
+                                {
+                                    displayName: 'Name',
+                                    name: 'name',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'Name of the header',
+                                },
+                                {
+                                    displayName: 'Value',
+                                    name: 'value',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'Value of the header',
+                                },
+                            ],
+                        },
+                    ],
+                    description: 'Additional headers to send with the request',
+                },
+                {
+                    displayName: 'Body',
+                    name: 'body',
+                    type: 'json',
+                    default: '{}',
+                    displayOptions: {
+                        show: {
+                            method: ['POST', 'PUT'],
+                        },
+                    },
+                    description: 'JSON body to send with the request',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            try {
+                // Get authentication type
+                const authentication = this.getNodeParameter('authentication', itemIndex);
+                let apiBaseUrl;
+                let authHeader;
+                // Use AgnicWallet backend API endpoint (production cloud by default)
+                // Can override with AGNICWALLET_API_URL environment variable for local development
+                apiBaseUrl = process.env.AGNICWALLET_API_URL || 'https://agnicwallet-project.onrender.com';
+                if (authentication === 'oAuth2') {
+                    // OAuth2 authentication
+                    const credentials = await this.getCredentials('agnicWalletOAuth2Api', itemIndex);
+                    authHeader = `Bearer ${credentials.oauthTokenData.access_token}`;
+                }
+                else {
+                    // API Key authentication
+                    const credentials = await this.getCredentials('agnicWalletApi', itemIndex);
+                    const { apiToken } = credentials;
+                    authHeader = apiToken;
+                }
+                // Get parameters
+                const method = this.getNodeParameter('method', itemIndex);
+                const url = this.getNodeParameter('url', itemIndex);
+                const headersConfig = this.getNodeParameter('headers', itemIndex, {});
+                const body = this.getNodeParameter('body', itemIndex, '{}');
+                // Build headers
+                const headers = {
+                    'Content-Type': 'application/json',
+                };
+                if (headersConfig.header) {
+                    headersConfig.header.forEach((h) => {
+                        headers[h.name] = h.value;
+                    });
+                }
+                // Make request with X402 payment handling
+                const response = await makeX402Request(this, {
+                    url,
+                    method,
+                    headers,
+                    body: method === 'POST' || method === 'PUT' ? JSON.parse(body) : undefined,
+                    agnicWalletApi: apiBaseUrl,
+                    authHeader,
+                    isOAuth: authentication === 'oAuth2',
+                });
+                returnData.push({
+                    json: response,
+                    pairedItem: {
+                        item: itemIndex,
+                    },
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                        },
+                        pairedItem: {
+                            item: itemIndex,
+                        },
+                    });
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), errorMessage, {
+                    itemIndex,
+                });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.X402HttpRequest = X402HttpRequest;
+// Helper function: Make X402 request with automatic payment
+async function makeX402Request(context, config) {
+    const { url, method, headers, body, agnicWalletApi, authHeader, isOAuth } = config;
+    try {
+        // 1. Try the request first (may return 402)
+        context.logger.info(`Making initial request to: ${url}`);
+        let response = await fetch(url, {
+            method,
+            headers,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        context.logger.info(`Response status: ${response.status}`);
+        // 2. If 402 Payment Required, use AgnicWallet to sign
+        if (response.status === 402) {
+            context.logger.info('402 Payment Required detected, parsing payment requirements...');
+            // Get response text first for debugging
+            const responseText = await response.text();
+            context.logger.info(`Payment requirements response: ${responseText}`);
+            let paymentRequirements;
+            try {
+                paymentRequirements = JSON.parse(responseText);
+            }
+            catch (parseError) {
+                throw new Error(`Failed to parse payment requirements: ${parseError instanceof Error ? parseError.message : 'Unknown error'}. Response: ${responseText}`);
+            }
+            context.logger.info(`Payment required: ${JSON.stringify(paymentRequirements)}`);
+            // 3. Call AgnicWallet signing API
+            context.logger.info(`Calling AgnicWallet API at: ${agnicWalletApi}/api/sign-payment`);
+            // Build auth headers based on auth type
+            const authHeaders = {
+                'Content-Type': 'application/json',
+            };
+            if (isOAuth) {
+                // OAuth: Use Authorization header with Bearer token
+                authHeaders['Authorization'] = authHeader;
+            }
+            else {
+                // API Key: Use X-Agnic-Token header
+                authHeaders['X-Agnic-Token'] = authHeader;
+            }
+            const signingResponse = await fetch(`${agnicWalletApi}/api/sign-payment`, {
+                method: 'POST',
+                headers: authHeaders,
+                body: JSON.stringify({
+                    paymentRequirements,
+                    requestData: { url, method, body },
+                }),
+            });
+            if (!signingResponse.ok) {
+                const errorText = await signingResponse.text();
+                context.logger.error(`AgnicWallet signing failed: ${errorText}`);
+                throw new Error(`Payment signing failed (${signingResponse.status}): ${errorText}`);
+            }
+            const signingResult = await signingResponse.json();
+            const { paymentHeader, amountPaid } = signingResult;
+            context.logger.info(`Payment signed successfully: $${amountPaid}`);
+            context.logger.info(`Payment header (Base64): ${paymentHeader}`);
+            // 4. Retry original request with payment header
+            // The paymentHeader is already Base64-encoded and X402-compliant
+            context.logger.info('Retrying request with X402 payment header...');
+            response = await fetch(url, {
+                method,
+                headers: {
+                    ...headers,
+                    'X-PAYMENT': paymentHeader,
+                },
+                body: body ? JSON.stringify(body) : undefined,
+            });
+            context.logger.info(`Retry response status: ${response.status}`);
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Request failed after payment (${response.status}): ${errorText}`);
+            }
+            const resultText = await response.text();
+            let result;
+            try {
+                result = JSON.parse(resultText);
+            }
+            catch (parseError) {
+                context.logger.warn(`Response is not JSON: ${resultText}`);
+                result = { data: resultText };
+            }
+            return {
+                ...(typeof result === 'object' && result !== null ? result : {}),
+                _agnicWallet: {
+                    paymentMade: true,
+                    amountPaid,
+                    timestamp: new Date().toISOString(),
+                },
+            };
+        }
+        // 5. If no payment required, just return the result
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Request failed (${response.status} ${response.statusText}): ${errorText}`);
+        }
+        const resultText = await response.text();
+        try {
+            return JSON.parse(resultText);
+        }
+        catch (parseError) {
+            context.logger.warn(`Response is not JSON: ${resultText}`);
+            return { data: resultText };
+        }
+    }
+    catch (error) {
+        context.logger.error(`Error in makeX402Request: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        throw error;
+    }
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "n8n-nodes-agnicwallet",
+  "version": "1.0.0",
+  "description": "n8n community node for AgnicWallet - automated Web3 payments for X402 APIs",
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "agnicwallet",
+    "x402",
+    "web3",
+    "crypto",
+    "payments"
+  ],
+  "license": "MIT",
+  "homepage": "https://agnicwallet.com",
+  "author": {
+    "name": "AgnicWallet",
+    "email": "support@agnicwallet.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agnicpay/agnicwallet-project.git"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && gulp build:icons",
+    "dev": "tsc --watch",
+    "format": "prettier nodes credentials --write",
+    "lint": "tslint -p tsconfig.json -c tslint.json",
+    "lintfix": "tslint --fix -p tsconfig.json -c tslint.json",
+    "prepublishOnly": "npm run build && npm run lint -c .eslintrc.prepublish.js nodes credentials package.json",
+    "test": "jest"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/AgnicWalletApi.credentials.js",
+      "dist/credentials/AgnicWalletOAuth2Api.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/X402HttpRequest/X402HttpRequest.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@typescript-eslint/parser": "^6.13.0",
+    "eslint": "^8.54.0",
+    "eslint-plugin-n8n-nodes-base": "^1.16.1",
+    "gulp": "^4.0.2",
+    "n8n-workflow": "^1.40.0",
+    "prettier": "^3.1.0",
+    "tslint": "^5.20.1",
+    "typescript": "^5.3.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}