@openfort/openfort-node 0.9.3 → 0.10.0

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);

package/examples/policies/getPolicy.ts

@@ -1,41 +0,0 @@
-// Usage: npx tsx policies/getPolicy.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 first
-const body: CreatePolicyBody = {
-  scope: "project",
-  description: "Test policy to retrieve",
-  rules: [
-    {
-      action: "reject",
-      operation: "signEvmHash",
-    },
-  ],
-};
-CreatePolicyBodySchema.parse(body);
-
-const created = await openfort.policies.create(body);
-console.log("Created policy:", created.id);
-
-// Retrieve the policy by ID
-const policy = await openfort.policies.get(created.id);
-
-console.log("\nRetrieved policy:");
-console.log("  ID:", policy.id);
-console.log("  Scope:", policy.scope);
-console.log("  Description:", policy.description);
-console.log("  Enabled:", policy.enabled);
-console.log("  Priority:", policy.priority);
-console.log("  Rules:");
-for (const rule of policy.rules) {
-  console.log(`    - Action: ${rule.action}, Operation: ${rule.operation}`);
-}

package/examples/policies/listPolicies.ts

@@ -1,34 +0,0 @@
-// Usage: npx tsx policies/listPolicies.ts
-
-import Openfort from "@openfort/openfort-node";
-import "dotenv/config";
-
-const openfort = new Openfort(process.env.OPENFORT_API_KEY!, {
-  basePath: process.env.OPENFORT_BASE_URL,
-});
-
-// List all policies
-const result = await openfort.policies.list({ limit: 10 });
-
-console.log(`Found ${result.total} policies:`);
-for (const policy of result.data) {
-  console.log(`  - ${policy.id}`);
-  console.log(`    Scope: ${policy.scope}`);
-  console.log(`    Description: ${policy.description ?? "(none)"}`);
-  console.log(`    Enabled: ${policy.enabled}`);
-  console.log(`    Rules: ${policy.rules.length}`);
-}
-
-// List only project-scoped policies
-console.log("\nProject-scoped policies:");
-const projectPolicies = await openfort.policies.list({
-  scope: "project",
-});
-console.log(`  Found: ${projectPolicies.total}`);
-
-// List only account-scoped policies
-console.log("\nAccount-scoped policies:");
-const accountPolicies = await openfort.policies.list({
-  scope: "account",
-});
-console.log(`  Found: ${accountPolicies.total}`);

package/examples/policies/multiRulePolicy.ts

