@swivy/node 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,40 @@
-# Temporary Holding Version
+# @swivy/node
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Swivy node SDK. Testnet preview; production onboarding is gated on the Swop canary.
+
+Public npm distribution is being prepared. Before first publication, use all SDK tarballs
+from one operator-supplied release and verify its SHA256SUMS. After publication:
+
+```sh
+npm install @swivy/node@next
+```
+
+Use an environment app ID and publishable key for browser/mobile apps. Keep environment
+secret keys on the backend and deployment bootstrap credentials with the deployment operator.
+Choose email or SMS in your environment policy; SMS recovery alone does not enable SMS login.
+Never log login codes, runtime sessions or signing material.
+
+Browser apps currently need a same-origin reverse proxy for `/v1/runtime/*`; the API
+does not advertise cross-origin browser access. Backend and native clients can use the API directly.
+
+The client exposes `requestSmsCode(phoneNumber)` and `verifySmsCode(challengeId, code)`. Supply phone numbers in E.164 format.
+
+Create a separate client per customer request/session; its session token is mutable. Requires Node 22 or newer.
+
+## Preview dependency policy
+
+Before installing this preview, merge the following into your application's root
+package.json. The legacy trading client's provider pins an older WebSocket release;
+npm does not apply overrides declared by installed libraries.
+
+```json
+{
+  "overrides": {
+    "ws@>=8.0.0 <9.0.0": "^8.21.0"
+  }
+}
+```
+
+Commit the resulting lockfile and run your integration tests and `npm audit --omit=dev`.
+The release consumer smoke verifies installation with this policy; bare installation
+without it is not claimed advisory-clean. WebSocket 7 dependencies keep their own major.

package/dist/packages/node/src/index.d.ts

