@graphitti/privy-core 0.1.0

package/dist/privy-client.js

@@ -0,0 +1,133 @@
+const PRIVY_API = "https://api.privy.io";
+function basicAuthHeader(appId, appSecret) {
+    return `Basic ${Buffer.from(`${appId}:${appSecret}`).toString("base64")}`;
+}
+export async function privyFetch(path, credentials, init = {}) {
+    const appId = credentials.PRIVY_APP_ID?.trim();
+    const appSecret = credentials.PRIVY_APP_SECRET?.trim();
+    if (!(appId && appSecret)) {
+        throw new Error("PRIVY_APP_ID and PRIVY_APP_SECRET must be configured.");
+    }
+    const headers = {
+        Authorization: basicAuthHeader(appId, appSecret),
+        "privy-app-id": appId,
+        "Content-Type": "application/json",
+        ...init.headers,
+    };
+    if (credentials.PRIVY_AUTHORIZATION_KEY?.trim()) {
+        headers["privy-authorization-key"] = credentials.PRIVY_AUTHORIZATION_KEY.trim();
+    }
+    const response = await fetch(`${PRIVY_API}${path}`, { ...init, headers });
+    const text = await response.text();
+    let body = {};
+    if (text) {
+        try {
+            body = JSON.parse(text);
+        }
+        catch {
+            body = { message: text };
+        }
+    }
+    if (!response.ok) {
+        const message = typeof body === "object" &&
+            body &&
+            "error" in body &&
+            typeof body.error === "string"
+            ? body.error
+            : typeof body === "object" &&
+                body &&
+                "message" in body &&
+                typeof body.message === "string"
+                ? body.message
+                : `Privy HTTP ${response.status}`;
+        throw new Error(message);
+    }
+    return body;
+}
+export async function getPrivyUser(privyUserId, credentials) {
+    return privyFetch(`/v1/users/${encodeURIComponent(privyUserId)}`, credentials);
+}
+export async function searchPrivyUsers(query, credentials) {
+    const params = new URLSearchParams({ search: query, limit: "20" });
+    return privyFetch(`/v1/users?${params}`, credentials);
+}
+export async function listPrivyWallets(credentials) {
+    return privyFetch("/v1/wallets", credentials);
+}
+export async function createPrivyWallet(credentials, chainType = "ethereum") {
+    return privyFetch("/v1/wallets", credentials, {
+        method: "POST",
+        body: JSON.stringify({ chain_type: chainType }),
+    });
+}
+export async function getPrivyWallet(walletId, credentials) {
+    return privyFetch(`/v1/wallets/${walletId}`, credentials);
+}
+export async function getPrivyWalletByAddress(address, credentials) {
+    const params = new URLSearchParams({ address });
+    return privyFetch(`/v1/wallets?${params}`, credentials);
+}
+export async function getPrivyWalletBalance(walletId, credentials, asset = "eth") {
+    return privyFetch(`/v1/wallets/${walletId}/balance?asset=${encodeURIComponent(asset)}`, credentials);
+}
+export async function getPrivyWalletTransaction(walletId, transactionId, credentials) {
+    return privyFetch(`/v1/wallets/${walletId}/transactions/${transactionId}`, credentials);
+}
+export async function createPrivyKeyQuorum(credentials, input) {
+    return privyFetch("/v1/key_quorums", credentials, {
+        method: "POST",
+        body: JSON.stringify({
+            display_name: input.displayName,
+            authorization_threshold: input.authorizationThreshold,
+            user_ids: input.userIds,
+            public_keys: input.publicKeys,
+            key_quorum_ids: input.keyQuorumIds,
+        }),
+    });
+}
+export async function getPrivyKeyQuorum(quorumId, credentials) {
+    return privyFetch(`/v1/key_quorums/${encodeURIComponent(quorumId)}`, credentials);
+}
+export async function createPrivyPolicy(credentials, input) {
+    return privyFetch("/v1/policies", credentials, {
+        method: "POST",
+        body: JSON.stringify({
+            version: "1.0",
+            name: input.name,
+            chain_type: input.chainType ?? "ethereum",
+            rules: input.rules,
+            owner_id: input.ownerId,
+        }),
+    });
+}
+export async function getPrivyPolicy(policyId, credentials) {
+    return privyFetch(`/v1/policies/${encodeURIComponent(policyId)}`, credentials);
+}
+export async function privyWalletTransfer(walletId, body, credentials) {
+    return privyFetch(`/v1/wallets/${walletId}/transfer`, credentials, {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+}
+export async function privyWalletSwap(walletId, body, credentials) {
+    return privyFetch(`/v1/wallets/${walletId}/swap`, credentials, {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+}
+export async function createPrivyTransferIntent(walletId, body, credentials) {
+    return privyFetch(`/v1/intents/wallets/${walletId}/transfer`, credentials, { method: "POST", body: JSON.stringify(body) });
+}
+export async function createPrivyRpcIntent(walletId, body, credentials) {
+    return privyFetch(`/v1/intents/wallets/${walletId}/rpc`, credentials, { method: "POST", body: JSON.stringify(body) });
+}
+export async function getPrivyIntent(intentId, credentials) {
+    return privyFetch(`/v1/intents/${intentId}`, credentials);
+}
+export async function listPrivyIntents(credentials, walletId) {
+    const params = walletId ? `?wallet_id=${encodeURIComponent(walletId)}` : "";
+    return privyFetch(`/v1/intents${params}`, credentials);
+}
+export async function walletRpc(walletId, body, credentials) {
+    return privyFetch(`/v1/wallets/${walletId}/rpc`, credentials, { method: "POST", body: JSON.stringify(body) });
+}

package/dist/privy-signer.d.ts

@@ -0,0 +1,30 @@
+import { type SupportedChain } from "./chains.js";
+import type { PrivyCredentials } from "./types.js";
+export declare function sendSponsoredTransaction(input: {
+    walletId: string;
+    chain: SupportedChain;
+    to: string;
+    data?: string;
+    value?: string;
+    credentials: PrivyCredentials;
+    sponsor?: boolean;
+}): Promise<{
+    hash: string;
+    gasMode: string;
+}>;
+export declare function personalSign(input: {
+    walletId: string;
+    message: string;
+    chain: SupportedChain;
+    credentials: PrivyCredentials;
+}): Promise<{
+    signature: string;
+}>;
+export declare function signTypedDataV4(input: {
+    walletId: string;
+    typedData: unknown;
+    chain: SupportedChain;
+    credentials: PrivyCredentials;
+}): Promise<{
+    signature: string;
+}>;

package/dist/privy-signer.js

@@ -0,0 +1,45 @@
+import { toCaip2 } from "./chains.js";
+import { walletRpc } from "./privy-client.js";
+export async function sendSponsoredTransaction(input) {
+    const result = await walletRpc(input.walletId, {
+        method: "eth_sendTransaction",
+        caip2: toCaip2(input.chain),
+        sponsor: input.sponsor ?? true,
+        params: {
+            transaction: {
+                to: input.to,
+                value: input.value ?? "0x0",
+                data: input.data ?? "0x",
+            },
+        },
+    }, input.credentials);
+    const hash = result.data?.hash || result.data?.user_operation_hash;
+    if (typeof hash !== "string" || !hash) {
+        throw new Error("Privy did not return a transaction hash");
+    }
+    return { hash, gasMode: input.sponsor === false ? "user-pays" : "app-pays" };
+}
+export async function personalSign(input) {
+    const result = await walletRpc(input.walletId, {
+        method: "personal_sign",
+        caip2: toCaip2(input.chain),
+        params: { message: input.message, encoding: "utf-8" },
+    }, input.credentials);
+    const signature = result.data?.signature;
+    if (typeof signature !== "string" || !signature) {
+        throw new Error("Privy did not return a signature");
+    }
+    return { signature };
+}
+export async function signTypedDataV4(input) {
+    const result = await walletRpc(input.walletId, {
+        method: "eth_signTypedData_v4",
+        caip2: toCaip2(input.chain),
+        params: { typed_data: input.typedData },
+    }, input.credentials);
+    const signature = result.data?.signature;
+    if (typeof signature !== "string" || !signature) {
+        throw new Error("Privy did not return a signature");
+    }
+    return { signature };
+}

package/dist/shared.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteParams } from "./types.js";
+export declare function strParam(params: ExecuteParams, key: string): string | undefined;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/shared.js

@@ -0,0 +1,17 @@
+export function strParam(params, key) {
+    const snake = params[key];
+    if (typeof snake === "string" && snake.trim()) {
+        return snake.trim();
+    }
+    const camel = params[camelCase(key)];
+    if (typeof camel === "string" && camel.trim()) {
+        return camel.trim();
+    }
+    return undefined;
+}
+function camelCase(key) {
+    return key.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/types.d.ts

@@ -0,0 +1,24 @@
+export type PrivyCredentials = {
+    PRIVY_APP_ID?: string;
+    PRIVY_APP_SECRET?: string;
+    PRIVY_AUTHORIZATION_KEY?: string;
+    GRAPHITTI_BASE_URL?: string;
+    GRAPHITTI_API_KEY?: string;
+};
+export type ToolResult = {
+    success: true;
+    data: Record<string, unknown>;
+} | {
+    success: false;
+    error: string;
+};
+export type PrivyToolDefinition = {
+    name: string;
+    description: string;
+    category: "users" | "wallets" | "sign" | "controls" | "intents" | "graphitti";
+    optional?: boolean;
+    requiresGraphittiKey?: boolean;
+    requiresTreasuryScope?: boolean;
+    parameters: Record<string, unknown>;
+};
+export type ExecuteParams = Record<string, unknown>;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@graphitti/privy-core",
+  "version": "0.1.0",
+  "description": "Shared Privy wallet and treasury tool catalog and MCP stdio server for agent plugins",
+  "type": "module",
+  "license": "Apache-2.0",
+  "author": "Graphitti",
+  "keywords": [
+    "privy",
+    "wallet",
+    "treasury",
+    "mcp",
+    "agent",
+    "web3"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Bleyle823/Graphitti.git",
+    "directory": "ecosystem-agent-plugins/privy/privy-core"
+  },
+  "bugs": {
+    "url": "https://github.com/Bleyle823/Graphitti/issues"
+  },
+  "homepage": "https://github.com/Bleyle823/Graphitti/tree/main/ecosystem-agent-plugins/privy/privy-core#readme",
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./mcp": {
+      "types": "./dist/mcp-server.d.ts",
+      "import": "./dist/mcp-server.js"
+    }
+  },
+  "bin": {
+    "privy-mcp": "./dist/mcp-server.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "pnpm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.7.2",
+    "vitest": "^3.0.5"
+  }
+}