@openfort/openfort-node 0.6.78 → 0.7.0

package/examples/policies/createPolicy.ts

@@ -0,0 +1,25 @@
+// Usage: npx tsx policies/createPolicy.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,
+});
+
+const chainId = Number(process.env.CHAIN_ID) || 80002;
+
+// Create a gas sponsorship policy
+const policy = await openfort.policies.create({
+  name: "Gas Sponsorship Policy",
+  chainId,
+  strategy: {
+    sponsorSchema: "pay_for_user",
+  },
+});
+
+console.log("Created policy:");
+console.log("  ID:", policy.id);
+console.log("  Name:", policy.name);
+console.log("  Chain ID:", policy.chainId);
+console.log("  Strategy:", policy.strategy.sponsorSchema);

package/examples/policies/createPolicyRule.ts

@@ -0,0 +1,43 @@
+// Usage: npx tsx policies/createPolicyRule.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,
+});
+
+const chainId = Number(process.env.CHAIN_ID) || 80002;
+
+// Create a policy first
+const policy = await openfort.policies.create({
+  name: `PolicyWithRules-${Date.now()}`,
+  chainId,
+  strategy: {
+    sponsorSchema: "pay_for_user",
+  },
+});
+console.log("Created policy:", policy.id);
+
+// Create a contract to reference in the rule
+const contract = await openfort.contracts.create({
+  name: "Test Contract",
+  chainId,
+  address: "0x38090d1636069c0ff1af6bc1737fb996b7f63ac0",
+});
+console.log("Created contract:", contract.id);
+
+// Create a policy rule for account functions
+const rule = await openfort.policyRules.create({
+  type: "account_functions",
+  policy: policy.id,
+  functionName: "transfer",
+  contract: contract.id,
+});
+
+console.log("\nCreated policy rule:");
+console.log("  ID:", rule.id);
+console.log("  Type:", rule.type);
+if ("functionName" in rule && rule.functionName) {
+  console.log("  Function:", rule.functionName);
+}

package/examples/policies/disableEnablePolicy.ts

@@ -0,0 +1,29 @@
+// Usage: npx tsx policies/disableEnablePolicy.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,
+});
+
+const chainId = Number(process.env.CHAIN_ID) || 80002;
+
+// Create a policy first
+const policy = await openfort.policies.create({
+  name: `TogglePolicy-${Date.now()}`,
+  chainId,
+  strategy: {
+    sponsorSchema: "pay_for_user",
+  },
+});
+console.log("Created policy:", policy.id);
+console.log("Initial state - Enabled:", policy.enabled);
+
+// Disable the policy
+const disabled = await openfort.policies.disable(policy.id);
+console.log("\nAfter disable - Enabled:", disabled.enabled);
+
+// Enable the policy again
+const enabled = await openfort.policies.enable(policy.id);
+console.log("After enable - Enabled:", enabled.enabled);

package/examples/policies/getPolicy.ts

@@ -0,0 +1,30 @@
+// Usage: npx tsx policies/getPolicy.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,
+});
+
+const chainId = Number(process.env.CHAIN_ID) || 80002;
+
+// Create a policy first
+const created = await openfort.policies.create({
+  name: `TestPolicy-${Date.now()}`,
+  chainId,
+  strategy: {
+    sponsorSchema: "pay_for_user",
+  },
+});
+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("  Name:", policy.name);
+console.log("  Chain ID:", policy.chainId);
+console.log("  Strategy:", policy.strategy.sponsorSchema);
+console.log("  Enabled:", policy.enabled);

package/examples/policies/listPolicies.ts

@@ -0,0 +1,17 @@
+// 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.name} (${policy.id})`);
+  console.log(`    Chain: ${policy.chainId}, Strategy: ${policy.strategy.sponsorSchema}`);
+}

package/examples/policies/listPolicyRules.ts

@@ -0,0 +1,37 @@
+// Usage: npx tsx policies/listPolicyRules.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,
+});
+
+const chainId = Number(process.env.CHAIN_ID) || 80002;
+
+// Create a policy with rules
+const policy = await openfort.policies.create({
+  name: `PolicyWithRules-${Date.now()}`,
+  chainId,
+  strategy: {
+    sponsorSchema: "pay_for_user",
+  },
+});
+
+// Add some rules
+await openfort.policyRules.create({
+  type: "account_functions",
+  policy: policy.id,
+});
+
+// List rules for this policy
+const result = await openfort.policyRules.list({ policy: policy.id });
+
+console.log(`Found ${result.total} rules for policy ${policy.id}:`);
+for (const rule of result.data) {
+  console.log(`  - ${rule.id}`);
+  console.log(`    Type: ${rule.type}`);
+  if ("functionName" in rule && rule.functionName) {
+    console.log(`    Function: ${rule.functionName}`);
+  }
+}