@@ -0,0 +1,600 @@
+import { Chain as PolymarketChain, SignatureTypeV2 as PolymarketSignatureType, type ApiKeyCreds as PolymarketApiKeyCreds } from "@polymarket/clob-client-v2";
+import type { AbstractWallet } from "@nktkas/hyperliquid/signing";
+import type { Chain, ChainCapabilities, CustodyMode, EnvironmentChainRpcConfig, ExecutionResult, IdentityDescriptor, IntentPayload, LinkedWalletDescriptor, ManagedAccountDescriptor, OrganizationOverview, OrganizationAdminCredentialDescriptor, OrganizationInviteDescriptor, OrganizationMemberDescriptor, SessionGrantDescriptor, SessionGrantScope, TransactionIntent, TypedDataDescriptor, WalletPurpose, WebhookDescriptor, WebhookSecretReveal } from "@swivy/core";
+export interface SwivyNodeClientConfig {
+    baseUrl: string;
+    adminToken?: string;
+    controlPlaneKey?: string;
+    appId?: string;
+    publishableKey?: string;
+    secretKey?: string;
+    environmentId?: string;
+    /**
+     * Legacy alias for secretKey while Swop migrates off x-env-id/x-api-key.
+     */
+    apiKey?: string;
+    sessionToken?: string;
+}
+export interface SwivyNodeListAccountsPayload {
+    managedAccounts: ManagedAccountDescriptor[];
+    linkedWallets: LinkedWalletDescriptor[];
+}
+export interface SwivyNodeIdentityLookupPayload {
+    identity: IdentityDescriptor;
+    managedAccounts: ManagedAccountDescriptor[];
+    linkedWallets: LinkedWalletDescriptor[];
+}
+export interface SwivyNodeWaitForIntentOptions {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    signal?: AbortSignal;
+}
+export interface SwivyNodeManagedAccountResolution {
+    account: ManagedAccountDescriptor;
+    existing: boolean;
+    attestation?: unknown;
+}
+export interface SwivyNodeManagedAccountCreateOptions {
+    label?: string;
+    purpose?: WalletPurpose;
+    custodyMode?: CustodyMode;
+    splitCustody?: {
+        deviceShare: {
+            commitment: string;
+            encryptedPayload?: string;
+            metadata?: Record<string, unknown>;
+        };
+        recoveryShare?: {
+            commitment: string;
+            encryptedPayload?: string;
+            metadata?: Record<string, unknown>;
+        };
+    };
+}
+export interface SwivyNodeExportedAccountPayload {
+    accountId: string;
+    chain: Chain;
+    privateKey: string;
+    attestation: unknown;
+}
+export interface SwivyNodeRawSignPayload {
+    result: ExecutionResult;
+}
+export interface SwivyNodeSigningPayload {
+    accountId: string;
+    chain: Chain;
+    challengeId?: string;
+    payload: Record<string, unknown>;
+}
+export interface SwivyNodeTypedDataSigningPayload {
+    accountId: string;
+    challengeId?: string;
+    typedData: TypedDataDescriptor;
+}
+export interface SwivyNodeSessionKeyPair {
+    curve: "ed25519";
+    publicKeyPem: string;
+    privateKeyPem: string;
+}
+export interface SwivyNodeSessionGrantCreatePayload {
+    accountId: string;
+    publicKey: string;
+    label?: string;
+    challengeId?: string;
+    expiresInSeconds?: number;
+    scope?: Partial<SessionGrantScope>;
+}
+export interface SwivyNodeSessionGrantAuthorization {
+    nonce: string;
+    expiresAt: string;
+    signatureBase64: string;
+}
+export interface SwivyNodeLifiQuotePayload {
+    accountId: string;
+    fromChain: number;
+    toChain: number;
+    fromToken: string;
+    toToken: string;
+    fromAmount: string;
+    requestedValueUsd?: number | null;
+    toAddress?: string;
+    slippage?: number;
+    allowBridges?: string[];
+    denyBridges?: string[];
+    allowExchanges?: string[];
+    denyExchanges?: string[];
+}
+export interface SwivyNodeJupiterQuotePayload {
+    accountId: string;
+    inputMint: string;
+    outputMint: string;
+    amount: string;
+    requestedValueUsd?: number | null;
+    slippageBps?: number;
+    swapMode?: "ExactIn" | "ExactOut";
+    buildTransaction?: boolean;
+    dynamicComputeUnitLimit?: boolean;
+    dynamicSlippage?: boolean;
+    prioritizationFeeLamports?: number | Record<string, unknown>;
+}
+export type SwivyNodeSwapQuotePayload = (SwivyNodeLifiQuotePayload & {
+    provider: "lifi";
+    buildTransaction?: boolean;
+}) | (SwivyNodeJupiterQuotePayload & {
+    provider: "jupiter";
+});
+export interface SwivyPolymarketClientOptions {
+    host?: string;
+    chain?: PolymarketChain;
+    signatureType?: PolymarketSignatureType;
+    funderAddress?: string;
+    useServerTime?: boolean;
+}
+export interface SwivyPolymarketOrderPayload {
+    accountId: string;
+    accountAddress?: string;
+    tokenId: string;
+    conditionId?: string;
+    side: "buy" | "sell";
+    price: number;
+    size: number;
+    requestedValueUsd?: number | null;
+    orderType?: "GTC" | "GTD" | "FOK" | "FAK";
+    jurisdiction?: string;
+    agent?: boolean;
+    builderCode?: string;
+    metadata?: string;
+    expiration?: number;
+    challengeId?: string;
+    wait?: SwivyNodeWaitForIntentOptions;
+}
+export interface SwivyPolymarketStopLimitPayload {
+    accountId: string;
+    tokenId: string;
+    conditionId?: string;
+    side: "buy" | "sell";
+    triggerPrice: number;
+    triggerDirection: "above" | "below";
+    limitPrice: number;
+    size: number;
+    requestedValueUsd?: number | null;
+    jurisdiction?: string;
+    agent?: boolean;
+    expiresAt?: string | null;
+}
+export interface SwivyPolymarketStopLimitEvaluateResult {
+    triggered: boolean;
+    expired: boolean;
+    stopLimitOrder: Record<string, unknown>;
+    orderPayload: SwivyPolymarketOrderPayload | null;
+}
+export interface SwivyPolymarketOrderPreview {
+    provider: "polymarket";
+    network: "polygon-mainnet";
+    order: {
+        tokenId: string;
+        conditionId: string | null;
+        side: "buy" | "sell";
+        price: number;
+        size: number;
+        requestedValueUsd: number;
+        orderType: "GTC" | "GTD" | "FOK" | "FAK";
+        builderCode: string | null;
+    };
+    execution: {
+        ready: boolean;
+        requiresTypedDataSignature: boolean;
+        hint: string;
+    };
+}
+export type SwivyHyperliquidNetwork = "mainnet" | "testnet";
+export interface SwivyHyperliquidClientOptions {
+    network?: SwivyHyperliquidNetwork;
+    apiUrl?: string;
+    timeoutMs?: number | null;
+}
+export interface SwivyHyperliquidOrderPayload {
+    asset: number;
+    isBuy: boolean;
+    price: string;
+    size: string;
+    reduceOnly?: boolean;
+    tif?: "Gtc" | "Ioc" | "Alo" | "FrontendMarket";
+    grouping?: "na" | "normalTpsl" | "positionTpsl";
+    clientOrderId?: `0x${string}`;
+}
+export interface SwivyHyperliquidPlaceOrderPayload extends SwivyHyperliquidOrderPayload {
+    wallet: AbstractWallet;
+    expiresAfter?: number;
+}
+export interface SwivyHyperliquidSwivyOrderPayload extends SwivyHyperliquidOrderPayload {
+    accountId: string;
+    accountAddress?: string;
+    challengeId?: string;
+    expiresAfter?: number;
+    wait?: SwivyNodeWaitForIntentOptions;
+}
+export interface SwivyHyperliquidOrderPreview {
+    provider: "hyperliquid";
+    network: SwivyHyperliquidNetwork;
+    order: {
+        asset: number;
+        side: "buy" | "sell";
+        price: string;
+        size: string;
+        reduceOnly: boolean;
+        tif: "Gtc" | "Ioc" | "Alo" | "FrontendMarket";
+        grouping: "na" | "normalTpsl" | "positionTpsl";
+        clientOrderId?: string;
+    };
+    execution: {
+        ready: boolean;
+        requiresSwivyWallet: boolean;
+        hint: string;
+    };
+}
+export interface SwivyHyperliquidAccountStatus {
+    provider: "hyperliquid";
+    network: SwivyHyperliquidNetwork;
+    address: `0x${string}`;
+    initialized: boolean;
+    funded: boolean;
+    accountValue: string | null;
+    withdrawable: string | null;
+    marginSummary?: unknown;
+    state?: unknown;
+    next: string;
+    error?: string;
+}
+export declare function buildHyperliquidOrderPreview(order: SwivyHyperliquidOrderPayload, options?: SwivyHyperliquidClientOptions): SwivyHyperliquidOrderPreview;
+export declare function getHyperliquidMids(options?: SwivyHyperliquidClientOptions): Promise<Record<string, string>>;
+export declare function getHyperliquidPerpMarkets(options?: SwivyHyperliquidClientOptions): Promise<unknown>;
+export declare function getHyperliquidAccountStatus(address: string, options?: SwivyHyperliquidClientOptions): Promise<SwivyHyperliquidAccountStatus>;
+export declare function placeHyperliquidOrder(payload: SwivyHyperliquidPlaceOrderPayload, options?: SwivyHyperliquidClientOptions): Promise<{
+    preview: SwivyHyperliquidOrderPreview;
+    response: unknown;
+}>;
+export declare function getPolymarketObservedPriceFromOrderbook(orderbook: unknown): number | null;
+export declare function generateSessionKeyPair(): SwivyNodeSessionKeyPair;
+export declare function createSessionGrantAuthorization(params: {
+    grantId: string;
+    accountId: string;
+    chain: Chain;
+    kind: "sign_message" | "sign_digest" | "sign_typed_data" | "sign_transaction" | "execute_transaction";
+    payload: IntentPayload;
+    privateKeyPem: string;
+    nonce?: string;
+    expiresInSeconds?: number;
+}): SwivyNodeSessionGrantAuthorization;
+export interface SwivyNodeServerWallet {
+    id: string;
+    accountId: string;
+    chain: Chain;
+    address: string;
+    publicKey: string;
+    label: string | null;
+    custodyMode: string;
+    idempotencyKey: string | null;
+    authorizationKeyRequired: boolean;
+    createdAt: string;
+}
+export interface SwivyNodeServerWalletCreateOptions {
+    label?: string;
+    idempotencyKey?: string;
+    /** Ed25519 SPKI PEM. When set, every intent must be signed with the matching private key. */
+    authorizationPublicKeyPem?: string;
+}
+export interface SwivyNodeServerIntentOptions {
+    /** Ed25519 PKCS8 PEM for wallets created with an authorization key. */
+    authorizationPrivateKeyPem?: string;
+}
+/**
+ * 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 declare function verifySwivyWebhookSignature(params: {
+    rawBody: string;
+    signature: string | undefined;
+    secret: string;
+}): boolean;
+export declare class SwivyNodeClient {
+    private readonly config;
+    private sessionToken?;
+    constructor(config: SwivyNodeClientConfig);
+    setSessionToken(token: string): void;
+    clearSessionToken(): void;
+    createOrganization(name: string): Promise<any>;
+    createProject(organizationId: string, name: string): Promise<any>;
+    updateProject(projectId: string, name: string): Promise<any>;
+    createEnvironment(projectId: string, name: string): Promise<any>;
+    updateEnvironment(environmentId: string, name: string): Promise<any>;
+    getOrganizationOverview(organizationId: string): Promise<{
+        overview: OrganizationOverview;
+        capabilities: ChainCapabilities[];
+    }>;
+    listEnvironmentCredentials(environmentId: string): Promise<any>;
+    createEnvironmentCredential(environmentId: string, label?: string): Promise<any>;
+    revokeEnvironmentCredential(environmentId: string, credentialId: string): Promise<any>;
+    rotateWebhookSecret(environmentId: string, webhookId: string): Promise<{
+        webhook: WebhookSecretReveal;
+    }>;
+    listWebhooks(environmentId: string): Promise<{
+        webhooks: WebhookDescriptor[];
+    }>;
+    revokeWebhook(environmentId: string, webhookId: string): Promise<any>;
+    listOrganizationAdminCredentials(organizationId: string): Promise<{
+        organization: {
+            id: string;
+            name: string;
+            slug: string;
+            createdAt: string;
+        };
+        credentials: OrganizationAdminCredentialDescriptor[];
+    }>;
+    createOrganizationAdminCredential(organizationId: string, body?: {
+        label?: string;
+        role?: "owner" | "admin" | "developer" | "viewer";
+    }): Promise<{
+        organization: {
+            id: string;
+            name: string;
+            slug: string;
+            createdAt: string;
+        };
+        credential: OrganizationAdminCredentialDescriptor;
+        adminKey: string;
+    }>;
+    revokeOrganizationAdminCredential(organizationId: string, credentialId: string): Promise<any>;
+    listOrganizationMembers(organizationId: string): Promise<{
+        organization: {
+            id: string;
+            name: string;
+            slug: string;
+            createdAt: string;
+        };
+        members: OrganizationMemberDescriptor[];
+    }>;
+    revokeOrganizationMember(organizationId: string, memberId: string): Promise<any>;
+    updateOrganizationMemberRole(organizationId: string, memberId: string, role: "owner" | "admin" | "developer" | "viewer"): Promise<{
+        organizationId: string;
+        member: OrganizationMemberDescriptor;
+        credentials: OrganizationAdminCredentialDescriptor[];
+    }>;
+    listOrganizationInvites(organizationId: string): Promise<{
+        organization: {
+            id: string;
+            name: string;
+            slug: string;
+            createdAt: string;
+        };
+        invites: OrganizationInviteDescriptor[];
+    }>;
+    createOrganizationInvite(organizationId: string, body: {
+        email: string;
+        role?: "owner" | "admin" | "developer" | "viewer";
+        expiresInHours?: number;
+    }): Promise<{
+        organization: {
+            id: string;
+            name: string;
+            slug: string;
+            createdAt: string;
+        };
+        invite: OrganizationInviteDescriptor;
+        inviteToken: string;
+    }>;
+    revokeOrganizationInvite(organizationId: string, inviteId: string): Promise<any>;
+    acceptOrganizationInvite(inviteId: string, body: {
+        token: string;
+        name?: string;
+        label?: string;
+    }): Promise<{
+        organization: {
+            id: string;
+            name: string;
+            slug: string;
+            createdAt: string;
+        };
+        invite: OrganizationInviteDescriptor;
+        member: OrganizationMemberDescriptor;
+        credential: OrganizationAdminCredentialDescriptor;
+        adminKey: string;
+    }>;
+    updateEnvironmentPolicy(environmentId: string, policy: Record<string, unknown>): Promise<any>;
+    listEnvironmentChainRpcConfigs(environmentId: string): Promise<{
+        chains: EnvironmentChainRpcConfig[];
+    }>;
+    upsertEnvironmentChainRpcConfig(environmentId: string, chain: Chain, config: {
+        network?: string;
+        rpcUrl: string;
+        wsUrl?: string | null;
+        headers?: Array<{
+            name: string;
+            value: string;
+        }>;
+        commitment?: "processed" | "confirmed" | "finalized" | null;
+        skipPreflight?: boolean;
+        maxRetries?: number | null;
+        enabled?: boolean;
+    }): Promise<{
+        chain: EnvironmentChainRpcConfig;
+    }>;
+    requestEmailCode(email: string, externalUserId?: string): Promise<any>;
+    verifyEmailCode(email: string, code: string, externalUserId?: string): Promise<any>;
+    /** Request a primary login code. The environment must enable SMS login. */
+    requestSmsCode(phoneNumber: string): Promise<{
+        challengeId: string;
+        phoneNumber: string;
+        expiresAt: string;
+    }>;
+    verifySmsCode(challengeId: string, code: string): Promise<any>;
+    getMe(): Promise<any>;
+    claimUsername(username: string): Promise<{
+        identity: IdentityDescriptor;
+    }>;
+    lookupUsername(username: string): Promise<SwivyNodeIdentityLookupPayload>;
+    startTotp(label?: string): Promise<any>;
+    verifyTotp(authMethodId: string, code: string): Promise<any>;
+    createChallenge(authMethodId: string, purpose: string): Promise<any>;
+    verifyChallenge(challengeId: string, payload: Record<string, unknown>): Promise<any>;
+    createManagedAccount(chain: Chain, options?: string | SwivyNodeManagedAccountCreateOptions): Promise<any>;
+    listAccounts(): Promise<SwivyNodeListAccountsPayload>;
+    listWalletTools(): Promise<any>;
+    createLifiQuote(body: SwivyNodeLifiQuotePayload): Promise<any>;
+    createJupiterQuote(body: SwivyNodeJupiterQuotePayload): Promise<any>;
+    listPolymarketMarkets(nextCursor?: string): Promise<any>;
+    getPolymarketOrderbook(tokenId: string): Promise<any>;
+    previewPolymarketOrder(body: SwivyPolymarketOrderPayload): Promise<any>;
+    createPolymarketStopLimitOrder(body: SwivyPolymarketStopLimitPayload): Promise<any>;
+    listPolymarketStopLimitOrders(status?: "active" | "triggered" | "cancelled" | "expired" | "all"): Promise<any>;
+    cancelPolymarketStopLimitOrder(orderId: string): Promise<any>;
+    evaluatePolymarketStopLimitOrder(orderId: string, body: {
+        observedPrice: number;
+        triggeredOrderId?: string;
+    }): Promise<SwivyPolymarketStopLimitEvaluateResult>;
+    createSwapQuote(body: SwivyNodeSwapQuotePayload): Promise<any>;
+    getHyperliquidMids(options?: SwivyHyperliquidClientOptions): Promise<Record<string, string>>;
+    createOrDerivePolymarketApiKeyWithSwivyWallet(payload: {
+        accountId: string;
+        accountAddress: string;
+        nonce?: number;
+        challengeId?: string;
+        wait?: SwivyNodeWaitForIntentOptions;
+    }, options?: SwivyPolymarketClientOptions): Promise<PolymarketApiKeyCreds>;
+    placePolymarketOrderWithSwivyWallet(payload: SwivyPolymarketOrderPayload & {
+        apiCreds: PolymarketApiKeyCreds;
+        postOnly?: boolean;
+        deferExec?: boolean;
+    }, options?: SwivyPolymarketClientOptions): Promise<{
+        preview: SwivyPolymarketOrderPreview;
+        signedOrder: unknown;
+        response: unknown;
+    }>;
+    evaluateAndPlacePolymarketStopLimitOrder(stopLimitOrder: SwivyPolymarketStopLimitPayload & {
+        id: string;
+        accountAddress: string;
+        apiCreds: PolymarketApiKeyCreds;
+        challengeId?: string;
+        builderCode?: string;
+        metadata?: string;
+        expiration?: number;
+        wait?: SwivyNodeWaitForIntentOptions;
+    }, options?: SwivyPolymarketClientOptions): Promise<{
+        observedPrice: number;
+        triggered: boolean;
+        evaluation: SwivyPolymarketStopLimitEvaluateResult;
+        order?: Awaited<ReturnType<SwivyNodeClient["placePolymarketOrderWithSwivyWallet"]>>;
+    }>;
+    getHyperliquidPerpMarkets(options?: SwivyHyperliquidClientOptions): Promise<unknown>;
+    getHyperliquidAccountStatus(address: string, options?: SwivyHyperliquidClientOptions): Promise<SwivyHyperliquidAccountStatus>;
+    buildHyperliquidOrderPreview(order: SwivyHyperliquidOrderPayload, options?: SwivyHyperliquidClientOptions): SwivyHyperliquidOrderPreview;
+    placeHyperliquidOrder(payload: SwivyHyperliquidPlaceOrderPayload, options?: SwivyHyperliquidClientOptions): Promise<{
+        preview: SwivyHyperliquidOrderPreview;
+        response: unknown;
+    }>;
+    placeHyperliquidOrderWithSwivyWallet(payload: SwivyHyperliquidSwivyOrderPayload, options?: SwivyHyperliquidClientOptions): Promise<{
+        preview: SwivyHyperliquidOrderPreview;
+        response: unknown;
+    }>;
+    listEmbeddedWallets(): Promise<ManagedAccountDescriptor[]>;
+    getManagedAccount(chain: Chain, options?: {
+        purpose?: WalletPurpose;
+    }): Promise<ManagedAccountDescriptor | null>;
+    getEmbeddedWallet(chain: Chain): Promise<ManagedAccountDescriptor | null>;
+    ensureManagedAccount(chain: Chain, options?: string | SwivyNodeManagedAccountCreateOptions): Promise<SwivyNodeManagedAccountResolution>;
+    ensureEmbeddedWallet(chain: Chain, options?: string | SwivyNodeManagedAccountCreateOptions): Promise<SwivyNodeManagedAccountResolution>;
+    linkWallet(body: Record<string, unknown>): Promise<any>;
+    createSigningIntent(body: Record<string, unknown>): Promise<any>;
+    createTransactionIntent(body: Record<string, unknown>): Promise<any>;
+    getIntent(intentId: string): Promise<any>;
+    waitForIntent(intentId: string, options?: SwivyNodeWaitForIntentOptions): Promise<TransactionIntent>;
+    createSigningIntentAndWait(body: Record<string, unknown>, options?: SwivyNodeWaitForIntentOptions): Promise<TransactionIntent>;
+    signMessageAndWait(body: SwivyNodeSigningPayload & {
+        payload: {
+            message?: string;
+            messageHex?: string;
+            messageBase64?: string;
+        };
+    }, options?: SwivyNodeWaitForIntentOptions): Promise<TransactionIntent>;
+    signTypedDataAndWait(body: SwivyNodeTypedDataSigningPayload, options?: SwivyNodeWaitForIntentOptions): Promise<TransactionIntent>;
+    signTransactionAndWait(body: SwivyNodeSigningPayload & {
+        payload: {
+            transaction?: Record<string, unknown>;
+            serializedTransactionBase64?: string;
+        };
+    }, options?: SwivyNodeWaitForIntentOptions): Promise<TransactionIntent>;
+    createTransactionIntentAndWait(body: Record<string, unknown>, options?: SwivyNodeWaitForIntentOptions): Promise<TransactionIntent>;
+    executeTransactionAndWait(body: Record<string, unknown>, options?: SwivyNodeWaitForIntentOptions): Promise<TransactionIntent>;
+    exportManagedAccount(accountId: string, challengeId: string): Promise<SwivyNodeExportedAccountPayload>;
+    rawSign(accountId: string, challengeId: string, payload: Record<string, unknown>): Promise<SwivyNodeRawSignPayload>;
+    getAccountCustody(accountId: string): Promise<any>;
+    enableSplitCustody(accountId: string, splitCustody: NonNullable<SwivyNodeManagedAccountCreateOptions["splitCustody"]>): Promise<any>;
+    createSessionGrant(body: SwivyNodeSessionGrantCreatePayload): Promise<{
+        sessionGrant: SessionGrantDescriptor;
+    }>;
+    listSessionGrants(): Promise<{
+        sessionGrants: SessionGrantDescriptor[];
+    }>;
+    revokeSessionGrant(grantId: string): Promise<{
+        sessionGrant: SessionGrantDescriptor;
+    }>;
+    createSigningIntentWithSessionGrant(grant: SessionGrantDescriptor, privateKeyPem: string, payload: IntentPayload): Promise<{
+        intent: TransactionIntent;
+    }>;
+    createTransactionIntentWithSessionGrant(grant: SessionGrantDescriptor, privateKeyPem: string, payload: IntentPayload): Promise<{
+        intent: TransactionIntent;
+    }>;
+    createServerWallet(chain: Chain, options?: SwivyNodeServerWalletCreateOptions): Promise<{
+        wallet: SwivyNodeServerWallet;
+        existing: boolean;
+    }>;
+    listServerWallets(): Promise<{
+        wallets: SwivyNodeServerWallet[];
+    }>;
+    getServerWallet(walletId: string): Promise<{
+        wallet: SwivyNodeServerWallet;
+    }>;
+    createServerWalletSigningIntent(wallet: Pick<SwivyNodeServerWallet, "id" | "accountId" | "chain">, payload: IntentPayload, options?: SwivyNodeServerIntentOptions): Promise<{
+        intent: TransactionIntent;
+    }>;
+    createServerWalletTransactionIntent(wallet: Pick<SwivyNodeServerWallet, "id" | "accountId" | "chain">, payload: IntentPayload, options?: SwivyNodeServerIntentOptions): Promise<{
+        intent: TransactionIntent;
+    }>;
+    getServerWalletIntent(walletId: string, intentId: string): Promise<{
+        intent: TransactionIntent;
+    }>;
+    getUser(userId: string): Promise<any>;
+    getUserByEmail(email: string): Promise<any>;
+    /** Create (or find by email) a user and optionally give it wallets before first login. */
+    createUser(email: string, options?: {
+        externalUserId?: string;
+        createWallets?: Chain[];
+    }): Promise<any>;
+    createUserWallet(userId: string, chain: Chain, label?: string): Promise<any>;
+    listUsers(options?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<any>;
+    /** Remove a user's personal data and access. Their wallets are kept. */
+    deleteUser(userId: string): Promise<{
+        deleted: boolean;
+        userId: string;
+    }>;
+    /** Server-side check of a user's session token (Privy verifyAccessToken equivalent). */
+    verifySessionToken(sessionToken: string): Promise<{
+        session: {
+            id: string;
+            userId: string;
+            environmentId: string;
+            createdAt: string;
+            expiresAt: string;
+        };
+    }>;
+    listWebhookDeliveries(options?: {
+        status?: "pending" | "delivering" | "delivered" | "failed";
+        limit?: number;
+    }): Promise<any>;
+    replayWebhookDelivery(deliveryId: string): Promise<any>;
+    private request;
+    private delay;
+}