@elizaos/agent 2.0.0-alpha.144 → 2.0.0-alpha.151

package/packages/agent/src/actions/timezone-normalization.d.ts

@@ -1,3 +1,2 @@
-export declare function normalizeExplicitTimeZoneToken(value: string | null | undefined): string | null;
-export declare function extractExplicitTimeZoneFromText(value: string | null | undefined): string | null;
+export * from "@elizaos/app-lifeops/actions/timezone-normalization";
 //# sourceMappingURL=timezone-normalization.d.ts.map

package/packages/agent/src/actions/timezone-normalization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timezone-normalization.d.ts","sourceRoot":"","sources":["../../../../../src/actions/timezone-normalization.ts"],"names":[],"mappings":"AAgEA,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/B,MAAM,GAAG,IAAI,CAgBf;AAED,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/B,MAAM,GAAG,IAAI,CAkCf"}
+{"version":3,"file":"timezone-normalization.d.ts","sourceRoot":"","sources":["../../../../../src/actions/timezone-normalization.ts"],"names":[],"mappings":"AAAA,cAAc,qDAAqD,CAAC"}

package/packages/agent/src/actions/timezone-normalization.js

@@ -1,107 +1 @@
-import { isValidTimeZone } from "../lifeops/defaults.js";
-const TIME_ZONE_ALIASES = {
-    pst: "America/Los_Angeles",
-    pdt: "America/Los_Angeles",
-    pt: "America/Los_Angeles",
-    pacific: "America/Los_Angeles",
-    "pacific time": "America/Los_Angeles",
-    "pacific timezone": "America/Los_Angeles",
-    "pacific daylight": "America/Los_Angeles",
-    "pacific daylight time": "America/Los_Angeles",
-    "pacific standard": "America/Los_Angeles",
-    "pacific standard time": "America/Los_Angeles",
-    "los angeles": "America/Los_Angeles",
-    mst: "America/Denver",
-    mdt: "America/Denver",
-    mt: "America/Denver",
-    mountain: "America/Denver",
-    "mountain time": "America/Denver",
-    "mountain timezone": "America/Denver",
-    "mountain daylight": "America/Denver",
-    "mountain daylight time": "America/Denver",
-    "mountain standard": "America/Denver",
-    "mountain standard time": "America/Denver",
-    denver: "America/Denver",
-    cst: "America/Chicago",
-    cdt: "America/Chicago",
-    ct: "America/Chicago",
-    central: "America/Chicago",
-    "central time": "America/Chicago",
-    "central timezone": "America/Chicago",
-    "central daylight": "America/Chicago",
-    "central daylight time": "America/Chicago",
-    "central standard": "America/Chicago",
-    "central standard time": "America/Chicago",
-    chicago: "America/Chicago",
-    est: "America/New_York",
-    edt: "America/New_York",
-    et: "America/New_York",
-    eastern: "America/New_York",
-    "eastern time": "America/New_York",
-    "eastern timezone": "America/New_York",
-    "eastern daylight": "America/New_York",
-    "eastern daylight time": "America/New_York",
-    "eastern standard": "America/New_York",
-    "eastern standard time": "America/New_York",
-    "new york": "America/New_York",
-    utc: "UTC",
-    gmt: "UTC",
-};
-const IANA_TIME_ZONE_PATTERN = /\b([A-Za-z]+(?:\/[A-Za-z0-9_+-]+)+)\b/g;
-function canonicalizeTimeZoneAliasKey(value) {
-    return value
-        .trim()
-        .toLowerCase()
-        .replace(/[._-]+/g, " ")
-        .replace(/\s+/g, " ")
-        .replace(/\b(?:timezone|time)\b/g, " ")
-        .replace(/\s+/g, " ")
-        .trim();
-}
-export function normalizeExplicitTimeZoneToken(value) {
-    if (typeof value !== "string") {
-        return null;
-    }
-    const trimmed = value.trim();
-    if (!trimmed) {
-        return null;
-    }
-    const alias = TIME_ZONE_ALIASES[canonicalizeTimeZoneAliasKey(trimmed)];
-    if (alias && isValidTimeZone(alias)) {
-        return alias;
-    }
-    if (isValidTimeZone(trimmed)) {
-        return trimmed;
-    }
-    return null;
-}
-export function extractExplicitTimeZoneFromText(value) {
-    if (typeof value !== "string" || value.trim().length === 0) {
-        return null;
-    }
-    let match;
-    const ianaPattern = new RegExp(IANA_TIME_ZONE_PATTERN);
-    ianaPattern.lastIndex = 0;
-    match = ianaPattern.exec(value);
-    while (match !== null) {
-        const normalized = normalizeExplicitTimeZoneToken(match[1] ?? match[0]);
-        if (normalized) {
-            return normalized;
-        }
-        match = ianaPattern.exec(value);
-    }
-    const lower = ` ${canonicalizeTimeZoneAliasKey(value)} `;
-    for (const alias of Object.keys(TIME_ZONE_ALIASES).sort((left, right) => right.length - left.length)) {
-        const escapedAlias = alias
-            .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-            .replace(/\\ /g, "\\s+");
-        const aliasPattern = new RegExp(`(^|\\s)${escapedAlias}(?=\\s|$)`, "i");
-        if (aliasPattern.test(lower)) {
-            const normalized = normalizeExplicitTimeZoneToken(alias);
-            if (normalized) {
-                return normalized;
-            }
-        }
-    }
-    return null;
-}
+export * from "@elizaos/app-lifeops/actions/timezone-normalization";

