n8n-nodes-dominusnode 1.0.0

package/dist/nodes/DominusNodeWallet/DominusNodeWallet.node.js

@@ -0,0 +1,656 @@
+"use strict";
+/**
+ * DomiNode Wallet n8n community node.
+ *
+ * Operations:
+ * - Check Balance: Get current wallet balance
+ * - Top Up (Stripe): Create a Stripe checkout session
+ * - Top Up (Crypto): Create a crypto payment invoice
+ * - Top Up (PayPal): Create a PayPal checkout session via Stripe
+ * - Create Agentic Wallet: Create a sub-wallet with spending limits
+ * - Fund Agentic Wallet: Transfer funds to an agentic wallet
+ * - Get Agentic Wallet Balance: Check an agentic wallet's balance
+ * - List Agentic Wallets: List all agentic wallets
+ * - Get Agentic Transactions: Get transaction history for an agentic wallet
+ * - Freeze Agentic Wallet: Freeze an agentic wallet
+ * - Unfreeze Agentic Wallet: Unfreeze an agentic wallet
+ * - Delete Agentic Wallet: Delete an agentic wallet
+ * - Update Wallet Policy: Update agentic wallet spending policy
+ * - Create Team: Create a new team
+ * - List Teams: List all teams
+ * - Team Details: Get team details
+ * - Fund Team: Fund a team wallet
+ * - Create Team Key: Create an API key for a team
+ * - Team Usage: Get team wallet transaction history
+ * - Update Team: Update team name/max members
+ * - Update Team Member Role: Update a team member's role
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DominusNodeWallet = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const auth_1 = require("../../shared/auth");
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const CONTROL_CHAR_RE = /[\x00-\x1f\x7f]/;
+const DOMAIN_RE = /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
+const VALID_CRYPTO_CURRENCIES = new Set([
+    "btc", "eth", "ltc", "xmr", "zec", "usdc", "sol", "usdt", "dai", "bnb",
+]);
+class DominusNodeWallet {
+    description = {
+        displayName: "DomiNode Wallet",
+        name: "dominusNodeWallet",
+        icon: "file:dominusnode.svg",
+        group: ["transform"],
+        version: 1,
+        subtitle: '={{$parameter["operation"]}}',
+        description: "Manage DomiNode wallet, agentic wallets, and teams",
+        defaults: { name: "DomiNode Wallet" },
+        inputs: ["main"],
+        outputs: ["main"],
+        credentials: [{ name: "dominusNodeApi", required: true }],
+        properties: [
+            {
+                displayName: "Operation",
+                name: "operation",
+                type: "options",
+                noDataExpression: true,
+                options: [
+                    // Wallet
+                    { name: "Check Balance", value: "checkBalance", description: "Get current wallet balance", action: "Check balance" },
+                    { name: "Top Up (Stripe)", value: "topUpStripe", description: "Create a Stripe checkout session", action: "Top up stripe" },
+                    { name: "Top Up (Crypto)", value: "topUpCrypto", description: "Create a crypto payment invoice", action: "Top up crypto" },
+                    { name: "Top Up (PayPal)", value: "topUpPaypal", description: "Create a PayPal checkout session", action: "Top up paypal" },
+                    // Agentic Wallets
+                    { name: "Create Agentic Wallet", value: "createAgenticWallet", description: "Create a sub-wallet with spending limits", action: "Create agentic wallet" },
+                    { name: "Fund Agentic Wallet", value: "fundAgenticWallet", description: "Transfer funds to an agentic wallet", action: "Fund agentic wallet" },
+                    { name: "Get Agentic Wallet Balance", value: "getAgenticBalance", description: "Get agentic wallet balance", action: "Get agentic wallet balance" },
+                    { name: "List Agentic Wallets", value: "listAgenticWallets", description: "List all agentic wallets", action: "List agentic wallets" },
+                    { name: "Get Agentic Transactions", value: "getAgenticTransactions", description: "Get agentic wallet transactions", action: "Get agentic transactions" },
+                    { name: "Freeze Agentic Wallet", value: "freezeAgenticWallet", description: "Freeze an agentic wallet", action: "Freeze agentic wallet" },
+                    { name: "Unfreeze Agentic Wallet", value: "unfreezeAgenticWallet", description: "Unfreeze an agentic wallet", action: "Unfreeze agentic wallet" },
+                    { name: "Delete Agentic Wallet", value: "deleteAgenticWallet", description: "Delete an agentic wallet", action: "Delete agentic wallet" },
+                    { name: "Update Wallet Policy", value: "updateWalletPolicy", description: "Update agentic wallet spending policy", action: "Update wallet policy" },
+                    // Teams
+                    { name: "Create Team", value: "createTeam", description: "Create a new team", action: "Create team" },
+                    { name: "List Teams", value: "listTeams", description: "List all teams", action: "List teams" },
+                    { name: "Team Details", value: "teamDetails", description: "Get team details", action: "Team details" },
+                    { name: "Fund Team", value: "fundTeam", description: "Fund a team wallet", action: "Fund team" },
+                    { name: "Create Team Key", value: "createTeamKey", description: "Create an API key for a team", action: "Create team key" },
+                    { name: "Team Usage", value: "teamUsage", description: "Get team wallet transactions", action: "Team usage" },
+                    { name: "Update Team", value: "updateTeam", description: "Update team settings", action: "Update team" },
+                    { name: "Update Team Member Role", value: "updateTeamMemberRole", description: "Update a team member role", action: "Update team member role" },
+                    // x402
+                    { name: "x402 Info", value: "x402Info", description: "Get x402 micropayment protocol information", action: "Get x402 info" },
+                ],
+                default: "checkBalance",
+            },
+            // --- Stripe top-up ---
+            {
+                displayName: "Amount (Cents)",
+                name: "amountCents",
+                type: "number",
+                default: 500,
+                required: true,
+                description: "Amount in cents (e.g., 500 = $5.00). Minimum 500 ($5).",
+                displayOptions: { show: { operation: ["topUpStripe", "topUpPaypal"] } },
+            },
+            // --- Crypto top-up ---
+            {
+                displayName: "Amount (USD)",
+                name: "amountUsd",
+                type: "number",
+                default: 10,
+                required: true,
+                description: "Amount in USD. Minimum $5.",
+                displayOptions: { show: { operation: ["topUpCrypto"] } },
+            },
+            {
+                displayName: "Currency",
+                name: "currency",
+                type: "options",
+                options: [
+                    { name: "Bitcoin (BTC)", value: "btc" },
+                    { name: "Ethereum (ETH)", value: "eth" },
+                    { name: "Litecoin (LTC)", value: "ltc" },
+                    { name: "Monero (XMR)", value: "xmr" },
+                    { name: "Zcash (ZEC)", value: "zec" },
+                    { name: "USDC", value: "usdc" },
+                    { name: "Solana (SOL)", value: "sol" },
+                    { name: "Tether (USDT)", value: "usdt" },
+                    { name: "DAI", value: "dai" },
+                    { name: "BNB", value: "bnb" },
+                ],
+                default: "btc",
+                description: "Cryptocurrency to pay with",
+                displayOptions: { show: { operation: ["topUpCrypto"] } },
+            },
+            // --- Agentic wallet params ---
+            {
+                displayName: "Label",
+                name: "agenticLabel",
+                type: "string",
+                default: "",
+                required: true,
+                description: "Label for the agentic wallet (max 100 chars)",
+                displayOptions: { show: { operation: ["createAgenticWallet"] } },
+            },
+            {
+                displayName: "Spending Limit (Cents)",
+                name: "spendingLimitCents",
+                type: "number",
+                default: 1000,
+                required: true,
+                description: "Per-transaction spending limit in cents",
+                displayOptions: { show: { operation: ["createAgenticWallet"] } },
+            },
+            {
+                displayName: "Daily Limit (Cents)",
+                name: "dailyLimitCents",
+                type: "number",
+                default: 0,
+                description: "Optional daily budget cap in cents (0 = no limit, max 1,000,000)",
+                displayOptions: { show: { operation: ["createAgenticWallet"] } },
+            },
+            {
+                displayName: "Allowed Domains",
+                name: "allowedDomains",
+                type: "string",
+                default: "",
+                description: "Comma-separated domain allowlist (e.g., \"example.com,api.example.org\"). Leave empty for no restriction.",
+                displayOptions: { show: { operation: ["createAgenticWallet"] } },
+            },
+            {
+                displayName: "Wallet ID",
+                name: "policyWalletId",
+                type: "string",
+                default: "",
+                required: true,
+                description: "Agentic wallet UUID to update policy for",
+                displayOptions: { show: { operation: ["updateWalletPolicy"] } },
+            },
+            {
+                displayName: "Daily Limit (Cents)",
+                name: "policyDailyLimitCents",
+                type: "number",
+                default: 0,
+                description: "Daily budget cap in cents (0 = no limit, max 1,000,000). Set to -1 to remove.",
+                displayOptions: { show: { operation: ["updateWalletPolicy"] } },
+            },
+            {
+                displayName: "Allowed Domains",
+                name: "policyAllowedDomains",
+                type: "string",
+                default: "",
+                description: "Comma-separated domain allowlist. Leave empty to skip, set to \"*\" to remove restriction.",
+                displayOptions: { show: { operation: ["updateWalletPolicy"] } },
+            },
+            {
+                displayName: "Wallet ID",
+                name: "walletId",
+                type: "string",
+                default: "",
+                required: true,
+                description: "Agentic wallet UUID",
+                displayOptions: {
+                    show: {
+                        operation: [
+                            "fundAgenticWallet",
+                            "getAgenticBalance",
+                            "getAgenticTransactions",
+                            "freezeAgenticWallet",
+                            "unfreezeAgenticWallet",
+                            "deleteAgenticWallet",
+                        ],
+                    },
+                },
+            },
+            {
+                displayName: "Amount (Cents)",
+                name: "fundAmountCents",
+                type: "number",
+                default: 100,
+                required: true,
+                description: "Amount in cents to transfer to the agentic wallet",
+                displayOptions: { show: { operation: ["fundAgenticWallet"] } },
+            },
+            {
+                displayName: "Limit",
+                name: "transactionLimit",
+                type: "number",
+                default: 20,
+                description: "Number of transactions to return (1-100)",
+                displayOptions: { show: { operation: ["getAgenticTransactions", "teamUsage"] } },
+            },
+            // --- Team params ---
+            {
+                displayName: "Team Name",
+                name: "teamName",
+                type: "string",
+                default: "",
+                required: true,
+                description: "Name for the team (max 100 chars)",
+                displayOptions: { show: { operation: ["createTeam"] } },
+            },
+            {
+                displayName: "Max Members",
+                name: "maxMembers",
+                type: "number",
+                default: 10,
+                description: "Maximum team members (1-100)",
+                displayOptions: { show: { operation: ["createTeam"] } },
+            },
+            {
+                displayName: "Team ID",
+                name: "teamId",
+                type: "string",
+                default: "",
+                required: true,
+                description: "Team UUID",
+                displayOptions: {
+                    show: {
+                        operation: [
+                            "teamDetails",
+                            "fundTeam",
+                            "createTeamKey",
+                            "teamUsage",
+                            "updateTeam",
+                            "updateTeamMemberRole",
+                        ],
+                    },
+                },
+            },
+            {
+                displayName: "Amount (Cents)",
+                name: "teamFundAmountCents",
+                type: "number",
+                default: 500,
+                required: true,
+                description: "Amount in cents to fund the team wallet. Min 100 ($1), max 1,000,000 ($10,000).",
+                displayOptions: { show: { operation: ["fundTeam"] } },
+            },
+            {
+                displayName: "Key Label",
+                name: "keyLabel",
+                type: "string",
+                default: "",
+                required: true,
+                description: "Label for the team API key (max 100 chars)",
+                displayOptions: { show: { operation: ["createTeamKey"] } },
+            },
+            {
+                displayName: "New Team Name",
+                name: "updateTeamName",
+                type: "string",
+                default: "",
+                description: "New name for the team",
+                displayOptions: { show: { operation: ["updateTeam"] } },
+            },
+            {
+                displayName: "New Max Members",
+                name: "updateMaxMembers",
+                type: "number",
+                default: 0,
+                description: "New max members (1-100). Set to 0 to skip.",
+                displayOptions: { show: { operation: ["updateTeam"] } },
+            },
+            {
+                displayName: "User ID",
+                name: "userId",
+                type: "string",
+                default: "",
+                required: true,
+                description: "User UUID whose role to update",
+                displayOptions: { show: { operation: ["updateTeamMemberRole"] } },
+            },
+            {
+                displayName: "Role",
+                name: "role",
+                type: "options",
+                options: [
+                    { name: "Admin", value: "admin" },
+                    { name: "Member", value: "member" },
+                ],
+                default: "member",
+                description: "New role for the team member",
+                displayOptions: { show: { operation: ["updateTeamMemberRole"] } },
+            },
+        ],
+    };
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials("dominusNodeApi");
+        const apiKey = credentials.apiKey;
+        const baseUrl = credentials.baseUrl || "https://api.dominusnode.com";
+        if (!apiKey) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "API Key is required");
+        }
+        const auth = new auth_1.DominusNodeAuth(apiKey, baseUrl);
+        const operation = this.getNodeParameter("operation", 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                let result;
+                switch (operation) {
+                    // ----- Wallet -----
+                    case "checkBalance": {
+                        result = await auth.apiRequest("GET", "/api/wallet");
+                        break;
+                    }
+                    case "topUpStripe": {
+                        const amountCents = this.getNodeParameter("amountCents", i);
+                        if (!Number.isInteger(amountCents) || amountCents < 500 || amountCents > 1_000_000) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "amountCents must be an integer between 500 ($5) and 1,000,000 ($10,000)", { itemIndex: i });
+                        }
+                        result = await auth.apiRequest("POST", "/api/wallet/topup/stripe", { amountCents });
+                        break;
+                    }
+                    case "topUpCrypto": {
+                        const amountUsd = this.getNodeParameter("amountUsd", i);
+                        const currency = this.getNodeParameter("currency", i);
+                        if (typeof amountUsd !== "number" || amountUsd < 5 || amountUsd > 10_000) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "amountUsd must be between $5 and $10,000", { itemIndex: i });
+                        }
+                        if (!VALID_CRYPTO_CURRENCIES.has(currency)) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid currency. Valid options: ${[...VALID_CRYPTO_CURRENCIES].join(", ")}`, { itemIndex: i });
+                        }
+                        result = await auth.apiRequest("POST", "/api/wallet/topup/crypto", {
+                            amountUsd,
+                            currency,
+                        });
+                        break;
+                    }
+                    case "topUpPaypal": {
+                        const amountCents = this.getNodeParameter("amountCents", i);
+                        if (!Number.isInteger(amountCents) || amountCents < 500 || amountCents > 1_000_000) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "amountCents must be an integer between 500 ($5) and 1,000,000 ($10,000)", { itemIndex: i });
+                        }
+                        result = await auth.apiRequest("POST", "/api/wallet/topup/stripe", {
+                            amountCents,
+                            paymentMethod: "paypal",
+                        });
+                        break;
+                    }
+                    // ----- Agentic Wallets -----
+                    case "createAgenticWallet": {
+                        const label = this.getNodeParameter("agenticLabel", i);
+                        const spendingLimitCents = this.getNodeParameter("spendingLimitCents", i);
+                        const dailyLimitCents = this.getNodeParameter("dailyLimitCents", i, 0);
+                        const allowedDomainsRaw = this.getNodeParameter("allowedDomains", i, "");
+                        if (!label || typeof label !== "string") {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Label is required", { itemIndex: i });
+                        }
+                        if (label.length > 100) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Label must be 100 characters or fewer", { itemIndex: i });
+                        }
+                        if (CONTROL_CHAR_RE.test(label)) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Label contains invalid control characters", { itemIndex: i });
+                        }
+                        if (!Number.isInteger(spendingLimitCents) ||
+                            spendingLimitCents <= 0 ||
+                            spendingLimitCents > 2_147_483_647) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Spending limit must be a positive integer", { itemIndex: i });
+                        }
+                        const body = { label, spendingLimitCents };
+                        if (dailyLimitCents > 0) {
+                            if (!Number.isInteger(dailyLimitCents) || dailyLimitCents > 1_000_000) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), "dailyLimitCents must be an integer between 1 and 1,000,000", { itemIndex: i });
+                            }
+                            body.dailyLimitCents = dailyLimitCents;
+                        }
+                        if (allowedDomainsRaw && allowedDomainsRaw.trim().length > 0) {
+                            const domains = allowedDomainsRaw.split(",").map((d) => d.trim()).filter(Boolean);
+                            if (domains.length > 100) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), "allowedDomains may contain at most 100 entries", { itemIndex: i });
+                            }
+                            for (const d of domains) {
+                                if (d.length > 253 || !DOMAIN_RE.test(d)) {
+                                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid domain: "${d}". Must be a valid domain name (max 253 chars).`, { itemIndex: i });
+                                }
+                            }
+                            body.allowedDomains = domains;
+                        }
+                        result = await auth.apiRequest("POST", "/api/agent-wallet", body);
+                        break;
+                    }
+                    case "fundAgenticWallet": {
+                        const walletId = this.getNodeParameter("walletId", i);
+                        const amountCents = this.getNodeParameter("fundAmountCents", i);
+                        validateUuid(this, walletId, "walletId", i);
+                        if (!Number.isInteger(amountCents) ||
+                            amountCents <= 0 ||
+                            amountCents > 2_147_483_647) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Amount must be a positive integer", { itemIndex: i });
+                        }
+                        result = await auth.apiRequest("POST", `/api/agent-wallet/${encodeURIComponent(walletId)}/fund`, { amountCents });
+                        break;
+                    }
+                    case "getAgenticBalance": {
+                        const walletId = this.getNodeParameter("walletId", i);
+                        validateUuid(this, walletId, "walletId", i);
+                        result = await auth.apiRequest("GET", `/api/agent-wallet/${encodeURIComponent(walletId)}`);
+                        break;
+                    }
+                    case "listAgenticWallets": {
+                        result = await auth.apiRequest("GET", "/api/agent-wallet");
+                        break;
+                    }
+                    case "getAgenticTransactions": {
+                        const walletId = this.getNodeParameter("walletId", i);
+                        const limit = this.getNodeParameter("transactionLimit", i, 20);
+                        validateUuid(this, walletId, "walletId", i);
+                        validateLimit(this, limit, i);
+                        const params = new URLSearchParams();
+                        params.set("limit", String(limit));
+                        result = await auth.apiRequest("GET", `/api/agent-wallet/${encodeURIComponent(walletId)}/transactions?${params.toString()}`);
+                        break;
+                    }
+                    case "freezeAgenticWallet": {
+                        const walletId = this.getNodeParameter("walletId", i);
+                        validateUuid(this, walletId, "walletId", i);
+                        result = await auth.apiRequest("POST", `/api/agent-wallet/${encodeURIComponent(walletId)}/freeze`);
+                        break;
+                    }
+                    case "unfreezeAgenticWallet": {
+                        const walletId = this.getNodeParameter("walletId", i);
+                        validateUuid(this, walletId, "walletId", i);
+                        result = await auth.apiRequest("POST", `/api/agent-wallet/${encodeURIComponent(walletId)}/unfreeze`);
+                        break;
+                    }
+                    case "deleteAgenticWallet": {
+                        const walletId = this.getNodeParameter("walletId", i);
+                        validateUuid(this, walletId, "walletId", i);
+                        result = await auth.apiRequest("DELETE", `/api/agent-wallet/${encodeURIComponent(walletId)}`);
+                        break;
+                    }
+                    case "updateWalletPolicy": {
+                        const walletId = this.getNodeParameter("policyWalletId", i);
+                        const dailyLimitCents = this.getNodeParameter("policyDailyLimitCents", i, 0);
+                        const allowedDomainsRaw = this.getNodeParameter("policyAllowedDomains", i, "");
+                        validateUuid(this, walletId, "policyWalletId", i);
+                        const body = {};
+                        if (dailyLimitCents === -1) {
+                            body.dailyLimitCents = null;
+                        }
+                        else if (dailyLimitCents > 0) {
+                            if (!Number.isInteger(dailyLimitCents) || dailyLimitCents > 1_000_000) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), "dailyLimitCents must be an integer between 1 and 1,000,000 (or -1 to remove)", { itemIndex: i });
+                            }
+                            body.dailyLimitCents = dailyLimitCents;
+                        }
+                        if (allowedDomainsRaw === "*") {
+                            body.allowedDomains = null;
+                        }
+                        else if (allowedDomainsRaw && allowedDomainsRaw.trim().length > 0) {
+                            const domains = allowedDomainsRaw.split(",").map((d) => d.trim()).filter(Boolean);
+                            if (domains.length > 100) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), "allowedDomains may contain at most 100 entries", { itemIndex: i });
+                            }
+                            for (const d of domains) {
+                                if (d.length > 253 || !DOMAIN_RE.test(d)) {
+                                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid domain: "${d}". Must be a valid domain name (max 253 chars).`, { itemIndex: i });
+                                }
+                            }
+                            body.allowedDomains = domains;
+                        }
+                        if (Object.keys(body).length === 0) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "At least one of dailyLimitCents or allowedDomains must be provided", { itemIndex: i });
+                        }
+                        result = await auth.apiRequest("PATCH", `/api/agent-wallet/${encodeURIComponent(walletId)}/policy`, body);
+                        break;
+                    }
+                    // ----- Teams -----
+                    case "createTeam": {
+                        const name = this.getNodeParameter("teamName", i);
+                        const maxMembers = this.getNodeParameter("maxMembers", i, 10);
+                        if (!name || typeof name !== "string") {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Team name is required", { itemIndex: i });
+                        }
+                        if (name.length > 100) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Team name must be 100 characters or fewer", { itemIndex: i });
+                        }
+                        if (CONTROL_CHAR_RE.test(name)) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Team name contains invalid control characters", { itemIndex: i });
+                        }
+                        const body = { name };
+                        if (maxMembers) {
+                            if (!Number.isInteger(maxMembers) || maxMembers < 1 || maxMembers > 100) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), "maxMembers must be an integer between 1 and 100", { itemIndex: i });
+                            }
+                            body.maxMembers = maxMembers;
+                        }
+                        result = await auth.apiRequest("POST", "/api/teams", body);
+                        break;
+                    }
+                    case "listTeams": {
+                        result = await auth.apiRequest("GET", "/api/teams");
+                        break;
+                    }
+                    case "teamDetails": {
+                        const teamId = this.getNodeParameter("teamId", i);
+                        validateUuid(this, teamId, "teamId", i);
+                        result = await auth.apiRequest("GET", `/api/teams/${encodeURIComponent(teamId)}`);
+                        break;
+                    }
+                    case "fundTeam": {
+                        const teamId = this.getNodeParameter("teamId", i);
+                        const amountCents = this.getNodeParameter("teamFundAmountCents", i);
+                        validateUuid(this, teamId, "teamId", i);
+                        if (!Number.isInteger(amountCents) ||
+                            amountCents < 100 ||
+                            amountCents > 1_000_000) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "amountCents must be between 100 ($1) and 1,000,000 ($10,000)", { itemIndex: i });
+                        }
+                        result = await auth.apiRequest("POST", `/api/teams/${encodeURIComponent(teamId)}/wallet/fund`, { amountCents });
+                        break;
+                    }
+                    case "createTeamKey": {
+                        const teamId = this.getNodeParameter("teamId", i);
+                        const label = this.getNodeParameter("keyLabel", i);
+                        validateUuid(this, teamId, "teamId", i);
+                        if (!label || typeof label !== "string") {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Key label is required", { itemIndex: i });
+                        }
+                        if (label.length > 100) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Key label must be 100 characters or fewer", { itemIndex: i });
+                        }
+                        if (CONTROL_CHAR_RE.test(label)) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Key label contains invalid control characters", { itemIndex: i });
+                        }
+                        result = await auth.apiRequest("POST", `/api/teams/${encodeURIComponent(teamId)}/keys`, { label });
+                        break;
+                    }
+                    case "teamUsage": {
+                        const teamId = this.getNodeParameter("teamId", i);
+                        const limit = this.getNodeParameter("transactionLimit", i, 20);
+                        validateUuid(this, teamId, "teamId", i);
+                        validateLimit(this, limit, i);
+                        const params = new URLSearchParams();
+                        params.set("limit", String(limit));
+                        result = await auth.apiRequest("GET", `/api/teams/${encodeURIComponent(teamId)}/wallet/transactions?${params.toString()}`);
+                        break;
+                    }
+                    case "updateTeam": {
+                        const teamId = this.getNodeParameter("teamId", i);
+                        validateUuid(this, teamId, "teamId", i);
+                        const body = {};
+                        const newName = this.getNodeParameter("updateTeamName", i, "");
+                        const newMax = this.getNodeParameter("updateMaxMembers", i, 0);
+                        if (newName) {
+                            if (newName.length > 100) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Team name must be 100 characters or fewer", { itemIndex: i });
+                            }
+                            if (CONTROL_CHAR_RE.test(newName)) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Team name contains invalid control characters", { itemIndex: i });
+                            }
+                            body.name = newName;
+                        }
+                        if (newMax > 0) {
+                            if (!Number.isInteger(newMax) || newMax < 1 || newMax > 100) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), "maxMembers must be an integer between 1 and 100", { itemIndex: i });
+                            }
+                            body.maxMembers = newMax;
+                        }
+                        if (Object.keys(body).length === 0) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "At least one of name or maxMembers must be provided", { itemIndex: i });
+                        }
+                        result = await auth.apiRequest("PATCH", `/api/teams/${encodeURIComponent(teamId)}`, body);
+                        break;
+                    }
+                    case "updateTeamMemberRole": {
+                        const teamId = this.getNodeParameter("teamId", i);
+                        const userId = this.getNodeParameter("userId", i);
+                        const role = this.getNodeParameter("role", i);
+                        validateUuid(this, teamId, "teamId", i);
+                        validateUuid(this, userId, "userId", i);
+                        if (role !== "member" && role !== "admin") {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Role must be 'member' or 'admin'", { itemIndex: i });
+                        }
+                        result = await auth.apiRequest("PATCH", `/api/teams/${encodeURIComponent(teamId)}/members/${encodeURIComponent(userId)}`, { role });
+                        break;
+                    }
+                    case "x402Info": {
+                        result = await auth.apiRequest("GET", "/api/x402/info");
+                        break;
+                    }
+                    default:
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`, { itemIndex: i });
+                }
+                returnData.push({ json: (result ?? {}) });
+            }
+            catch (err) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: (0, auth_1.sanitizeError)(err instanceof Error ? err.message : String(err)),
+                        },
+                    });
+                    continue;
+                }
+                if (err instanceof n8n_workflow_1.NodeOperationError)
+                    throw err;
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), (0, auth_1.sanitizeError)(err instanceof Error ? err.message : String(err)), { itemIndex: i });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.DominusNodeWallet = DominusNodeWallet;
+// ---------------------------------------------------------------------------
+// Validation helpers
+// ---------------------------------------------------------------------------
+function validateUuid(ctx, value, fieldName, itemIndex) {
+    if (!value || typeof value !== "string") {
+        throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), `${fieldName} is required`, { itemIndex });
+    }
+    if (!UUID_RE.test(value)) {
+        throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), `${fieldName} must be a valid UUID`, { itemIndex });
+    }
+}
+function validateLimit(ctx, limit, itemIndex) {
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
+        throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), "Limit must be an integer between 1 and 100", { itemIndex });
+    }
+}
+//# sourceMappingURL=DominusNodeWallet.node.js.map