@openfort/openfort-node 0.9.2 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfort/openfort-node",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "description": "Openfort Node SDK",
   "author": "Openfort",
   "repository": {
@@ -40,24 +40,29 @@
   },
   "dependencies": {
     "@openfort/shield-js": "^0.1.35",
-    "@types/node": "^25.3.2",
-    "@types/node-fetch": "^2.6.13",
     "axios": "^1.13.6",
     "axios-retry": "^4.5.0",
     "bs58": "^6.0.0",
     "jose": "^5.10.0",
     "node-fetch": "^2.7.0",
-    "viem": "^2.46.3",
     "zod": "^3.25.76"
   },
   "simple-git-hooks": {
     "pre-commit": "pnpm check"
   },
   "devDependencies": {
+    "@types/node": "^25.3.2",
+    "@types/node-fetch": "^2.6.13",
     "@arethetypeswrong/cli": "^0.18.2",
     "@biomejs/biome": "^2.4.4",
     "@changesets/changelog-github": "^0.5.2",
     "@changesets/cli": "^2.29.8",
+    "@solana-program/compute-budget": "^0.14.0",
+    "@solana-program/system": "^0.12.0",
+    "@solana-program/token": "^0.12.0",
+    "@solana/kit": "^6.1.0",
+    "@solana/kora": "^0.1.3",
+    "@solana/transaction-confirmation": "^6.1.0",
     "@vitest/coverage-v8": "^3.2.4",
     "knip": "^5.85.0",
     "orval": "^8.5.1",
@@ -65,8 +70,41 @@
     "simple-git-hooks": "^2.13.1",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
+    "viem": "^2.46.3",
     "vitest": "^3.2.4"
   },
+  "peerDependencies": {
+    "@solana-program/compute-budget": ">=0.7.0",
+    "@solana-program/system": ">=0.7.0",
+    "@solana-program/token": ">=0.7.0",
+    "@solana/kit": ">=6.0.0",
+    "@solana/kora": ">=0.1.0",
+    "@solana/transaction-confirmation": ">=6.0.0",
+    "viem": ">=2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@solana/kit": {
+      "optional": true
+    },
+    "@solana-program/compute-budget": {
+      "optional": true
+    },
+    "@solana-program/system": {
+      "optional": true
+    },
+    "@solana-program/token": {
+      "optional": true
+    },
+    "@solana/kora": {
+      "optional": true
+    },
+    "@solana/transaction-confirmation": {
+      "optional": true
+    },
+    "viem": {
+      "optional": true
+    }
+  },
   "scripts": {
     "prebuild": "node -p \"'export const VERSION = ' + JSON.stringify(require('./package.json').version) + ';\\nexport const PACKAGE = ' + JSON.stringify(require('./package.json').name) + ';'\" > src/version.ts",
     "build": "tsup",

package/tsconfig.json

@@ -8,22 +8,21 @@
     "moduleResolution": "bundler",
     "types": ["node"],
     "target": "es2021",
-    "lib": ["es2021", "esnext.disposable", "dom"],
+    "lib": ["es2022", "esnext.disposable", "dom"],
     "typeRoots": ["node_modules/@types", "./typings"],
     "downlevelIteration": true,
-    "experimentalDecorators": true,
     "declaration": true,
     "strictNullChecks": true,
     "newLine": "LF",
     "noUnusedParameters": false,
     "noUnusedLocals": false,
-    "emitDecoratorMetadata": true,
     "noImplicitThis": true,
     "noImplicitReturns": true,
     "noFallthroughCasesInSwitch": true,
     "strictBindCallApply": true,
     "esModuleInterop": true,
-    "resolveJsonModule": true
+    "resolveJsonModule": true,
+    "skipLibCheck": true
   },
   "include": ["src/**/*"],
   "exclude": ["dist", "example"]

package/examples/policies/createAccountPolicy.ts