package/packages/agent/src/actions/transfer-token.d.ts

@@ -0,0 +1,17 @@
+/**
+ * TRANSFER_TOKEN action — transfers tokens or native BNB to another address.
+ *
+ * When triggered the action:
+ *   1. Validates parameters (toAddress 0x format, amount > 0, assetSymbol non-empty)
+ *   2. POSTs to the local transfer execution API with agent automation header
+ *   3. Returns structured result: execution status, txHash, explorer URL,
+ *      or unsigned TX info if user-sign mode
+ *
+ * All business logic (permissions, safety caps, signing) is handled
+ * server-side — this action is a thin wrapper.
+ *
+ * @module actions/transfer-token
+ */
+import type { Action } from "@elizaos/core";
+export declare const transferTokenAction: Action;
+//# sourceMappingURL=transfer-token.d.ts.map

package/packages/agent/src/actions/transfer-token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer-token.d.ts","sourceRoot":"","sources":["../../../../../src/actions/transfer-token.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EACV,MAAM,EAIP,MAAM,eAAe,CAAC;AAwHvB,eAAO,MAAM,mBAAmB,EAAE,MA0bjC,CAAC"}

package/packages/agent/src/actions/transfer-token.js

@@ -0,0 +1,470 @@
+/**
+ * TRANSFER_TOKEN action — transfers tokens or native BNB to another address.
+ *
+ * When triggered the action:
+ *   1. Validates parameters (toAddress 0x format, amount > 0, assetSymbol non-empty)
+ *   2. POSTs to the local transfer execution API with agent automation header
+ *   3. Returns structured result: execution status, txHash, explorer URL,
+ *      or unsigned TX info if user-sign mode
+ *
+ * All business logic (permissions, safety caps, signing) is handled
+ * server-side — this action is a thin wrapper.
+ *
+ * @module actions/transfer-token
+ */
+import { buildAuthHeaders, getWalletActionApiPort, } from "./wallet-action-shared.js";
+/** Timeout for the transfer API call (includes on-chain confirmation). */
+const TRANSFER_TIMEOUT_MS = 60_000;
+/** Chain ID used for BSC mainnet / testnet when routing through steward. */
+const BSC_CHAIN_ID = 56;
+const BSC_TESTNET_CHAIN_ID = 97;
+/** Matches a 0x-prefixed 40-hex-char EVM address. */
+const EVM_ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
+const EVM_ADDRESS_CAPTURE_RE = /\b0x[a-fA-F0-9]{40}\b/g;
+const DECIMAL_AMOUNT_CAPTURE_RE = /\b(\d+(?:\.\d+)?)\b/;
+const ASSET_SYMBOL_CAPTURE_RE = /\b(?:t?bnb|bnb|eth|usdt|usdc|busd|dai|weth|wbtc)\b/i;
+function extractMessageText(message) {
+    if (!message ||
+        typeof message !== "object" ||
+        !("content" in message) ||
+        !message.content ||
+        typeof message.content !== "object" ||
+        !("text" in message.content) ||
+        typeof message.content.text !== "string") {
+        return "";
+    }
+    return message.content.text.trim();
+}
+function inferTransferParamsFromMessage(message) {
+    const text = extractMessageText(message);
+    const addressMatches = text.match(EVM_ADDRESS_CAPTURE_RE) ?? [];
+    const toAddress = addressMatches[addressMatches.length - 1];
+    const amount = text.match(DECIMAL_AMOUNT_CAPTURE_RE)?.[1];
+    const assetSymbol = text.match(ASSET_SYMBOL_CAPTURE_RE)?.[0];
+    return {
+        toAddress,
+        amount,
+        assetSymbol: typeof assetSymbol === "string"
+            ? assetSymbol.trim().toUpperCase() === "TBNB"
+                ? "BNB"
+                : assetSymbol.trim().toUpperCase()
+            : undefined,
+    };
+}
+function isStewardConfigured() {
+    const url = process.env.STEWARD_API_URL?.trim();
+    const agentId = process.env.STEWARD_AGENT_ID?.trim() ||
+        process.env.ELIZA_STEWARD_AGENT_ID?.trim() ||
+        process.env.ELIZA_STEWARD_AGENT_ID?.trim();
+    return Boolean(url && agentId);
+}
+function resolveBscChainId() {
+    return process.env.ELIZA_WALLET_NETWORK?.trim().toLowerCase() === "testnet"
+        ? BSC_TESTNET_CHAIN_ID
+        : BSC_CHAIN_ID;
+}
+function walletNetworkLabel() {
+    return process.env.ELIZA_WALLET_NETWORK?.trim().toLowerCase() === "testnet"
+        ? "BSC testnet"
+        : "BSC";
+}
+function buildTransferSuccessText(args) {
+    return [
+        "Action: TRANSFER_TOKEN",
+        `Chain: ${walletNetworkLabel()}`,
+        `Amount: ${args.amount} ${args.assetSymbol}`,
+        `Recipient: ${args.toAddress}`,
+        `Execution mode: ${args.mode}`,
+        "Executed: true",
+        `Tx hash: ${args.txHash}`,
+        `Explorer: ${args.explorerUrl}`,
+        `Status: ${args.status}`,
+    ].join("\n");
+}
+function buildTransferFailureText(args) {
+    return [
+        "Action: TRANSFER_TOKEN",
+        `Chain: ${walletNetworkLabel()}`,
+        `Amount: ${args.amount} ${args.assetSymbol}`,
+        `Recipient: ${args.toAddress}`,
+        `Execution mode: ${args.mode}`,
+        "Executed: false",
+        `Requires user signature: ${args.requiresUserSignature ? "true" : "false"}`,
+        `Reason: ${args.reason}`,
+    ].join("\n");
+}
+export const transferTokenAction = {
+    name: "TRANSFER_TOKEN",
+    similes: ["SEND_TOKEN", "TRANSFER", "SEND", "SEND_BNB", "SEND_CRYPTO", "PAY"],
+    description: "Transfer tokens or native BNB to another address. Use this when a user " +
+        "asks to send, transfer, or pay tokens to a recipient address on BSC.",
+    validate: async (runtime) => {
+        return Boolean(runtime.getSetting("EVM_PRIVATE_KEY") ||
+            runtime.getSetting("PRIVY_APP_ID") ||
+            runtime.getSetting("STEWARD_API_URL"));
+    },
+    handler: async (_runtime, _message, _state, options, callback) => {
+        try {
+            const params = options?.parameters;
+            const inferredParams = inferTransferParamsFromMessage(_message);
+            // ── Validate toAddress ─────────────────────────────────────────────
+            const toAddress = typeof params?.toAddress === "string"
+                ? EVM_ADDRESS_RE.test(params.toAddress.trim())
+                    ? params.toAddress.trim()
+                    : inferredParams.toAddress
+                : inferredParams.toAddress;
+            if (!toAddress || !EVM_ADDRESS_RE.test(toAddress)) {
+                const text = "I need a valid recipient address (0x-prefixed, 40 hex chars).";
+                if (callback)
+                    callback({ text, action: "TRANSFER_TOKEN_FAILED" });
+                return {
+                    text,
+                    success: false,
+                };
+            }
+            // ── Validate amount ────────────────────────────────────────────────
+            const amountRaw = typeof params?.amount === "string"
+                ? Number(params.amount.trim()) > 0
+                    ? params.amount.trim()
+                    : inferredParams.amount
+                : typeof params?.amount === "number"
+                    ? String(params.amount)
+                    : inferredParams.amount;
+            if (!amountRaw ||
+                Number.isNaN(Number(amountRaw)) ||
+                Number(amountRaw) <= 0) {
+                const text = "I need a positive numeric amount for the transfer.";
+                if (callback)
+                    callback({ text, action: "TRANSFER_TOKEN_FAILED" });
+                return {
+                    text,
+                    success: false,
+                };
+            }
+            // ── Validate assetSymbol ───────────────────────────────────────────
+            const assetSymbol = typeof params?.assetSymbol === "string"
+                ? params.assetSymbol.trim().length > 0
+                    ? params.assetSymbol.trim()
+                    : inferredParams.assetSymbol
+                : inferredParams.assetSymbol;
+            if (!assetSymbol) {
+                const text = "I need an asset symbol (e.g. BNB, USDT, USDC) for the transfer.";
+                if (callback)
+                    callback({ text, action: "TRANSFER_TOKEN_FAILED" });
+                return {
+                    text,
+                    success: false,
+                };
+            }
+            if (!/^[A-Za-z0-9]{1,20}$/.test(assetSymbol)) {
+                const text = "Invalid asset symbol format.";
+                if (callback)
+                    callback({ text, action: "TRANSFER_TOKEN_FAILED" });
+                return { text, success: false };
+            }
+            // ── Optional tokenAddress ──────────────────────────────────────────
+            const tokenAddress = typeof params?.tokenAddress === "string" &&
+                params.tokenAddress.trim() !== ""
+                ? params.tokenAddress.trim()
+                : undefined;
+            if (tokenAddress && !EVM_ADDRESS_RE.test(tokenAddress)) {
+                const text = "Invalid token address format.";
+                if (callback)
+                    callback({ text, action: "TRANSFER_TOKEN_FAILED" });
+                return { text, success: false };
+            }
+            // ── Try Steward vault signing first ─────────────────────────────────
+            if (isStewardConfigured()) {
+                try {
+                    const stewardResult = await fetch(`http://127.0.0.1:${getWalletActionApiPort()}/api/wallet/steward-sign`, {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json",
+                            ...buildAuthHeaders(),
+                        },
+                        body: JSON.stringify({
+                            to: toAddress,
+                            value: amountRaw,
+                            chainId: resolveBscChainId(),
+                            description: `Transfer ${amountRaw} ${assetSymbol} to ${toAddress}`,
+                        }),
+                        signal: AbortSignal.timeout(TRANSFER_TIMEOUT_MS),
+                    });
+                    const stewardBody = (await stewardResult
+                        .json()
+                        .catch(() => ({})));
+                    // Approved — steward signed and broadcast
+                    if (stewardResult.ok && stewardBody.approved === true) {
+                        const txHash = typeof stewardBody.txHash === "string"
+                            ? stewardBody.txHash
+                            : "unknown";
+                        const explorerUrl = resolveBscChainId() === BSC_CHAIN_ID
+                            ? `https://bscscan.com/tx/${txHash}`
+                            : `https://testnet.bscscan.com/tx/${txHash}`;
+                        const text = buildTransferSuccessText({
+                            amount: amountRaw,
+                            assetSymbol,
+                            toAddress,
+                            mode: "steward",
+                            txHash,
+                            explorerUrl,
+                            status: "success",
+                        });
+                        if (callback) {
+                            callback({
+                                text,
+                                action: "TRANSFER_TOKEN_SUCCESS",
+                                txHash,
+                                explorerUrl,
+                                executionMode: "steward",
+                                executed: true,
+                                recipient: toAddress,
+                            });
+                        }
+                        return {
+                            text,
+                            success: true,
+                            data: {
+                                toAddress,
+                                amount: amountRaw,
+                                assetSymbol,
+                                mode: "steward",
+                                txHash,
+                                explorerUrl,
+                                executed: true,
+                            },
+                        };
+                    }
+                    // Pending approval — tx queued for manual review
+                    if (stewardResult.status === 202 && stewardBody.pending === true) {
+                        const txId = typeof stewardBody.txId === "string" ? stewardBody.txId : "";
+                        const text = buildTransferFailureText({
+                            amount: amountRaw,
+                            assetSymbol,
+                            toAddress,
+                            mode: "steward",
+                            requiresUserSignature: false,
+                            reason: `Transaction queued for manual approval${txId ? ` (ID: ${txId})` : ""}. A policy admin must approve before it broadcasts.`,
+                        });
+                        if (callback) {
+                            callback({
+                                text,
+                                action: "TRANSFER_TOKEN_PENDING",
+                                executionMode: "steward",
+                                executed: false,
+                                recipient: toAddress,
+                                txId,
+                            });
+                        }
+                        return {
+                            text,
+                            success: false,
+                            data: {
+                                toAddress,
+                                amount: amountRaw,
+                                assetSymbol,
+                                mode: "steward",
+                                pending: true,
+                                txId,
+                                executed: false,
+                            },
+                        };
+                    }
+                    // Denied — policy violation
+                    if (stewardResult.status === 403) {
+                        const violations = Array.isArray(stewardBody.violations)
+                            ? stewardBody.violations
+                            : [];
+                        const violationText = violations
+                            .map((v) => `• ${v.policy}: ${v.reason}`)
+                            .join("\n");
+                        const reason = violationText
+                            ? `Policy violations:\n${violationText}`
+                            : "Transaction denied by steward policy.";
+                        const text = buildTransferFailureText({
+                            amount: amountRaw,
+                            assetSymbol,
+                            toAddress,
+                            mode: "steward",
+                            requiresUserSignature: false,
+                            reason,
+                        });
+                        if (callback) {
+                            callback({
+                                text,
+                                action: "TRANSFER_TOKEN_FAILED",
+                                executionMode: "steward",
+                                executed: false,
+                                recipient: toAddress,
+                                violations,
+                            });
+                        }
+                        return {
+                            text,
+                            success: false,
+                            data: {
+                                toAddress,
+                                amount: amountRaw,
+                                assetSymbol,
+                                mode: "steward",
+                                denied: true,
+                                violations,
+                                executed: false,
+                            },
+                        };
+                    }
+                    // Other steward errors — fall through to direct signing
+                }
+                catch (_stewardErr) {
+                    // Steward unavailable — fall through to direct signing
+                }
+            }
+            // ── POST to transfer execution API (direct signing fallback) ───────
+            const body = {
+                toAddress,
+                amount: amountRaw,
+                assetSymbol,
+                confirm: true,
+            };
+            if (tokenAddress) {
+                body.tokenAddress = tokenAddress;
+            }
+            const response = await fetch(`http://127.0.0.1:${getWalletActionApiPort()}/api/wallet/transfer/execute`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "X-Eliza-Agent-Action": "1",
+                    ...buildAuthHeaders(),
+                },
+                body: JSON.stringify(body),
+                signal: AbortSignal.timeout(TRANSFER_TIMEOUT_MS),
+            });
+            if (!response.ok) {
+                const errBody = (await response.json().catch(() => ({})));
+                const text = `Transfer failed: ${errBody.error ?? `HTTP ${response.status}`}`;
+                if (callback)
+                    callback({ text, action: "TRANSFER_TOKEN_FAILED" });
+                return {
+                    text,
+                    success: false,
+                };
+            }
+            const result = (await response.json());
+            if (!result.ok) {
+                const text = `Transfer failed: ${result.error ?? "unknown error"}`;
+                if (callback)
+                    callback({ text, action: "TRANSFER_TOKEN_FAILED" });
+                return {
+                    text,
+                    success: false,
+                };
+            }
+            // ── Build human-readable response ──────────────────────────────────
+            if (result.executed && result.execution) {
+                const text = buildTransferSuccessText({
+                    amount: amountRaw,
+                    assetSymbol,
+                    toAddress,
+                    mode: result.mode,
+                    txHash: result.execution.hash,
+                    explorerUrl: result.execution.explorerUrl,
+                    status: result.execution.status,
+                });
+                if (callback) {
+                    callback({
+                        text,
+                        action: "TRANSFER_TOKEN_SUCCESS",
+                        txHash: result.execution.hash,
+                        explorerUrl: result.execution.explorerUrl,
+                        executionMode: result.mode,
+                        executed: true,
+                        recipient: toAddress,
+                    });
+                }
+                return {
+                    text,
+                    success: true,
+                    data: {
+                        toAddress,
+                        amount: amountRaw,
+                        assetSymbol,
+                        mode: result.mode,
+                        txHash: result.execution.hash,
+                        explorerUrl: result.execution.explorerUrl,
+                        executed: true,
+                    },
+                };
+            }
+            // For agent automation, reporting "success" without an on-chain execution
+            // leads to false-positive heartbeat status.
+            const text = buildTransferFailureText({
+                amount: amountRaw,
+                assetSymbol,
+                toAddress,
+                mode: result.mode,
+                requiresUserSignature: result.requiresUserSignature,
+                reason: result.requiresUserSignature
+                    ? "User signature is required before the transfer can be broadcast."
+                    : "Transfer was prepared but not executed on-chain.",
+            });
+            if (callback) {
+                callback({
+                    text,
+                    action: "TRANSFER_TOKEN_FAILED",
+                    executionMode: result.mode,
+                    executed: false,
+                    recipient: toAddress,
+                    requiresUserSignature: result.requiresUserSignature,
+                });
+            }
+            return {
+                text,
+                success: false,
+                data: {
+                    toAddress,
+                    amount: amountRaw,
+                    assetSymbol,
+                    mode: result.mode,
+                    requiresUserSignature: result.requiresUserSignature,
+                    executed: false,
+                    unsignedTx: result.unsignedTx,
+                },
+            };
+        }
+        catch (err) {
+            const text = `Transfer failed: ${err instanceof Error ? err.message : String(err)}`;
+            if (callback)
+                callback({ text, action: "TRANSFER_TOKEN_FAILED" });
+            return {
+                text,
+                success: false,
+            };
+        }
+    },
+    parameters: [
+        {
+            name: "toAddress",
+            description: "Recipient EVM address (0x-prefixed, 40 hex characters)",
+            required: true,
+            schema: { type: "string" },
+        },
+        {
+            name: "amount",
+            description: 'Human-readable transfer amount (e.g. "1.5" BNB, "100" USDT)',
+            required: true,
+            schema: { type: "string" },
+        },
+        {
+            name: "assetSymbol",
+            description: 'Token symbol to transfer (e.g. "BNB", "USDT", "USDC")',
+            required: true,
+            schema: { type: "string" },
+        },
+        {
+            name: "tokenAddress",
+            description: "Token contract address for custom tokens (optional, not needed for native BNB)",
+            required: false,
+            schema: { type: "string" },
+        },
+    ],
+};

package/packages/agent/src/actions/update-owner-profile.d.ts

@@ -1,3 +1,2 @@
-import type { Action } from "@elizaos/core";
-export declare const updateOwnerProfileAction: Action;
+export * from "@elizaos/app-lifeops/actions/update-owner-profile";
 //# sourceMappingURL=update-owner-profile.d.ts.map

package/packages/agent/src/actions/update-owner-profile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update-owner-profile.d.ts","sourceRoot":"","sources":["../../../../../src/actions/update-owner-profile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAkB,MAAM,eAAe,CAAC;AAiD5D,eAAO,MAAM,wBAAwB,EAAE,MAuHtC,CAAC"}
+{"version":3,"file":"update-owner-profile.d.ts","sourceRoot":"","sources":["../../../../../src/actions/update-owner-profile.ts"],"names":[],"mappings":"AAAA,cAAc,mDAAmD,CAAC"}