package/examples/policies/updatePolicy.ts

@@ -0,0 +1,29 @@
+// Usage: npx tsx policies/updatePolicy.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,
+});
+
+const chainId = Number(process.env.CHAIN_ID) || 80002;
+
+// Create a policy first
+const policy = await openfort.policies.create({
+  name: "Original Policy Name",
+  chainId,
+  strategy: {
+    sponsorSchema: "pay_for_user",
+  },
+});
+console.log("Created policy:", policy.name);
+
+// Update the policy
+const updated = await openfort.policies.update(policy.id, {
+  name: "Updated Policy Name",
+});
+
+console.log("\nUpdated policy:");
+console.log("  ID:", updated.id);
+console.log("  Name:", updated.name);

package/examples/solana/accounts/createAccount.ts

@@ -0,0 +1,18 @@
+// Usage: npx tsx solana/accounts/createAccount.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,
+  walletSecret: process.env.OPENFORT_WALLET_SECRET,
+});
+
+// Create a Solana backend account
+const account = await openfort.accounts.solana.backend.create({
+  name: `SolanaWallet-${Date.now()}`,
+});
+
+console.log("Created Solana account:");
+console.log("  ID:", account.id);
+console.log("  Address:", account.address);

package/examples/solana/accounts/exportAccount.ts

@@ -0,0 +1,29 @@
+// Usage: npx tsx solana/accounts/exportAccount.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,
+  walletSecret: process.env.OPENFORT_WALLET_SECRET,
+});
+
+// Create a Solana backend account
+const account = await openfort.accounts.solana.backend.create({
+  name: "ExportTestSolanaWallet",
+});
+
+console.log("Created Solana account:");
+console.log("  ID:", account.id);
+console.log("  Address:", account.address);
+
+// Export the account's private key
+// Returns base58 encoded private key (standard Solana format)
+const exportedPrivateKey = await openfort.accounts.solana.backend.export({
+  id: account.id,
+});
+
+console.log("\nExported private key (base58):", exportedPrivateKey);
+console.log(
+  "\nNote: This is the standard Solana private key format that can be used with Phantom, Solflare, etc."
+);

package/examples/solana/accounts/getAccount.ts

@@ -0,0 +1,24 @@
+// Usage: npx tsx solana/accounts/getAccount.ts
+
+import Openfort from "@openfort/openfort-node";
+import "dotenv/config";
+
+const openfort = new Openfort(process.env.OPENFORT_API_KEY!, {
+  walletSecret: process.env.OPENFORT_WALLET_SECRET,
+});
+
+// Create a Solana backend account
+const account = await openfort.accounts.solana.backend.create({
+  name: `MySolanaWallet-${Date.now()}`,
+});
+console.log("Created account:", account.address);
+
+// Retrieve account by ID
+const accountById = await openfort.accounts.solana.backend.get({ id: account.id });
+console.log("Retrieved account by ID:", accountById.address);
+
+// Retrieve account by address
+const accountByAddress = await openfort.accounts.solana.backend.get({
+  address: account.address,
+});
+console.log("Retrieved account by address:", accountByAddress.address);

package/examples/solana/accounts/importAccount.ts

@@ -0,0 +1,28 @@
+// Usage: npx tsx solana/accounts/importAccount.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,
+  walletSecret: process.env.OPENFORT_WALLET_SECRET,
+});
+
+// For demonstration, we'll use a random 32-byte hex key
+// In production, you would use an actual Solana private key (base58 or hex format)
+const privateKeyHex = Array.from({ length: 64 }, () =>
+  Math.floor(Math.random() * 16).toString(16)
+).join("");
+
+console.log("Private key (hex):", privateKeyHex);
+
+// Import the account to Openfort
+// Openfort accepts both base58 and hex format for Solana keys
+const account = await openfort.accounts.solana.backend.import({
+  privateKey: privateKeyHex, // Can also be base58 format
+  name: "ImportedSolanaWallet",
+});
+
+console.log("\nImported Solana account:");
+console.log("  ID:", account.id);
+console.log("  Address:", account.address);

package/examples/solana/accounts/listAccounts.ts