@@ -1,71 +0,0 @@
-// Usage: npx tsx policies/createAccountPolicy.ts
-//
-// Creates an account-scoped policy (as opposed to project-scoped).
-// Account policies apply only to a specific wallet account.
-
-import Openfort, {
-  CreatePolicyBodySchema,
-  type CreatePolicyBody,
-} from "@openfort/openfort-node";
-import "dotenv/config";
-
-const openfort = new Openfort(process.env.OPENFORT_API_KEY!, {
-  basePath: process.env.OPENFORT_BASE_URL,
-  walletSecret: process.env.OPENFORT_WALLET_SECRET,
-});
-
-// Create an EVM backend wallet to attach the policy to
-const account = await openfort.accounts.evm.backend.create();
-console.log("Created account:", account.id);
-
-// ---------------------------------------------------------------------------
-// Create an account-scoped policy
-// ---------------------------------------------------------------------------
-
-const body: CreatePolicyBody = {
-  scope: "account",
-  accountId: account.id,
-  description: "Account-level allowlist for this specific wallet",
-  enabled: true,
-  priority: 10,
-  rules: [
-    {
-      action: "accept",
-      operation: "signEvmTransaction",
-      criteria: [
-        {
-          type: "evmAddress",
-          operator: "in",
-          addresses: ["0x000000000000000000000000000000000000dEaD"],
-        },
-        {
-          type: "ethValue",
-          operator: "<=",
-          ethValue: "500000000000000000", // 0.5 ETH
-        },
-      ],
-    },
-    {
-      action: "accept",
-      operation: "signEvmMessage",
-      criteria: [
-        {
-          type: "evmMessage",
-          operator: "match",
-          pattern: "^Sign in to",
-        },
-      ],
-    },
-  ],
-};
-
-CreatePolicyBodySchema.parse(body);
-
-const policy = await openfort.policies.create(body);
-
-console.log("\nCreated account-scoped policy:");
-console.log("  ID:", policy.id);
-console.log("  Scope:", policy.scope);
-console.log("  Account:", policy.accountId);
-console.log("  Priority:", policy.priority);
-console.log("  Rules:", policy.rules.length);

package/examples/policies/createEvmPolicy.ts

@@ -1,149 +0,0 @@
-// Usage: npx tsx policies/createEvmPolicy.ts
-//
-// Creates policies that control EVM signing operations.
-// Demonstrates: ethValue limits, address allowlists, network restrictions,
-// and combined criteria.
-
-import Openfort, {
-  CreatePolicyBodySchema,
-  type CreatePolicyBody,
-} from "@openfort/openfort-node";
-import "dotenv/config";
-
-const openfort = new Openfort(process.env.OPENFORT_API_KEY!, {
-  basePath: process.env.OPENFORT_BASE_URL,
-});
-
-// ---------------------------------------------------------------------------
-// 1. Reject high-value EVM transactions (> 1 ETH)
-// ---------------------------------------------------------------------------
-
-const highValueBody: CreatePolicyBody = {
-  scope: "project",
-  description: "Reject transactions above 1 ETH",
-  rules: [
-    {
-      action: "reject",
-      operation: "signEvmTransaction",
-      criteria: [
-        {
-          type: "ethValue",
-          operator: ">",
-          ethValue: "1000000000000000000", // 1 ETH in wei
-        },
-      ],
-    },
-  ],
-};
-
-// Validate with Zod before sending
-CreatePolicyBodySchema.parse(highValueBody);
-
-const highValuePolicy = await openfort.policies.create(highValueBody);
-console.log("Created high-value rejection policy:");
-console.log("  ID:", highValuePolicy.id);
-console.log("  Scope:", highValuePolicy.scope);
-console.log("  Rules:", highValuePolicy.rules.length);
-
-// ---------------------------------------------------------------------------
-// 2. Address allowlist — only allow transactions to known addresses
-// ---------------------------------------------------------------------------
-
-const allowlistBody: CreatePolicyBody = {
-  scope: "project",
-  description: "Only allow transfers to treasury and vault",
-  rules: [
-    {
-      action: "accept",
-      operation: "sendEvmTransaction",
-      criteria: [
-        {
-          type: "evmAddress",
-          operator: "in",
-          addresses: [
-            "0x000000000000000000000000000000000000dEaD",
-            "0x1234567890abcdef1234567890abcdef12345678",
-          ],
-        },
-        {
-          type: "evmNetwork",
-          operator: "in",
-          chainIds: [1, 137, 8453], // Ethereum, Polygon, Base
-        },
-      ],
-    },
-  ],
-};
-
-CreatePolicyBodySchema.parse(allowlistBody);
-
-const allowlistPolicy = await openfort.policies.create(allowlistBody);
-console.log("\nCreated address allowlist policy:");
-console.log("  ID:", allowlistPolicy.id);
-
-// ---------------------------------------------------------------------------
-// 3. Restrict EVM contract calls by ABI function
-// ---------------------------------------------------------------------------
-
-const dataBody: CreatePolicyBody = {
-  scope: "project",
-  description: "Only allow ERC-20 transfer calls",
-  rules: [
-    {
-      action: "accept",
-      operation: "signEvmTransaction",
-      criteria: [
-        {
-          type: "evmData",
-          operator: "==",
-          abi: '[{"type":"function","name":"transfer","inputs":[{"name":"to","type":"address"},{"name":"amount","type":"uint256"}],"outputs":[{"type":"bool"}]}]',
-          functionName: "transfer",
-        },
-      ],
-    },
-  ],
-};
-
-CreatePolicyBodySchema.parse(dataBody);
-
-const dataPolicy = await openfort.policies.create(dataBody);
-console.log("\nCreated ERC-20 transfer-only policy:");
-console.log("  ID:", dataPolicy.id);
-
-// ---------------------------------------------------------------------------
-// 4. Combined: value cap + address allowlist + network restriction
-// ---------------------------------------------------------------------------
-
-const combinedBody: CreatePolicyBody = {
-  scope: "project",
-  description: "Accept low-value sends to known addresses on mainnet only",
-  rules: [
-    {
-      action: "accept",
-      operation: "sendEvmTransaction",
-      criteria: [
-        {
-          type: "ethValue",
-          operator: "<=",
-          ethValue: "500000000000000000", // 0.5 ETH
-        },
-        {
-          type: "evmAddress",
-          operator: "in",
-          addresses: ["0x000000000000000000000000000000000000dEaD"],
-        },
-        {
-          type: "evmNetwork",
-          operator: "in",
-          chainIds: [1], // Ethereum mainnet only
-        },
-      ],
-    },
-  ],
-};
-
-CreatePolicyBodySchema.parse(combinedBody);
-
-const combinedPolicy = await openfort.policies.create(combinedBody);
-console.log("\nCreated combined EVM policy:");
-console.log("  ID:", combinedPolicy.id);