@@ -1,133 +0,0 @@
-// Usage: npx tsx policies/multiRulePolicy.ts
-//
-// Creates a comprehensive policy with multiple rules covering different
-// operations (EVM + Solana) in a single policy.
-
-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,
-});
-
-const body: CreatePolicyBody = {
-  scope: "project",
-  description: "Comprehensive cross-chain policy",
-  priority: 100,
-  rules: [
-    // Rule 1: Accept EVM transactions under 1 ETH to known addresses
-    {
-      action: "accept",
-      operation: "signEvmTransaction",
-      criteria: [
-        {
-          type: "ethValue",
-          operator: "<=",
-          ethValue: "1000000000000000000",
-        },
-        {
-          type: "evmAddress",
-          operator: "in",
-          addresses: ["0x000000000000000000000000000000000000dEaD"],
-        },
-      ],
-    },
-
-    // Rule 2: Accept EVM sends on specific networks
-    {
-      action: "accept",
-      operation: "sendEvmTransaction",
-      criteria: [
-        {
-          type: "evmNetwork",
-          operator: "in",
-          chainIds: [1, 137, 8453], // Ethereum, Polygon, Base
-        },
-        {
-          type: "ethValue",
-          operator: "<=",
-          ethValue: "500000000000000000",
-        },
-      ],
-    },
-
-    // Rule 3: Accept EVM message signing matching login pattern
-    {
-      action: "accept",
-      operation: "signEvmMessage",
-      criteria: [
-        {
-          type: "evmMessage",
-          operator: "match",
-          pattern: "^Sign in to",
-        },
-      ],
-    },
-
-    // Rule 4: Reject all raw hash signing
-    {
-      action: "reject",
-      operation: "signEvmHash",
-    },
-
-    // Rule 5: Accept SOL transfers under 5 SOL to known addresses
-    {
-      action: "accept",
-      operation: "signSolTransaction",
-      criteria: [
-        {
-          type: "solValue",
-          operator: "<=",
-          value: "5000000000", // 5 SOL
-        },
-        {
-          type: "solAddress",
-          operator: "in",
-          addresses: ["DtdSSG8ZJRZVv5Jx7K1MeWp7Zxcu19GD5wQRGRpQ9uMF"],
-        },
-      ],
-    },
-
-    // Rule 6: Accept Solana sends on mainnet only
-    {
-      action: "accept",
-      operation: "sendSolTransaction",
-      criteria: [
-        {
-          type: "solNetwork",
-          operator: "in",
-          networks: ["mainnet-beta"],
-        },
-      ],
-    },
-
-    // Rule 7: Accept SOL message signing with known prefix
-    {
-      action: "accept",
-      operation: "signSolMessage",
-      criteria: [
-        {
-          type: "solMessage",
-          operator: "match",
-          pattern: "^Verify ownership:",
-        },
-      ],
-    },
-  ],
-};
-
-// Validate locally before sending
-CreatePolicyBodySchema.parse(body);
-
-const policy = await openfort.policies.create(body);
-
-console.log("Created multi-rule policy:");
-console.log("  ID:", policy.id);
-console.log("  Priority:", policy.priority);
-console.log("  Rules:", policy.rules.length);
-for (const rule of policy.rules) {
-  console.log(`    - ${rule.action} ${rule.operation}`);
-}

package/examples/policies/updatePolicy.ts

@@ -1,77 +0,0 @@
-// Usage: npx tsx policies/updatePolicy.ts
-
-import Openfort, {
-  CreatePolicyBodySchema,
-  UpdatePolicyBodySchema,
-  type CreatePolicyBody,
-  type UpdatePolicyBody,
-} 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 first
-const createBody: CreatePolicyBody = {
-  scope: "project",
-  description: "Original policy — reject high-value transactions",
-  rules: [
-    {
-      action: "reject",
-      operation: "signEvmTransaction",
-      criteria: [
-        {
-          type: "ethValue",
-          operator: ">",
-          ethValue: "1000000000000000000", // 1 ETH
-        },
-      ],
-    },
-  ],
-};
-CreatePolicyBodySchema.parse(createBody);
-
-const policy = await openfort.policies.create(createBody);
-console.log("Created policy:", policy.id);
-console.log("  Description:", policy.description);
-
-// ---------------------------------------------------------------------------
-// Update the policy — lower the threshold and add an address denylist
-// ---------------------------------------------------------------------------
-
-const updateBody: UpdatePolicyBody = {
-  description: "Updated — reject high-value or denylist transactions",
-  rules: [
-    {
-      action: "reject",
-      operation: "signEvmTransaction",
-      criteria: [
-        {
-          type: "ethValue",
-          operator: ">",
-          ethValue: "500000000000000000", // 0.5 ETH (lowered)
-        },
-      ],
-    },
-    {
-      action: "reject",
-      operation: "sendEvmTransaction",
-      criteria: [
-        {
-          type: "evmAddress",
-          operator: "in",
-          addresses: ["0x000000000000000000000000000000000000dEaD"],
-        },
-      ],
-    },
-  ],
-};
-UpdatePolicyBodySchema.parse(updateBody);
-
-const updated = await openfort.policies.update(policy.id, updateBody);
-
-console.log("\nUpdated policy:");
-console.log("  ID:", updated.id);
-console.log("  Description:", updated.description);
-console.log("  Rules:", updated.rules.length);