@@ -0,0 +1,32 @@
+// Usage: npx tsx solana/accounts/listAccounts.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,
+  walletSecret: process.env.OPENFORT_WALLET_SECRET,
+});
+
+// List all Solana backend accounts
+const result = await openfort.accounts.solana.backend.list({ limit: 10 });
+
+console.log(`Found ${result.total} Solana accounts:`);
+for (const account of result.accounts) {
+  console.log(`  - ${account.address} (${account.id})`);
+}
+
+// Create a few more accounts
+await openfort.accounts.solana.backend.create({ name: `SolanaWallet-${Date.now()}-1` });
+await openfort.accounts.solana.backend.create({ name: `SolanaWallet-${Date.now()}-2` });
+
+// List accounts with pagination
+const moreAccounts = await openfort.accounts.solana.backend.list({
+  limit: 5,
+  skip: 0,
+});
+
+console.log(`\nPaginated results (first 5):`);
+for (const account of moreAccounts.accounts) {
+  console.log(`  - ${account.address}`);
+}

package/examples/solana/signing/signMessage.ts

@@ -0,0 +1,22 @@
+// Usage: npx tsx solana/signing/signMessage.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,
+  walletSecret: process.env.OPENFORT_WALLET_SECRET,
+});
+
+// Create a Solana backend account
+const account = await openfort.accounts.solana.backend.create({
+  name: `SolanaWallet-${Date.now()}`,
+});
+console.log("Created Solana account:", account.address);
+
+// Sign a message
+const message = "Hello, Openfort on Solana!";
+const signature = await account.signMessage({ message });
+
+console.log("\nMessage:", message);
+console.log("Signature:", signature);

package/examples/solana/signing/signTransaction.ts

@@ -0,0 +1,41 @@
+// Usage: npx tsx solana/signing/signTransaction.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,
+  walletSecret: process.env.OPENFORT_WALLET_SECRET,
+});
+
+// Create a Solana backend account
+const account = await openfort.accounts.solana.backend.create({
+  name: `SolanaWallet-${Date.now()}`,
+});
+console.log("Created Solana account:", account.address);
+
+// Create a sample transaction (base64 encoded)
+// In production, you would create this using @solana/web3.js
+// This is a placeholder transaction for demonstration
+const sampleTransaction = Buffer.from("sample-transaction-data").toString(
+  "base64"
+);
+
+console.log("\nTransaction (base64):", sampleTransaction);
+
+// Sign the transaction
+// Note: This example uses a placeholder. In production, create a proper
+// Solana transaction using @solana/web3.js or @solana/kit and serialize it to base64
+try {
+  const signedTransaction = await account.signTransaction({
+    transaction: sampleTransaction,
+  });
+  console.log("Signed transaction:", signedTransaction);
+} catch (error) {
+  console.log(
+    "\nNote: This example uses a placeholder transaction."
+  );
+  console.log(
+    "In production, create a valid Solana transaction using @solana/web3.js"
+  );
+}

package/examples/transactions/createTransactionIntent.ts

@@ -0,0 +1,49 @@
+// Usage: npx tsx transactions/createTransactionIntent.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,
+});
+
+const chainId = Number(process.env.CHAIN_ID) || 80002;
+
+// Create an account (V1 legacy API)
+const account = await openfort.accounts.v1.create({
+  chainId,
+});
+
+// Create a policy for gas sponsorship
+const policy = await openfort.policies.create({
+  name: `TxPolicy-${Date.now()}`,
+  chainId,
+  strategy: {
+    sponsorSchema: "pay_for_user",
+  },
+});
+
+// Create a policy rule to allow all account functions
+await openfort.policyRules.create({
+  type: "account_functions",
+  policy: policy.id,
+});
+
+// Create a transaction intent
+const transactionIntent = await openfort.transactionIntents.create({
+  chainId,
+  policy: policy.id,
+  interactions: [
+    {
+      contract: "0x38090d1636069c0ff1af6bc1737fb996b7f63ac0",
+      functionName: "mint",
+      functionArgs: [account.address],
+    },
+  ],
+});
+
+console.log("Created transaction intent:");
+console.log("  ID:", transactionIntent.id);
+console.log("  Chain ID:", transactionIntent.chainId);
+console.log("  Player:", transactionIntent.player?.id);
+console.log("  Policy:", transactionIntent.policy?.id);

package/examples/transactions/estimateGas.ts