package/examples/policies/createSolanaPolicy.ts

@@ -1,176 +0,0 @@
-// Usage: npx tsx policies/createSolanaPolicy.ts
-//
-// Creates policies that control Solana signing operations.
-// Demonstrates: SOL value limits, address allowlists, SPL token criteria,
-// program ID restrictions, and Solana network constraints.
-
-import Openfort, {
-  CreatePolicyBodySchema,
-  type CreatePolicyBody,
-} from "@openfort/openfort-node";
-import "dotenv/config";
-
-const openfort = new Openfort(process.env.OPENFORT_API_KEY!, {
-  basePath: process.env.OPENFORT_BASE_URL,
-});
-
-// ---------------------------------------------------------------------------
-// 1. Reject high-value SOL transfers (> 10 SOL)
-// ---------------------------------------------------------------------------
-
-const solValueBody: CreatePolicyBody = {
-  scope: "project",
-  description: "Reject SOL transfers above 10 SOL",
-  rules: [
-    {
-      action: "reject",
-      operation: "signSolTransaction",
-      criteria: [
-        {
-          type: "solValue",
-          operator: ">=",
-          value: "10000000000", // 10 SOL in lamports
-        },
-      ],
-    },
-  ],
-};
-
-CreatePolicyBodySchema.parse(solValueBody);
-
-const solValuePolicy = await openfort.policies.create(solValueBody);
-console.log("Created SOL value limit policy:");
-console.log("  ID:", solValuePolicy.id);
-
-// ---------------------------------------------------------------------------
-// 2. SOL address allowlist
-// ---------------------------------------------------------------------------
-
-const addressBody: CreatePolicyBody = {
-  scope: "project",
-  description: "Only allow transfers to known Solana addresses",
-  rules: [
-    {
-      action: "accept",
-      operation: "sendSolTransaction",
-      criteria: [
-        {
-          type: "solAddress",
-          operator: "in",
-          addresses: [
-            "DtdSSG8ZJRZVv5Jx7K1MeWp7Zxcu19GD5wQRGRpQ9uMF",
-            "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d",
-          ],
-        },
-      ],
-    },
-  ],
-};
-
-CreatePolicyBodySchema.parse(addressBody);
-
-const addressPolicy = await openfort.policies.create(addressBody);
-console.log("\nCreated SOL address allowlist policy:");
-console.log("  ID:", addressPolicy.id);
-
-// ---------------------------------------------------------------------------
-// 3. SPL token transfer restrictions (e.g. USDC mint)
-// ---------------------------------------------------------------------------
-
-const splBody: CreatePolicyBody = {
-  scope: "project",
-  description: "Restrict SPL transfers to specific USDC mint and recipients",
-  rules: [
-    {
-      action: "accept",
-      operation: "signSolTransaction",
-      criteria: [
-        {
-          type: "mintAddress",
-          operator: "==",
-          addresses: ["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"], // USDC
-        },
-        {
-          type: "splAddress",
-          operator: "in",
-          addresses: ["DtdSSG8ZJRZVv5Jx7K1MeWp7Zxcu19GD5wQRGRpQ9uMF"],
-        },
-        {
-          type: "splValue",
-          operator: "<=",
-          value: "1000000000", // 1000 USDC (6 decimals)
-        },
-      ],
-    },
-  ],
-};
-
-CreatePolicyBodySchema.parse(splBody);
-
-const splPolicy = await openfort.policies.create(splBody);
-console.log("\nCreated SPL token policy:");
-console.log("  ID:", splPolicy.id);
-
-// ---------------------------------------------------------------------------
-// 4. Program ID restriction with network constraint
-// ---------------------------------------------------------------------------
-
-const programBody: CreatePolicyBody = {
-  scope: "project",
-  description: "Only allow interactions with specific programs on mainnet",
-  rules: [
-    {
-      action: "accept",
-      operation: "sendSolTransaction",
-      criteria: [
-        {
-          type: "programId",
-          operator: "in",
-          programIds: [
-            "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", // Token Program
-            "11111111111111111111111111111111", // System Program
-          ],
-        },
-        {
-          type: "solNetwork",
-          operator: "in",
-          networks: ["mainnet-beta"],
-        },
-      ],
-    },
-  ],
-};
-
-CreatePolicyBodySchema.parse(programBody);
-
-const programPolicy = await openfort.policies.create(programBody);
-console.log("\nCreated program ID + network policy:");
-console.log("  ID:", programPolicy.id);
-
-// ---------------------------------------------------------------------------
-// 5. Sign Solana message — restrict to matching pattern
-// ---------------------------------------------------------------------------
-
-const messageBody: CreatePolicyBody = {
-  scope: "project",
-  description: "Only allow signing messages that match a known format",
-  rules: [
-    {
-      action: "accept",
-      operation: "signSolMessage",
-      criteria: [
-        {
-          type: "solMessage",
-          operator: "match",
-          pattern: "^Sign in to MyApp:",
-        },
-      ],
-    },
-  ],
-};
-
-CreatePolicyBodySchema.parse(messageBody);
-
-const messagePolicy = await openfort.policies.create(messageBody);
-console.log("\nCreated Solana message policy:");
-console.log("  ID:", messagePolicy.id);

