@swivy/node 0.0.0-stage → 1.0.1

package/dist/packages/node/src/index.js

@@ -0,0 +1,1248 @@
+import crypto from "node:crypto";
+import { Chain as PolymarketChain, ClobClient, OrderType as PolymarketOrderType, Side as PolymarketSide, SignatureTypeV2 as PolymarketSignatureType, } from "@polymarket/clob-client-v2";
+import { ExchangeClient, HttpTransport, InfoClient, } from "@nktkas/hyperliquid";
+import { generateExportRecipientKeyPair, openSealedExport } from "@swivy/core";
+import { createSessionGrantAuthorizationMessage as buildSessionGrantAuthorizationMessage } from "@swivy/core";
+function assertHyperliquidEvmAddress(address) {
+    if (!/^0x[0-9a-fA-F]{40}$/.test(address)) {
+        throw new Error("invalid_hyperliquid_account_address");
+    }
+    return address.toLowerCase();
+}
+function createHyperliquidTransport(options = {}) {
+    const transportOptions = {
+        isTestnet: options.network === "testnet",
+    };
+    if (options.apiUrl) {
+        transportOptions.apiUrl = options.apiUrl;
+    }
+    if (options.timeoutMs !== undefined) {
+        transportOptions.timeout = options.timeoutMs;
+    }
+    return new HttpTransport(transportOptions);
+}
+export function buildHyperliquidOrderPreview(order, options = {}) {
+    return {
+        provider: "hyperliquid",
+        network: options.network ?? "mainnet",
+        order: {
+            asset: order.asset,
+            side: order.isBuy ? "buy" : "sell",
+            price: order.price,
+            size: order.size,
+            reduceOnly: order.reduceOnly ?? false,
+            tif: order.tif ?? "Gtc",
+            grouping: order.grouping ?? "na",
+            clientOrderId: order.clientOrderId,
+        },
+        execution: {
+            ready: false,
+            requiresSwivyWallet: true,
+            hint: "Use --account acct_... to sign with a Swivy EVM wallet.",
+        },
+    };
+}
+export async function getHyperliquidMids(options = {}) {
+    const client = new InfoClient({ transport: createHyperliquidTransport(options) });
+    return client.allMids();
+}
+export async function getHyperliquidPerpMarkets(options = {}) {
+    const client = new InfoClient({ transport: createHyperliquidTransport(options) });
+    return client.metaAndAssetCtxs();
+}
+export async function getHyperliquidAccountStatus(address, options = {}) {
+    const accountAddress = assertHyperliquidEvmAddress(address);
+    const network = options.network ?? "mainnet";
+    const client = new InfoClient({ transport: createHyperliquidTransport(options) });
+    try {
+        const state = await client.clearinghouseState({ user: accountAddress });
+        const marginSummary = state && typeof state === "object"
+            ? state.marginSummary
+            : undefined;
+        const accountValue = marginSummary?.accountValue ?? null;
+        const withdrawable = state && typeof state === "object" && typeof state.withdrawable === "string"
+            ? state.withdrawable
+            : null;
+        const funded = Number(accountValue ?? "0") > 0 || Number(withdrawable ?? "0") > 0;
+        return {
+            provider: "hyperliquid",
+            network,
+            address: accountAddress,
+            initialized: true,
+            funded,
+            accountValue,
+            withdrawable,
+            marginSummary,
+            state,
+            next: funded
+                ? "Ready for Swivy-signed Hyperliquid orders."
+                : network === "testnet"
+                    ? "Claim mock USDC for this Swivy address from Hyperliquid testnet, then rerun status."
+                    : "Deposit USDC to this Swivy address on Hyperliquid, then rerun status.",
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const missing = /does not exist|not found|unknown user/i.test(message);
+        return {
+            provider: "hyperliquid",
+            network,
+            address: accountAddress,
+            initialized: false,
+            funded: false,
+            accountValue: null,
+            withdrawable: null,
+            error: message,
+            next: missing
+                ? network === "testnet"
+                    ? "Initialize this Swivy address on Hyperliquid testnet by claiming mock USDC after mainnet eligibility is satisfied."
+                    : "Initialize this Swivy address on Hyperliquid by depositing USDC to it."
+                : "Hyperliquid account status check failed; retry or inspect with --json.",
+        };
+    }
+}
+export async function placeHyperliquidOrder(payload, options = {}) {
+    const client = new ExchangeClient({
+        transport: createHyperliquidTransport(options),
+        wallet: payload.wallet,
+    });
+    const response = await client.order({
+        orders: [{
+                a: payload.asset,
+                b: payload.isBuy,
+                p: payload.price,
+                s: payload.size,
+                r: payload.reduceOnly ?? false,
+                t: { limit: { tif: payload.tif ?? "Gtc" } },
+                c: payload.clientOrderId,
+            }],
+        grouping: payload.grouping ?? "na",
+    }, {
+        expiresAfter: payload.expiresAfter,
+    });
+    return {
+        preview: {
+            ...buildHyperliquidOrderPreview(payload, options),
+            execution: {
+                ready: true,
+                requiresSwivyWallet: true,
+                hint: "Order was signed by the Swivy EVM wallet and submitted to Hyperliquid.",
+            },
+        },
+        response,
+    };
+}
+function createSwivyHyperliquidWallet(params) {
+    const address = assertHyperliquidEvmAddress(params.accountAddress);
+    return {
+        address,
+        async getAddress() {
+            return address;
+        },
+        async signTypedData(typedData) {
+            const intent = await params.client.signTypedDataAndWait({
+                accountId: params.accountId,
+                challengeId: params.challengeId,
+                typedData: {
+                    domain: typedData.domain,
+                    types: typedData.types,
+                    primaryType: typedData.primaryType,
+                    message: typedData.message,
+                },
+            }, params.wait);
+            if (intent.status !== "completed" || !intent.result?.signature) {
+                throw new Error(intent.result?.error ?? "hyperliquid_swivy_signing_failed");
+            }
+            return intent.result.signature;
+        },
+    };
+}
+function assertPolymarketEvmAddress(address) {
+    if (!/^0x[0-9a-fA-F]{40}$/.test(address)) {
+        throw new Error("invalid_polymarket_account_address");
+    }
+    return address.toLowerCase();
+}
+function resolvePolymarketOrderType(orderType) {
+    switch (orderType ?? "GTC") {
+        case "GTD":
+            return PolymarketOrderType.GTD;
+        case "FOK":
+            return PolymarketOrderType.FOK;
+        case "FAK":
+            return PolymarketOrderType.FAK;
+        case "GTC":
+        default:
+            return PolymarketOrderType.GTC;
+    }
+}
+function buildPolymarketOrderPreviewPayload(payload) {
+    return {
+        provider: "polymarket",
+        network: "polygon-mainnet",
+        order: {
+            tokenId: payload.tokenId,
+            conditionId: payload.conditionId ?? null,
+            side: payload.side,
+            price: payload.price,
+            size: payload.size,
+            requestedValueUsd: payload.requestedValueUsd ?? payload.price * payload.size,
+            orderType: payload.orderType ?? "GTC",
+            builderCode: payload.builderCode ?? null,
+        },
+        execution: {
+            ready: false,
+            requiresTypedDataSignature: true,
+            hint: "Order has not been signed or submitted yet.",
+        },
+    };
+}
+function numberFromOrderbookLevel(level) {
+    if (Array.isArray(level)) {
+        const value = Number(level[0]);
+        return Number.isFinite(value) ? value : null;
+    }
+    if (level && typeof level === "object") {
+        const record = level;
+        const value = Number(record.price ?? record.p);
+        return Number.isFinite(value) ? value : null;
+    }
+    return null;
+}
+export function getPolymarketObservedPriceFromOrderbook(orderbook) {
+    const record = orderbook && typeof orderbook === "object"
+        ? orderbook
+        : {};
+    const bids = Array.isArray(record.bids) ? record.bids : [];
+    const asks = Array.isArray(record.asks) ? record.asks : [];
+    const bestBid = bids.length ? numberFromOrderbookLevel(bids[bids.length - 1]) ?? numberFromOrderbookLevel(bids[0]) : null;
+    const bestAsk = asks.length ? numberFromOrderbookLevel(asks[0]) : null;
+    if (bestBid !== null && bestAsk !== null) {
+        return (bestBid + bestAsk) / 2;
+    }
+    return bestAsk ?? bestBid;
+}
+function isPolymarketStopTriggered(params) {
+    return params.triggerDirection === "above"
+        ? params.observedPrice >= params.triggerPrice
+        : params.observedPrice <= params.triggerPrice;
+}
+function createSwivyPolymarketSigner(params) {
+    const address = assertPolymarketEvmAddress(params.accountAddress);
+    return {
+        async getAddress() {
+            return address;
+        },
+        async _signTypedData(domain, types, value) {
+            const intent = await params.client.signTypedDataAndWait({
+                accountId: params.accountId,
+                challengeId: params.challengeId,
+                typedData: {
+                    domain,
+                    types,
+                    primaryType: "Order",
+                    message: value,
+                },
+            }, params.wait);
+            if (intent.status !== "completed" || !intent.result?.signature) {
+                throw new Error(intent.result?.error ?? "polymarket_swivy_signing_failed");
+            }
+            return intent.result.signature;
+        },
+    };
+}
+function parseJsonResponseBody(response, text) {
+    if (!text) {
+        return {};
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        const contentType = response.headers.get("content-type") ?? "";
+        if (response.ok) {
+            throw new Error(contentType ? `invalid_json_response:${contentType}` : "invalid_json_response");
+        }
+        throw new Error(`http_${response.status}_non_json_response`);
+    }
+}
+function resolveResponseErrorMessage(response, payload) {
+    if (typeof payload?.error === "string" && payload.error) {
+        return payload.error;
+    }
+    if (typeof payload?.error?.message === "string" && payload.error.message) {
+        return payload.error.message;
+    }
+    if (typeof payload?.message === "string" && payload.message) {
+        return payload.message;
+    }
+    return response.statusText || `http_${response.status}`;
+}
+function randomNonce(bytes = 24) {
+    return crypto.randomBytes(bytes).toString("base64url");
+}
+export function generateSessionKeyPair() {
+    const { publicKey, privateKey } = crypto.generateKeyPairSync("ed25519");
+    return {
+        curve: "ed25519",
+        publicKeyPem: publicKey.export({ type: "spki", format: "pem" }).toString(),
+        privateKeyPem: privateKey.export({ type: "pkcs8", format: "pem" }).toString(),
+    };
+}
+export function createSessionGrantAuthorization(params) {
+    const nonce = params.nonce ?? randomNonce();
+    const expiresAt = new Date(Date.now() + (params.expiresInSeconds ?? 60) * 1000).toISOString();
+    const message = buildSessionGrantAuthorizationMessage({
+        grantId: params.grantId,
+        accountId: params.accountId,
+        chain: params.chain,
+        kind: params.kind,
+        payload: params.payload,
+        nonce,
+        expiresAt,
+    });
+    const signatureBase64 = crypto
+        .sign(null, Buffer.from(message, "utf8"), crypto.createPrivateKey(params.privateKeyPem))
+        .toString("base64");
+    return {
+        nonce,
+        expiresAt,
+        signatureBase64,
+    };
+}
+function countDefined(values) {
+    return values.filter((value) => value !== undefined && value !== null).length;
+}
+function resolveSessionGrantSigningKind(payload) {
+    const messageCount = countDefined([payload.message, payload.messageHex, payload.messageBase64]);
+    const typedDataCount = countDefined([payload.typedData]);
+    const digestCount = countDefined([payload.digestHex]);
+    const transactionCount = countDefined([payload.transaction, payload.serializedTransactionBase64]);
+    const totalModes = messageCount + typedDataCount + digestCount + transactionCount;
+    if (totalModes !== 1) {
+        throw new Error("unsupported_signing_payload");
+    }
+    if (typedDataCount === 1) {
+        return "sign_typed_data";
+    }
+    if (digestCount === 1) {
+        return "sign_digest";
+    }
+    if (messageCount === 1) {
+        return "sign_message";
+    }
+    return "sign_transaction";
+}
+/**
+ * Verify a Swivy webhook: `x-swivy-signature` is hex HMAC-SHA256 of the raw body.
+ * Reject events whose `createdAt` is older than you are willing to accept.
+ */
+export function verifySwivyWebhookSignature(params) {
+    if (!params.signature) {
+        return false;
+    }
+    const expected = crypto.createHmac("sha256", params.secret).update(params.rawBody).digest();
+    const received = Buffer.from(params.signature, "hex");
+    return received.length === expected.length && crypto.timingSafeEqual(received, expected);
+}
+export class SwivyNodeClient {
+    config;
+    sessionToken;
+    constructor(config) {
+        this.config = config;
+        this.sessionToken = config.sessionToken;
+    }
+    setSessionToken(token) {
+        this.sessionToken = token;
+    }
+    clearSessionToken() {
+        this.sessionToken = undefined;
+    }
+    async createOrganization(name) {
+        return this.request("/v1/control/organizations", {
+            method: "POST",
+            body: { name },
+            adminScope: "deployment",
+        });
+    }
+    async createProject(organizationId, name) {
+        return this.request(`/v1/control/organizations/${organizationId}/projects`, {
+            method: "POST",
+            body: { name },
+            adminScope: "scoped",
+        });
+    }
+    async updateProject(projectId, name) {
+        return this.request(`/v1/control/projects/${projectId}`, {
+            method: "PATCH",
+            body: { name },
+            adminScope: "scoped",
+        });
+    }
+    async createEnvironment(projectId, name) {
+        return this.request(`/v1/control/projects/${projectId}/environments`, {
+            method: "POST",
+            body: { name },
+            adminScope: "scoped",
+        });
+    }
+    async updateEnvironment(environmentId, name) {
+        return this.request(`/v1/control/environments/${environmentId}`, {
+            method: "PATCH",
+            body: { name },
+            adminScope: "scoped",
+        });
+    }
+    async getOrganizationOverview(organizationId) {
+        return this.request(`/v1/control/organizations/${organizationId}/overview`, {
+            method: "GET",
+            adminScope: "scoped",
+        });
+    }
+    async listEnvironmentCredentials(environmentId) {
+        return this.request(`/v1/control/environments/${environmentId}/credentials`, {
+            method: "GET",
+            adminScope: "scoped",
+        });
+    }
+    async createEnvironmentCredential(environmentId, label = "Rotated key") {
+        return this.request(`/v1/control/environments/${environmentId}/credentials`, {
+            method: "POST",
+            body: { label },
+            adminScope: "scoped",
+        });
+    }
+    async revokeEnvironmentCredential(environmentId, credentialId) {
+        return this.request(`/v1/control/environments/${environmentId}/credentials/${credentialId}`, {
+            method: "DELETE",
+            adminScope: "scoped",
+        });
+    }
+    async rotateWebhookSecret(environmentId, webhookId) {
+        return this.request(`/v1/control/environments/${environmentId}/webhooks/${webhookId}/rotate-secret`, {
+            method: "POST",
+            adminScope: "scoped",
+        });
+    }
+    async listWebhooks(environmentId) {
+        return this.request(`/v1/control/environments/${environmentId}/webhooks`, {
+            method: "GET",
+            adminScope: "scoped",
+        });
+    }
+    async revokeWebhook(environmentId, webhookId) {
+        return this.request(`/v1/control/environments/${environmentId}/webhooks/${webhookId}`, {
+            method: "DELETE",
+            adminScope: "scoped",
+        });
+    }
+    async listOrganizationAdminCredentials(organizationId) {
+        return this.request(`/v1/control/organizations/${organizationId}/admin-credentials`, {
+            method: "GET",
+            adminScope: "scoped",
+        });
+    }
+    async createOrganizationAdminCredential(organizationId, body = {}) {
+        return this.request(`/v1/control/organizations/${organizationId}/admin-credentials`, {
+            method: "POST",
+            body,
+            adminScope: "scoped",
+        });
+    }
+    async revokeOrganizationAdminCredential(organizationId, credentialId) {
+        return this.request(`/v1/control/organizations/${organizationId}/admin-credentials/${credentialId}`, {
+            method: "DELETE",
+            adminScope: "scoped",
+        });
+    }
+    async listOrganizationMembers(organizationId) {
+        return this.request(`/v1/control/organizations/${organizationId}/members`, {
+            method: "GET",
+            adminScope: "scoped",
+        });
+    }
+    async revokeOrganizationMember(organizationId, memberId) {
+        return this.request(`/v1/control/organizations/${organizationId}/members/${memberId}`, {
+            method: "DELETE",
+            adminScope: "scoped",
+        });
+    }
+    async updateOrganizationMemberRole(organizationId, memberId, role) {
+        return this.request(`/v1/control/organizations/${organizationId}/members/${memberId}`, {
+            method: "PATCH",
+            body: { role },
+            adminScope: "scoped",
+        });
+    }
+    async listOrganizationInvites(organizationId) {
+        return this.request(`/v1/control/organizations/${organizationId}/invites`, {
+            method: "GET",
+            adminScope: "scoped",
+        });
+    }
+    async createOrganizationInvite(organizationId, body) {
+        return this.request(`/v1/control/organizations/${organizationId}/invites`, {
+            method: "POST",
+            body,
+            adminScope: "scoped",
+        });
+    }
+    async revokeOrganizationInvite(organizationId, inviteId) {
+        return this.request(`/v1/control/organizations/${organizationId}/invites/${inviteId}`, {
+            method: "DELETE",
+            adminScope: "scoped",
+        });
+    }
+    async acceptOrganizationInvite(inviteId, body) {
+        return this.request(`/v1/control/organization-invites/${inviteId}/accept`, {
+            method: "POST",
+            body,
+        });
+    }
+    async updateEnvironmentPolicy(environmentId, policy) {
+        return this.request(`/v1/control/environments/${environmentId}/policy`, {
+            method: "PUT",
+            body: policy,
+            adminScope: "scoped",
+        });
+    }
+    async listEnvironmentChainRpcConfigs(environmentId) {
+        return this.request(`/v1/control/environments/${environmentId}/chains`, {
+            method: "GET",
+            environment: true,
+        });
+    }
+    async upsertEnvironmentChainRpcConfig(environmentId, chain, config) {
+        return this.request(`/v1/control/environments/${environmentId}/chains/${chain}`, {
+            method: "PUT",
+            body: config,
+            adminScope: "scoped",
+        });
+    }
+    async requestEmailCode(email, externalUserId) {
+        return this.request("/v1/runtime/auth/email/request", {
+            method: "POST",
+            body: { email, externalUserId },
+            environment: true,
+        });
+    }
+    async verifyEmailCode(email, code, externalUserId) {
+        const result = await this.request("/v1/runtime/auth/email/verify", {
+            method: "POST",
+            body: { email, code, externalUserId },
+            environment: true,
+        });
+        if (result.sessionToken) {
+            this.sessionToken = result.sessionToken;
+        }
+        return result;
+    }
+    /** Request a primary login code. The environment must enable SMS login. */
+    async requestSmsCode(phoneNumber) {
+        return this.request("/v1/runtime/auth/sms/request", {
+            method: "POST",
+            body: { phoneNumber },
+            environment: true,
+        });
+    }
+    async verifySmsCode(challengeId, code) {
+        const result = await this.request("/v1/runtime/auth/sms/verify", {
+            method: "POST",
+            body: { challengeId, code },
+            environment: true,
+        });
+        if (result.sessionToken)
+            this.sessionToken = result.sessionToken;
+        return result;
+    }
+    async getMe() {
+        return this.request("/v1/runtime/me", {
+            method: "GET",
+            runtime: true,
+        });
+    }
+    async claimUsername(username) {
+        return this.request("/v1/runtime/id/username", {
+            method: "POST",
+            body: { username },
+            runtime: true,
+        });
+    }
+    async lookupUsername(username) {
+        return this.request(`/v1/runtime/id/${encodeURIComponent(username)}`, {
+            method: "GET",
+            runtime: true,
+        });
+    }
+    async startTotp(label = "Authenticator app") {
+        return this.request("/v1/runtime/mfa/totp/start", {
+            method: "POST",
+            body: { label },
+            runtime: true,
+        });
+    }
+    async verifyTotp(authMethodId, code) {
+        return this.request("/v1/runtime/mfa/totp/verify", {
+            method: "POST",
+            body: { authMethodId, code },
+            runtime: true,
+        });
+    }
+    async createChallenge(authMethodId, purpose) {
+        return this.request("/v1/runtime/mfa/challenges", {
+            method: "POST",
+            body: { authMethodId, purpose },
+            runtime: true,
+        });
+    }
+    async verifyChallenge(challengeId, payload) {
+        return this.request("/v1/runtime/mfa/challenges/verify", {
+            method: "POST",
+            body: { challengeId, ...payload },
+            runtime: true,
+        });
+    }
+    async createManagedAccount(chain, options) {
+        const normalizedOptions = typeof options === "string" ? { label: options } : options;
+        return this.request("/v1/runtime/accounts/managed", {
+            method: "POST",
+            body: { chain, ...normalizedOptions },
+            runtime: true,
+        });
+    }
+    async listAccounts() {
+        return this.request("/v1/runtime/accounts", {
+            method: "GET",
+            runtime: true,
+        });
+    }
+    async listWalletTools() {
+        return this.request("/v1/runtime/tools", {
+            method: "GET",
+            runtime: true,
+        });
+    }
+    async createLifiQuote(body) {
+        return this.request("/v1/runtime/tools/lifi/quote", {
+            method: "POST",
+            body,
+            runtime: true,
+        });
+    }
+    async createJupiterQuote(body) {
+        return this.request("/v1/runtime/tools/jupiter/quote", {
+            method: "POST",
+            body,
+            runtime: true,
+        });
+    }
+    async listPolymarketMarkets(nextCursor) {
+        const path = nextCursor
+            ? `/v1/runtime/tools/polymarket/markets?next_cursor=${encodeURIComponent(nextCursor)}`
+            : "/v1/runtime/tools/polymarket/markets";
+        return this.request(path, {
+            method: "GET",
+            runtime: true,
+        });
+    }
+    async getPolymarketOrderbook(tokenId) {
+        return this.request(`/v1/runtime/tools/polymarket/orderbook?tokenId=${encodeURIComponent(tokenId)}`, {
+            method: "GET",
+            runtime: true,
+        });
+    }
+    async previewPolymarketOrder(body) {
+        return this.request("/v1/runtime/tools/polymarket/orders/preview", {
+            method: "POST",
+            body,
+            runtime: true,
+        });
+    }
+    async createPolymarketStopLimitOrder(body) {
+        return this.request("/v1/runtime/tools/polymarket/stop-limit-orders", {
+            method: "POST",
+            body,
+            runtime: true,
+        });
+    }
+    async listPolymarketStopLimitOrders(status = "active") {
+        return this.request(`/v1/runtime/tools/polymarket/stop-limit-orders?status=${encodeURIComponent(status)}`, {
+            method: "GET",
+            runtime: true,
+        });
+    }
+    async cancelPolymarketStopLimitOrder(orderId) {
+        return this.request(`/v1/runtime/tools/polymarket/stop-limit-orders/${encodeURIComponent(orderId)}/cancel`, {
+            method: "POST",
+            runtime: true,
+        });
+    }
+    async evaluatePolymarketStopLimitOrder(orderId, body) {
+        return this.request(`/v1/runtime/tools/polymarket/stop-limit-orders/${encodeURIComponent(orderId)}/evaluate`, {
+            method: "POST",
+            body,
+            runtime: true,
+        });
+    }
+    async createSwapQuote(body) {
+        return this.request("/v1/runtime/swaps/quote", {
+            method: "POST",
+            body,
+            runtime: true,
+        });
+    }
+    async getHyperliquidMids(options) {
+        return getHyperliquidMids(options);
+    }
+    async createOrDerivePolymarketApiKeyWithSwivyWallet(payload, options = {}) {
+        const signer = createSwivyPolymarketSigner({
+            client: this,
+            accountId: payload.accountId,
+            accountAddress: payload.accountAddress,
+            challengeId: payload.challengeId,
+            wait: payload.wait,
+        });
+        const client = new ClobClient({
+            host: options.host ?? "https://clob.polymarket.com",
+            chain: options.chain ?? PolymarketChain.POLYGON,
+            signer,
+            signatureType: options.signatureType ?? PolymarketSignatureType.EOA,
+            funderAddress: options.funderAddress,
+            useServerTime: options.useServerTime ?? true,
+            throwOnError: true,
+        });
+        return client.createOrDeriveApiKey(payload.nonce);
+    }
+    async placePolymarketOrderWithSwivyWallet(payload, options = {}) {
+        const previewResponse = await this.previewPolymarketOrder(payload);
+        const accountAddress = payload.accountAddress ?? previewResponse.account?.address;
+        if (!accountAddress) {
+            throw new Error("missing_polymarket_account_address");
+        }
+        const signer = createSwivyPolymarketSigner({
+            client: this,
+            accountId: payload.accountId,
+            accountAddress,
+            challengeId: payload.challengeId,
+            wait: payload.wait,
+        });
+        const client = new ClobClient({
+            host: options.host ?? "https://clob.polymarket.com",
+            chain: options.chain ?? PolymarketChain.POLYGON,
+            signer,
+            creds: payload.apiCreds,
+            signatureType: options.signatureType ?? PolymarketSignatureType.EOA,
+            funderAddress: options.funderAddress,
+            useServerTime: options.useServerTime ?? true,
+            throwOnError: true,
+        });
+        const orderType = resolvePolymarketOrderType(payload.orderType);
+        const signedOrder = await client.createOrder({
+            tokenID: payload.tokenId,
+            price: payload.price,
+            size: payload.size,
+            side: payload.side === "buy" ? PolymarketSide.BUY : PolymarketSide.SELL,
+            builderCode: payload.builderCode ?? previewResponse.order?.builderCode ?? undefined,
+            metadata: payload.metadata,
+            expiration: payload.expiration,
+        });
+        const response = await client.postOrder(signedOrder, orderType, payload.postOnly, payload.deferExec);
+        return {
+            preview: {
+                ...buildPolymarketOrderPreviewPayload(payload),
+                execution: {
+                    ready: true,
+                    requiresTypedDataSignature: true,
+                    hint: "Order was signed through Swivy and submitted to Polymarket CLOB V2.",
+                },
+            },
+            signedOrder,
+            response,
+        };
+    }
+    async evaluateAndPlacePolymarketStopLimitOrder(stopLimitOrder, options = {}) {
+        const orderbookPayload = await this.getPolymarketOrderbook(stopLimitOrder.tokenId);
+        const observedPrice = getPolymarketObservedPriceFromOrderbook(orderbookPayload.orderbook);
+        if (observedPrice === null) {
+            throw new Error("polymarket_observed_price_unavailable");
+        }
+        const shouldTrigger = isPolymarketStopTriggered({
+            observedPrice,
+            triggerPrice: stopLimitOrder.triggerPrice,
+            triggerDirection: stopLimitOrder.triggerDirection,
+        });
+        if (!shouldTrigger) {
+            return {
+                observedPrice,
+                triggered: false,
+                evaluation: await this.evaluatePolymarketStopLimitOrder(stopLimitOrder.id, {
+                    observedPrice,
+                }),
+            };
+        }
+        const order = await this.placePolymarketOrderWithSwivyWallet({
+            accountId: stopLimitOrder.accountId,
+            accountAddress: stopLimitOrder.accountAddress,
+            tokenId: stopLimitOrder.tokenId,
+            conditionId: stopLimitOrder.conditionId,
+            side: stopLimitOrder.side,
+            price: stopLimitOrder.limitPrice,
+            size: stopLimitOrder.size,
+            requestedValueUsd: stopLimitOrder.requestedValueUsd ?? stopLimitOrder.limitPrice * stopLimitOrder.size,
+            jurisdiction: stopLimitOrder.jurisdiction,
+            agent: stopLimitOrder.agent,
+            builderCode: stopLimitOrder.builderCode,
+            metadata: stopLimitOrder.metadata,
+            expiration: stopLimitOrder.expiration,
+            challengeId: stopLimitOrder.challengeId,
+            wait: stopLimitOrder.wait,
+            apiCreds: stopLimitOrder.apiCreds,
+        }, options);
+        const responseRecord = order.response && typeof order.response === "object"
+            ? order.response
+            : {};
+        const triggeredOrderId = typeof responseRecord.orderID === "string"
+            ? responseRecord.orderID
+            : typeof responseRecord.orderId === "string"
+                ? responseRecord.orderId
+                : undefined;
+        return {
+            observedPrice,
+            triggered: true,
+            order,
+            evaluation: await this.evaluatePolymarketStopLimitOrder(stopLimitOrder.id, {
+                observedPrice,
+                triggeredOrderId,
+            }),
+        };
+    }
+    async getHyperliquidPerpMarkets(options) {
+        return getHyperliquidPerpMarkets(options);
+    }
+    async getHyperliquidAccountStatus(address, options) {
+        return getHyperliquidAccountStatus(address, options);
+    }
+    buildHyperliquidOrderPreview(order, options) {
+        return buildHyperliquidOrderPreview(order, options);
+    }
+    async placeHyperliquidOrder(payload, options) {
+        return placeHyperliquidOrder(payload, options);
+    }
+    async placeHyperliquidOrderWithSwivyWallet(payload, options) {
+        const account = payload.accountAddress
+            ? null
+            : (await this.listAccounts()).managedAccounts.find((managedAccount) => managedAccount.id === payload.accountId) ?? null;
+        const accountAddress = payload.accountAddress ?? account?.address;
+        if (!accountAddress) {
+            throw new Error("hyperliquid_account_not_found");
+        }
+        if (account && account.chain !== "evm") {
+            throw new Error("hyperliquid_requires_evm_account");
+        }
+        const wallet = createSwivyHyperliquidWallet({
+            client: this,
+            accountId: payload.accountId,
+            accountAddress,
+            challengeId: payload.challengeId,
+            wait: payload.wait,
+        });
+        return placeHyperliquidOrder({
+            ...payload,
+            wallet,
+        }, options);
+    }
+    async listEmbeddedWallets() {
+        const payload = await this.listAccounts();
+        return payload.managedAccounts;
+    }
+    async getManagedAccount(chain, options) {
+        const payload = await this.listAccounts();
+        return (payload.managedAccounts.find((account) => account.chain === chain &&
+            (!options?.purpose || ((account.purpose ?? "agent") === options.purpose))) ?? null);
+    }
+    async getEmbeddedWallet(chain) {
+        return this.getManagedAccount(chain);
+    }
+    async ensureManagedAccount(chain, options) {
+        const normalizedOptions = typeof options === "string" ? { label: options } : options;
+        const purpose = normalizedOptions?.purpose ??
+            (normalizedOptions?.custodyMode === "split_custody" ? "personal" : "agent");
+        const existing = await this.getManagedAccount(chain, {
+            purpose,
+        });
+        if (existing) {
+            return {
+                account: existing,
+                existing: true,
+            };
+        }
+        const created = await this.createManagedAccount(chain, normalizedOptions);
+        return {
+            account: created.account,
+            existing: Boolean(created.existing),
+            attestation: created.attestation,
+        };
+    }
+    async ensureEmbeddedWallet(chain, options) {
+        return this.ensureManagedAccount(chain, options);
+    }
+    async linkWallet(body) {
+        return this.request("/v1/runtime/accounts/linked", {
+            method: "POST",
+            body,
+            runtime: true,
+        });
+    }
+    async createSigningIntent(body) {
+        return this.request("/v1/runtime/intents/signing", {
+            method: "POST",
+            body,
+            runtime: true,
+        });
+    }
+    async createTransactionIntent(body) {
+        return this.request("/v1/runtime/intents/transactions", {
+            method: "POST",
+            body,
+            runtime: true,
+        });
+    }
+    async getIntent(intentId) {
+        return this.request(`/v1/runtime/intents/${intentId}`, {
+            method: "GET",
+            runtime: true,
+        });
+    }
+    async waitForIntent(intentId, options = {}) {
+        const timeoutMs = options.timeoutMs ?? 30_000;
+        const pollIntervalMs = options.pollIntervalMs ?? 1_000;
+        const startedAt = Date.now();
+        for (;;) {
+            if (options.signal?.aborted) {
+                throw new Error("intent_wait_aborted");
+            }
+            const payload = (await this.getIntent(intentId));
+            const intent = payload.intent;
+            if (intent.status === "completed" || intent.status === "failed") {
+                return intent;
+            }
+            if (Date.now() - startedAt >= timeoutMs) {
+                throw new Error("intent_wait_timeout");
+            }
+            await this.delay(pollIntervalMs, options.signal);
+        }
+    }
+    async createSigningIntentAndWait(body, options) {
+        const payload = (await this.createSigningIntent(body));
+        return this.waitForIntent(payload.intent.id, options);
+    }
+    async signMessageAndWait(body, options) {
+        return this.createSigningIntentAndWait(body, options);
+    }
+    async signTypedDataAndWait(body, options) {
+        return this.createSigningIntentAndWait({
+            accountId: body.accountId,
+            chain: "evm",
+            challengeId: body.challengeId,
+            payload: {
+                typedData: body.typedData,
+            },
+        }, options);
+    }
+    async signTransactionAndWait(body, options) {
+        return this.createSigningIntentAndWait(body, options);
+    }
+    async createTransactionIntentAndWait(body, options) {
+        const payload = (await this.createTransactionIntent(body));
+        return this.waitForIntent(payload.intent.id, options);
+    }
+    async executeTransactionAndWait(body, options) {
+        return this.createTransactionIntentAndWait(body, options);
+    }
+    async exportManagedAccount(accountId, challengeId) {
+        // The key comes back HPKE-sealed to a one-time key made here, so it is never in
+        // clear on the wire or in the API; it is opened locally.
+        const recipient = generateExportRecipientKeyPair();
+        const payload = await this.request(`/v1/runtime/accounts/${accountId}/export`, {
+            method: "POST",
+            body: { challengeId, recipientPublicKey: recipient.publicKeyBase64 },
+            runtime: true,
+        });
+        if (!payload.encryption) {
+            // An older API ignored recipientPublicKey and sent the key in clear: refuse it.
+            throw new Error("sealed_export_not_supported_by_server");
+        }
+        const { encryption, ...rest } = payload;
+        // Pin what the server says it bound the ciphertext to.
+        if (encryption.info !== "swivy-export-v1" || !String(encryption.aad).startsWith(`swivy-export:${accountId}:`)) {
+            throw new Error("sealed_export_binding_mismatch");
+        }
+        return { ...rest, privateKey: openSealedExport(encryption, recipient.privateKey) };
+    }
+    async rawSign(accountId, challengeId, payload) {
+        return this.request(`/v1/runtime/accounts/${accountId}/raw-sign`, {
+            method: "POST",
+            body: { challengeId, payload },
+            runtime: true,
+        });
+    }
+    async getAccountCustody(accountId) {
+        return this.request(`/v1/runtime/accounts/${accountId}/custody`, {
+            method: "GET",
+            runtime: true,
+        });
+    }
+    async enableSplitCustody(accountId, splitCustody) {
+        return this.request(`/v1/runtime/accounts/${accountId}/custody/split`, {
+            method: "POST",
+            body: splitCustody,
+            runtime: true,
+        });
+    }
+    async createSessionGrant(body) {
+        return this.request("/v1/runtime/session-grants", {
+            method: "POST",
+            body,
+            runtime: true,
+        });
+    }
+    async listSessionGrants() {
+        return this.request("/v1/runtime/session-grants", {
+            method: "GET",
+            runtime: true,
+        });
+    }
+    async revokeSessionGrant(grantId) {
+        return this.request(`/v1/runtime/session-grants/${grantId}/revoke`, {
+            method: "POST",
+            runtime: true,
+        });
+    }
+    async createSigningIntentWithSessionGrant(grant, privateKeyPem, payload) {
+        const authorization = createSessionGrantAuthorization({
+            grantId: grant.id,
+            accountId: grant.accountId,
+            chain: grant.chain,
+            kind: resolveSessionGrantSigningKind(payload),
+            payload,
+            privateKeyPem,
+        });
+        return this.request(`/v1/runtime/session-grants/${grant.id}/intents/signing`, {
+            method: "POST",
+            body: { payload, authorization },
+            environment: true,
+        });
+    }
+    async createTransactionIntentWithSessionGrant(grant, privateKeyPem, payload) {
+        const authorization = createSessionGrantAuthorization({
+            grantId: grant.id,
+            accountId: grant.accountId,
+            chain: grant.chain,
+            kind: "execute_transaction",
+            payload,
+            privateKeyPem,
+        });
+        return this.request(`/v1/runtime/session-grants/${grant.id}/intents/transactions`, {
+            method: "POST",
+            body: { payload, authorization },
+            environment: true,
+        });
+    }
+    async createServerWallet(chain, options = {}) {
+        return this.request("/v1/server/wallets", {
+            method: "POST",
+            body: {
+                chain,
+                label: options.label,
+                idempotencyKey: options.idempotencyKey,
+                authorizationPublicKey: options.authorizationPublicKeyPem,
+            },
+            server: true,
+        });
+    }
+    async listServerWallets() {
+        return this.request("/v1/server/wallets", { method: "GET", server: true });
+    }
+    async getServerWallet(walletId) {
+        return this.request(`/v1/server/wallets/${encodeURIComponent(walletId)}`, { method: "GET", server: true });
+    }
+    async createServerWalletSigningIntent(wallet, payload, options = {}) {
+        return this.request(`/v1/server/wallets/${encodeURIComponent(wallet.id)}/intents/signing`, {
+            method: "POST",
+            body: {
+                payload,
+                authorization: options.authorizationPrivateKeyPem
+                    ? createSessionGrantAuthorization({
+                        grantId: wallet.id,
+                        accountId: wallet.accountId,
+                        chain: wallet.chain,
+                        kind: resolveSessionGrantSigningKind(payload),
+                        payload,
+                        privateKeyPem: options.authorizationPrivateKeyPem,
+                    })
+                    : undefined,
+            },
+            server: true,
+        });
+    }
+    async createServerWalletTransactionIntent(wallet, payload, options = {}) {
+        return this.request(`/v1/server/wallets/${encodeURIComponent(wallet.id)}/intents/transactions`, {
+            method: "POST",
+            body: {
+                payload,
+                authorization: options.authorizationPrivateKeyPem
+                    ? createSessionGrantAuthorization({
+                        grantId: wallet.id,
+                        accountId: wallet.accountId,
+                        chain: wallet.chain,
+                        kind: "execute_transaction",
+                        payload,
+                        privateKeyPem: options.authorizationPrivateKeyPem,
+                    })
+                    : undefined,
+            },
+            server: true,
+        });
+    }
+    async getServerWalletIntent(walletId, intentId) {
+        return this.request(`/v1/server/wallets/${encodeURIComponent(walletId)}/intents/${encodeURIComponent(intentId)}`, { method: "GET", server: true });
+    }
+    async getUser(userId) {
+        return this.request(`/v1/server/users/${encodeURIComponent(userId)}`, { method: "GET", server: true });
+    }
+    async getUserByEmail(email) {
+        return this.request(`/v1/server/users?email=${encodeURIComponent(email)}`, { method: "GET", server: true });
+    }
+    /** Create (or find by email) a user and optionally give it wallets before first login. */
+    async createUser(email, options = {}) {
+        return this.request("/v1/server/users", {
+            method: "POST",
+            body: { email, externalUserId: options.externalUserId, createWallets: options.createWallets },
+            server: true,
+        });
+    }
+    async createUserWallet(userId, chain, label) {
+        return this.request(`/v1/server/users/${encodeURIComponent(userId)}/wallets`, {
+            method: "POST",
+            body: { chain, label },
+            server: true,
+        });
+    }
+    async listUsers(options = {}) {
+        const query = new URLSearchParams();
+        if (options.limit)
+            query.set("limit", String(options.limit));
+        if (options.cursor)
+            query.set("cursor", options.cursor);
+        const suffix = query.size ? `?${query.toString()}` : "";
+        return this.request(`/v1/server/users/list${suffix}`, { method: "GET", server: true });
+    }
+    /** Remove a user's personal data and access. Their wallets are kept. */
+    async deleteUser(userId) {
+        return this.request(`/v1/server/users/${encodeURIComponent(userId)}`, { method: "DELETE", server: true });
+    }
+    /** Server-side check of a user's session token (Privy verifyAccessToken equivalent). */
+    async verifySessionToken(sessionToken) {
+        return this.request("/v1/server/sessions/verify", {
+            method: "POST",
+            body: { sessionToken },
+            server: true,
+        });
+    }
+    async listWebhookDeliveries(options = {}) {
+        const query = new URLSearchParams();
+        if (options.status)
+            query.set("status", options.status);
+        if (options.limit)
+            query.set("limit", String(options.limit));
+        const suffix = query.size ? `?${query.toString()}` : "";
+        return this.request(`/v1/server/webhooks/deliveries${suffix}`, { method: "GET", server: true });
+    }
+    async replayWebhookDelivery(deliveryId) {
+        return this.request(`/v1/server/webhooks/deliveries/${encodeURIComponent(deliveryId)}/replay`, {
+            method: "POST",
+            server: true,
+        });
+    }
+    async request(path, options) {
+        const headers = {};
+        if (options.server) {
+            const appId = this.config.appId ?? this.config.environmentId;
+            const secretKey = this.config.secretKey ?? this.config.apiKey;
+            if (!appId || !secretKey) {
+                throw new Error("appId and secretKey are required for server routes");
+            }
+            headers["x-swivy-app-id"] = appId;
+            headers["x-swivy-secret-key"] = secretKey;
+        }
+        if (options.adminScope === "deployment") {
+            if (!this.config.adminToken) {
+                throw new Error("deployment admin token is required");
+            }
+            headers["x-admin-token"] = this.config.adminToken;
+        }
+        if (options.adminScope === "scoped") {
+            if (this.config.controlPlaneKey) {
+                headers["x-swivy-admin-key"] = this.config.controlPlaneKey;
+            }
+            else if (this.config.adminToken) {
+                headers["x-admin-token"] = this.config.adminToken;
+            }
+            else {
+                throw new Error("control plane credential is required");
+            }
+        }
+        if (options.environment || options.runtime) {
+            const appId = this.config.appId ?? this.config.environmentId;
+            const secretKey = this.config.secretKey ?? this.config.apiKey;
+            const credential = secretKey ?? this.config.publishableKey;
+            if (!appId || !credential) {
+                throw new Error("environment credentials are required");
+            }
+            headers["x-swivy-app-id"] = appId;
+            if (secretKey) {
+                headers["x-swivy-secret-key"] = secretKey;
+            }
+            else {
+                headers["x-swivy-publishable-key"] = credential;
+            }
+        }
+        if (options.runtime) {
+            if (!this.sessionToken) {
+                throw new Error("session token is required");
+            }
+            headers.authorization = `Bearer ${this.sessionToken}`;
+        }
+        if (options.body !== undefined) {
+            headers["content-type"] = "application/json";
+        }
+        const response = await fetch(`${this.config.baseUrl}${path}`, {
+            method: options.method,
+            headers,
+            body: options.body !== undefined ? JSON.stringify(options.body) : undefined,
+        });
+        const text = await response.text();
+        const payload = parseJsonResponseBody(response, text);
+        if (!response.ok) {
+            throw new Error(resolveResponseErrorMessage(response, payload));
+        }
+        return payload;
+    }
+    async delay(ms, signal) {
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                cleanup();
+                resolve();
+            }, ms);
+            const onAbort = () => {
+                cleanup();
+                reject(new Error("intent_wait_aborted"));
+            };
+            const cleanup = () => {
+                clearTimeout(timer);
+                signal?.removeEventListener("abort", onAbort);
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
+        });
+    }
+}