@@ -0,0 +1,52 @@
+// Usage: npx tsx transactions/estimateGas.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,
+});
+
+const chainId = Number(process.env.CHAIN_ID) || 80002;
+
+// Create an account (V1 legacy API)
+const account = await openfort.accounts.v1.create({
+  chainId,
+});
+
+// Create a policy
+const policy = await openfort.policies.create({
+  name: `TxPolicy-${Date.now()}`,
+  chainId,
+  strategy: {
+    sponsorSchema: "pay_for_user",
+  },
+});
+
+await openfort.policyRules.create({
+  type: "account_functions",
+  policy: policy.id,
+});
+
+// Define transaction intent request
+const transactionIntentRequest = {
+  chainId,
+  policy: policy.id,
+  interactions: [
+    {
+      contract: "0x38090d1636069c0ff1af6bc1737fb996b7f63ac0",
+      functionName: "mint",
+      functionArgs: [account.address],
+    },
+  ],
+};
+
+// Estimate cost for the transaction before creating it
+const estimate = await openfort.transactionIntents.estimateCost(
+  transactionIntentRequest,
+);
+
+console.log("Cost estimate:");
+console.log("  Estimated TX Gas:", estimate.estimatedTXGas);
+console.log("  Estimated TX Gas Fee:", estimate.estimatedTXGasFee);
+console.log("  Estimated TX Gas Fee (USD):", estimate.estimatedTXGasFeeUSD);

package/examples/transactions/getTransactionIntent.ts

@@ -0,0 +1,54 @@
+// Usage: npx tsx transactions/getTransactionIntent.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,
+});
+
+const chainId = Number(process.env.CHAIN_ID) || 80002;
+
+// Create an account (V1 legacy API)
+const account = await openfort.accounts.v1.create({
+  chainId,
+});
+
+// Create a policy
+const policy = await openfort.policies.create({
+  name: `TxPolicy-${Date.now()}`,
+  chainId,
+  strategy: {
+    sponsorSchema: "pay_for_user",
+  },
+});
+
+await openfort.policyRules.create({
+  type: "account_functions",
+  policy: policy.id,
+});
+
+// Create a transaction intent
+const created = await openfort.transactionIntents.create({
+  chainId,
+  policy: policy.id,
+  interactions: [
+    {
+      contract: "0x38090d1636069c0ff1af6bc1737fb996b7f63ac0",
+      functionName: "mint",
+      functionArgs: [account.address],
+    },
+  ],
+});
+
+console.log("Created transaction intent:", created.id);
+
+// Retrieve the transaction intent
+const intent = await openfort.transactionIntents.get(created.id);
+
+console.log("\nRetrieved transaction intent:");
+console.log("  ID:", intent.id);
+console.log("  Chain ID:", intent.chainId);
+console.log("  Player:", intent.player?.id);
+console.log("  Account:", intent.account?.id);
+console.log("  Created:", intent.createdAt);

package/examples/transactions/listTransactionIntents.ts

@@ -0,0 +1,31 @@
+// Usage: npx tsx transactions/listTransactionIntents.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 transaction intents
+const result = await openfort.transactionIntents.list({ limit: 10 });
+
+console.log(`Found ${result.total} transaction intents:`);
+for (const intent of result.data) {
+  console.log(`  - ${intent.id}`);
+  console.log(`    Chain: ${intent.chainId}`);
+  console.log(`    Player: ${intent.player?.id || "N/A"}`);
+  console.log(`    Created: ${intent.createdAt}`);
+}
+
+// List transaction intents for a specific player
+const player = await openfort.players.create({
+  name: `Player-${Date.now()}`,
+});
+
+const playerIntents = await openfort.transactionIntents.list({
+  player: [player.id],
+  limit: 10,
+});
+
+console.log(`\nTransaction intents for player ${player.id}: ${playerIntents.total}`);

package/examples/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2021",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist",
+    "rootDir": "."
+  },
+  "include": ["./**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/examples/webhook/index.ts

@@ -0,0 +1,43 @@
+import express, { type Request, type Response } from "express";
+import "dotenv/config";
+import Openfort from "@openfort/openfort-node";
+
+interface WebhookEvent {
+	type: string;
+	data: {
+		id: string;
+		[key: string]: unknown;
+	};
+}
+
+const app = express();
+const port = process.env.APP_PORT || "3001";
+
+app.post(
+	"/webhook/openfort",
+	express.raw({ type: "application/json" }),
+	async (req: Request, res: Response) => {
+		const openfort = new Openfort(process.env.OPENFORT_API_KEY!, {
+			basePath: process.env.OPENFORT_BASE_URL,
+		});
+		try {
+			const signature = req.headers["openfort-signature"];
+			if (typeof signature !== "string") {
+				throw new Error("Missing or invalid openfort-signature header");
+			}
+			const event = await openfort.constructWebhookEvent<WebhookEvent>(
+				req.body.toString(),
+				signature,
+			);
+			console.info("Received webhook event:", event.type, event.data.id);
+			res.status(200).send("OK");
+		} catch (e) {
+			console.error((e as Error).message);
+			res.status(400).send("Invalid webhook");
+		}
+	},
+);
+
+app.listen(port, () => {
+	console.info(`Server is running on http://localhost:${port}`);
+});