package/examples/policies/createTypedDataPolicy.ts

@@ -1,159 +0,0 @@
-// Usage: npx tsx policies/createTypedDataPolicy.ts
-//
-// Creates policies for EVM typed-data signing (EIP-712) and message signing
-// operations.
-
-import Openfort, {
-  CreatePolicyBodySchema,
-  type CreatePolicyBody,
-} from "@openfort/openfort-node";
-import "dotenv/config";
-
-const openfort = new Openfort(process.env.OPENFORT_API_KEY!, {
-  basePath: process.env.OPENFORT_BASE_URL,
-});
-
-// ---------------------------------------------------------------------------
-// 1. Restrict typed-data signing to specific verifying contracts
-// ---------------------------------------------------------------------------
-
-const verifyingContractBody: CreatePolicyBody = {
-  scope: "project",
-  description: "Only allow signing typed data from known contracts",
-  rules: [
-    {
-      action: "accept",
-      operation: "signEvmTypedData",
-      criteria: [
-        {
-          type: "evmTypedDataVerifyingContract",
-          operator: "in",
-          addresses: [
-            "0x000000000000000000000000000000000000dEaD",
-            "0x1234567890abcdef1234567890abcdef12345678",
-          ],
-        },
-      ],
-    },
-  ],
-};
-
-CreatePolicyBodySchema.parse(verifyingContractBody);
-
-const verifyingPolicy = await openfort.policies.create(
-  verifyingContractBody,
-);
-console.log("Created verifying-contract typed-data policy:");
-console.log("  ID:", verifyingPolicy.id);
-
-// ---------------------------------------------------------------------------
-// 2. Restrict typed-data field values (e.g. limit order amount)
-// ---------------------------------------------------------------------------
-
-const fieldBody: CreatePolicyBody = {
-  scope: "project",
-  description: "Restrict Order.amount to known values",
-  rules: [
-    {
-      action: "accept",
-      operation: "signEvmTypedData",
-      criteria: [
-        {
-          type: "evmTypedDataField",
-          operator: "in",
-          fieldPath: "Order.amount",
-          values: ["100", "200", "500"],
-        },
-      ],
-    },
-  ],
-};
-
-CreatePolicyBodySchema.parse(fieldBody);
-
-const fieldPolicy = await openfort.policies.create(fieldBody);
-console.log("\nCreated typed-data field restriction policy:");
-console.log("  ID:", fieldPolicy.id);
-
-// ---------------------------------------------------------------------------
-// 3. Combined: verifying contract + field constraint
-// ---------------------------------------------------------------------------
-
-const combinedBody: CreatePolicyBody = {
-  scope: "project",
-  description: "Accept orders from known contract with capped amount",
-  rules: [
-    {
-      action: "accept",
-      operation: "signEvmTypedData",
-      criteria: [
-        {
-          type: "evmTypedDataVerifyingContract",
-          operator: "in",
-          addresses: ["0x000000000000000000000000000000000000dEaD"],
-        },
-        {
-          type: "evmTypedDataField",
-          operator: "<=",
-          fieldPath: "Order.amount",
-          value: "1000",
-        },
-      ],
-    },
-  ],
-};
-
-CreatePolicyBodySchema.parse(combinedBody);
-
-const combinedPolicy = await openfort.policies.create(combinedBody);
-console.log("\nCreated combined typed-data policy:");
-console.log("  ID:", combinedPolicy.id);
-
-// ---------------------------------------------------------------------------
-// 4. EVM message signing — restrict to known pattern
-// ---------------------------------------------------------------------------
-
-const messageBody: CreatePolicyBody = {
-  scope: "project",
-  description: "Only allow signing messages that match the login format",
-  rules: [
-    {
-      action: "accept",
-      operation: "signEvmMessage",
-      criteria: [
-        {
-          type: "evmMessage",
-          operator: "match",
-          pattern: "^Sign in to MyApp: nonce=",
-        },
-      ],
-    },
-  ],
-};
-
-CreatePolicyBodySchema.parse(messageBody);
-
-const messagePolicy = await openfort.policies.create(messageBody);
-console.log("\nCreated EVM message signing policy:");
-console.log("  ID:", messagePolicy.id);
-
-// ---------------------------------------------------------------------------
-// 5. Reject all raw hash signing (no criteria = blanket rule)
-// ---------------------------------------------------------------------------
-
-const hashBody: CreatePolicyBody = {
-  scope: "project",
-  description: "Reject all raw hash signing operations",
-  rules: [
-    {
-      action: "reject",
-      operation: "signEvmHash",
-    },
-  ],
-};
-
-CreatePolicyBodySchema.parse(hashBody);
-
-const hashPolicy = await openfort.policies.create(hashBody);
-console.log("\nCreated hash signing rejection policy:");
-console.log("  ID:", hashPolicy.id);

package/examples/policies/deletePolicy.ts

@@ -1,34 +0,0 @@
-// Usage: npx tsx policies/deletePolicy.ts
-
-import Openfort, {
-  CreatePolicyBodySchema,
-  type CreatePolicyBody,
-} from "@openfort/openfort-node";
-import "dotenv/config";
-
-const openfort = new Openfort(process.env.OPENFORT_API_KEY!, {
-  basePath: process.env.OPENFORT_BASE_URL,
-});
-
-// Create a policy to delete
-const body: CreatePolicyBody = {
-  scope: "project",
-  description: "Temporary policy to be deleted",
-  rules: [
-    {
-      action: "reject",
-      operation: "signEvmHash",
-    },
-  ],
-};
-CreatePolicyBodySchema.parse(body);
-
-const policy = await openfort.policies.create(body);
-console.log("Created policy:", policy.id);
-
-// Delete the policy (soft delete)
-const result = await openfort.policies.delete(policy.id);
-
-console.log("\nDeleted policy:");
-console.log("  ID:", result.id);
-console.log("  Deleted:", result.deleted);