@openfort/openfort-node 0.6.78 → 0.7.1

package/examples/.env.example

@@ -0,0 +1,16 @@
+# Openfort API Key (required)
+OPENFORT_API_KEY=sk_test_...
+OPENFORT_PUBLISHABLE_KEY=pk_test_...
+# Optional: Custom API base URL
+# OPENFORT_BASE_URL=https://api.openfort.io
+
+# Optional: Wallet secret for backend wallet operations
+# OPENFORT_WALLET_SECRET=your-wallet-secret
+
+# Chain ID for EVM operations (e.g., 80002 for Amoy, 84532 for Base Sepolia)
+CHAIN_ID=80002
+
+# Shield Configuration (required for evm/embedded/pregenerate.ts)
+SHIELD_API_KEY=your_shield_api_key
+SHIELD_API_SECRET=your_shield_api_secret
+SHIELD_ENCRYPTION_SHARE=your_encryption_share

package/examples/README.md

@@ -0,0 +1,157 @@
+# Openfort Node SDK Examples
+
+This directory contains examples demonstrating how to use the Openfort Node SDK.
+
+## Setup
+
+1. Build the SDK and install dependencies:
+```bash
+pnpm setup
+```
+
+This will:
+- Build the parent SDK package
+- Install example dependencies (linked to local SDK)
+
+2. Copy the environment template and configure your API keys:
+```bash
+cp .env.example .env
+```
+
+3. Edit `.env` with your Openfort API key:
+```bash
+OPENFORT_API_KEY=sk_test_...
+CHAIN_ID=80002  # Polygon Amoy testnet
+```
+
+## Running Examples
+
+Run any example using `pnpm example`:
+
+```bash
+pnpm example evm/accounts/createAccount.ts
+```
+
+Or directly with tsx:
+
+```bash
+npx tsx evm/accounts/createAccount.ts
+```
+
+## Development Workflow
+
+When making changes to the SDK:
+
+1. Make your changes in the parent `src/` directory
+2. Rebuild the SDK:
+```bash
+pnpm build:sdk
+```
+3. Run an example to test:
+```bash
+pnpm example evm/accounts/createAccount.ts
+```
+
+## Examples Overview
+
+### EVM Wallet Examples
+
+#### Accounts (`evm/accounts/`)
+| Example            | Description                          |
+| ------------------ | ------------------------------------ |
+| `createAccount.ts` | Create a new EVM account             |
+| `getAccount.ts`    | Retrieve an account by ID or address |
+| `listAccounts.ts`  | List all EVM accounts                |
+| `importAccount.ts` | Import an account from private key   |
+| `exportAccount.ts` | Export an account's private key      |
+
+#### Signing (`evm/signing/`)
+| Example              | Description                        |
+| -------------------- | ---------------------------------- |
+| `signMessage.ts`     | Sign a message with an EVM account |
+| `signTypedData.ts`   | Sign EIP-712 typed data            |
+| `signHash.ts`        | Sign a raw hash                    |
+| `signTransaction.ts` | Sign a transaction                 |
+
+#### Embedded Wallets (`evm/embedded/`)
+| Example          | Description                              |
+| ---------------- | ---------------------------------------- |
+| `pregenerate.ts` | Pre-generate a user with embedded wallet |
+
+> **Note:** The `pregenerate.ts` example requires Shield configuration. See `.env.example` for required environment variables:
+> - `SHIELD_API_KEY`
+> - `SHIELD_API_SECRET`
+> - `SHIELD_ENCRYPTION_SHARE`
+
+### Solana Wallet Examples
+
+#### Accounts (`solana/accounts/`)
+| Example            | Description                          |
+| ------------------ | ------------------------------------ |
+| `createAccount.ts` | Create a new Solana account          |
+| `getAccount.ts`    | Retrieve an account by ID or address |
+| `listAccounts.ts`  | List all Solana accounts             |
+| `importAccount.ts` | Import an account from private key   |
+| `exportAccount.ts` | Export an account's private key      |
+
+#### Signing (`solana/signing/`)
+| Example              | Description                          |
+| -------------------- | ------------------------------------ |
+| `signMessage.ts`     | Sign a message with a Solana account |
+| `signTransaction.ts` | Sign a Solana transaction            |
+
+
+### Policies
+
+| Example                           | Description                     |
+| --------------------------------- | ------------------------------- |
+| `policies/createPolicy.ts`        | Create a gas sponsorship policy |
+| `policies/getPolicy.ts`           | Get a policy by ID              |
+| `policies/listPolicies.ts`        | List all policies               |
+| `policies/updatePolicy.ts`        | Update a policy                 |
+| `policies/disableEnablePolicy.ts` | Enable/disable a policy         |
+| `policies/createPolicyRule.ts`    | Create a policy rule            |
+| `policies/listPolicyRules.ts`     | List policy rules               |
+
+### Contracts
+
+| Example                       | Description         |
+| ----------------------------- | ------------------- |
+| `contracts/createContract.ts` | Register a contract |
+| `contracts/listContracts.ts`  | List all contracts  |
+
+### Transaction Intents
+
+| Example                                   | Description                    |
+| ----------------------------------------- | ------------------------------ |
+| `transactions/createTransactionIntent.ts` | Create a transaction intent    |
+| `transactions/getTransactionIntent.ts`    | Get a transaction intent       |
+| `transactions/listTransactionIntents.ts`  | List transaction intents       |
+| `transactions/estimateGas.ts`             | Estimate gas for a transaction |
+
+### Exchange / Swaps
+
+| Example                  | Description                |
+| ------------------------ | -------------------------- |
+| `exchange/quoteSwap.ts`  | Get a quote for token swap |
+| `exchange/createSwap.ts` | Execute a token swap       |
+
+### IAM (Identity & Access Management)
+
+| Example             | Description                   |
+| ------------------- | ----------------------------- |
+| `iam/listUsers.ts`  | List all authenticated users  |
+| `iam/getUser.ts`    | Get a user by ID              |
+| `iam/deleteUser.ts` | Delete a user                 |
+| `iam/getSession.ts` | Verify auth token server-side |
+
+### Webhooks
+
+| Example            | Description                                         |
+| ------------------ | --------------------------------------------------- |
+| `webhook/index.ts` | Express server to receive and verify webhook events |
+
+## Additional Resources
+
+- [Openfort Documentation](https://www.openfort.io/docs)
+- [Dashboard](https://dashboard.openfort.io)

package/examples/contracts/createContract.ts

@@ -0,0 +1,25 @@
+// Usage: npx tsx contracts/createContract.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 contract reference
+const contract = await openfort.contracts.create({
+  name: "My Token Contract",
+  chainId,
+  address: "0xbabe0001489722187FbaF0689C47B2f5E97545C5",
+  // Optional: provide ABI for function name validation
+  // abi: [...]
+});
+
+console.log("Created contract:");
+console.log("  ID:", contract.id);
+console.log("  Name:", contract.name);
+console.log("  Address:", contract.address);
+console.log("  Chain ID:", contract.chainId);

package/examples/contracts/listContracts.ts

@@ -0,0 +1,18 @@
+// Usage: npx tsx contracts/listContracts.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 contracts
+const result = await openfort.contracts.list({ limit: 10 });
+
+console.log(`Found ${result.total} contracts:`);
+for (const contract of result.data) {
+  console.log(`  - ${contract.name} (${contract.id})`);
+  console.log(`    Address: ${contract.address}`);
+  console.log(`    Chain: ${contract.chainId}`);
+}

package/examples/evm/accounts/createAccount.ts

@@ -0,0 +1,18 @@
+// Usage: npx tsx evm/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 an EVM backend account
+const account = await openfort.accounts.evm.backend.create({
+  name: `MyWallet-${Date.now()}`,
+});
+
+console.log("Created EVM account:");
+console.log("  ID:", account.id);
+console.log("  Address:", account.address);

package/examples/evm/accounts/exportAccount.ts

@@ -0,0 +1,39 @@
+// Usage: npx tsx evm/accounts/exportAccount.ts
+
+import Openfort from "@openfort/openfort-node";
+import "dotenv/config";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+
+const openfort = new Openfort(process.env.OPENFORT_API_KEY!, {
+  basePath: process.env.OPENFORT_BASE_URL,
+  walletSecret: process.env.OPENFORT_WALLET_SECRET,
+});
+
+// First import an account so we can export it
+const originalPrivateKey = generatePrivateKey();
+const originalAccount = privateKeyToAccount(originalPrivateKey);
+
+console.log("Original private key:", originalPrivateKey);
+console.log("Original address:", originalAccount.address);
+
+const account = await openfort.accounts.evm.backend.import({
+  privateKey: originalPrivateKey,
+  name: "ExportTestWallet",
+});
+
+console.log("\nImported account ID:", account.id);
+
+// Export the account's private key
+const exportedPrivateKey = await openfort.accounts.evm.backend.export({
+  id: account.id,
+});
+
+console.log("\nExported private key:", `0x${exportedPrivateKey}`);
+
+// Verify the exported key matches
+const derivedAccount = privateKeyToAccount(`0x${exportedPrivateKey}`);
+console.log("Derived address:", derivedAccount.address);
+console.log(
+  "Keys match:",
+  originalPrivateKey.toLowerCase() === `0x${exportedPrivateKey}`.toLowerCase()
+);

package/examples/evm/accounts/getAccount.ts

@@ -0,0 +1,30 @@
+// Usage: npx tsx evm/accounts/getAccount.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 player and account first
+const player = await openfort.players.create({
+  name: `Player-${Date.now()}`,
+});
+console.log("Created player:", player.id);
+
+const account = await openfort.accounts.evm.backend.create({
+  name: `MyWallet-${Date.now()}`,
+});
+console.log("Created account:", account.address);
+
+// Retrieve account by ID
+const accountById = await openfort.accounts.evm.backend.get({ id: account.id });
+console.log("Retrieved account by ID:", accountById.address);
+
+// Retrieve account by address
+const accountByAddress = await openfort.accounts.evm.backend.get({
+  address: account.address,
+});
+console.log("Retrieved account by address:", accountByAddress.address);

package/examples/evm/accounts/importAccount.ts

@@ -0,0 +1,31 @@
+// Usage: npx tsx evm/accounts/importAccount.ts
+
+import Openfort from "@openfort/openfort-node";
+import "dotenv/config";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+
+const openfort = new Openfort(process.env.OPENFORT_API_KEY!, {
+  basePath: process.env.OPENFORT_BASE_URL,
+  walletSecret: process.env.OPENFORT_WALLET_SECRET,
+});
+
+// Generate a random private key for demonstration
+const privateKey = generatePrivateKey();
+const localAccount = privateKeyToAccount(privateKey);
+
+console.log("Generated private key:", privateKey);
+console.log("Expected address:", localAccount.address);
+
+// Import the account to Openfort
+const account = await openfort.accounts.evm.backend.import({
+  privateKey,
+  name: "ImportedWallet",
+});
+
+console.log("\nImported account:");
+console.log("  ID:", account.id);
+console.log("  Address:", account.address);
+console.log(
+  "  Addresses match:",
+  account.address.toLowerCase() === localAccount.address.toLowerCase()
+);

package/examples/evm/accounts/listAccounts.ts

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

package/examples/evm/embedded/pregenerate.ts

@@ -0,0 +1,33 @@
+// Usage: npx tsx evm/embedded/pregenerate.ts
+
+import Openfort, { ShieldAuthProvider } from "@openfort/openfort-node";
+import "dotenv/config";
+
+const openfort = new Openfort(process.env.OPENFORT_API_KEY!, {
+  basePath: process.env.OPENFORT_BASE_URL,
+});
+
+// Pre-generate a user with an embedded wallet
+// This creates the user and wallet before they authenticate
+const result = await openfort.accounts.evm.embedded.pregenerate(
+  {
+    email: "jaume+1@openfort.xyz",
+    accountType: "Externally Owned Account"
+  },
+  {
+    shieldApiKey: process.env.SHIELD_API_KEY!,
+    shieldApiSecret: process.env.SHIELD_API_SECRET!,
+    shieldAuthProvider: ShieldAuthProvider.OPENFORT,
+    encryptionShare: process.env.SHIELD_ENCRYPTION_SHARE!,
+  }
+);
+
+console.log("Pre-generated user with embedded wallet:");
+console.log("  Account ID:", result.id);
+console.log("  User ID:", result.user);
+console.log("  Address:", result.address);
+console.log("  Owner Address:", result.ownerAddress);
+console.log("  Account Type:", result.accountType);
+console.log("  Chain ID:", result.chainId);
+console.log("  Chain Type:", result.chainType);
+console.log("  Created:", new Date(result.createdAt * 1000).toISOString());

package/examples/evm/signing/signHash.ts

@@ -0,0 +1,28 @@
+// Usage: npx tsx evm/signing/signHash.ts
+
+import Openfort from "@openfort/openfort-node";
+import "dotenv/config";
+import { keccak256, toBytes } from "viem";
+
+const openfort = new Openfort(process.env.OPENFORT_API_KEY!, {
+  basePath: process.env.OPENFORT_BASE_URL,
+  walletSecret: process.env.OPENFORT_WALLET_SECRET,
+});
+
+// Create a backend account
+const account = await openfort.accounts.evm.backend.create({
+  name: `Wallet-${Date.now()}`,
+});
+console.log("Created account:", account.address);
+
+// Create a hash to sign
+const message = "Hello, Openfort!";
+const hash = keccak256(toBytes(message));
+
+console.log("\nOriginal message:", message);
+console.log("Hash:", hash);
+
+// Sign the hash directly
+const signature = await account.sign({ hash });
+
+console.log("Signature:", signature);

package/examples/evm/signing/signMessage.ts

@@ -0,0 +1,32 @@
+// Usage: npx tsx evm/signing/signMessage.ts
+
+import Openfort from "@openfort/openfort-node";
+import "dotenv/config";
+import { verifyMessage } from "viem";
+
+const openfort = new Openfort(process.env.OPENFORT_API_KEY!, {
+  basePath: process.env.OPENFORT_BASE_URL,
+  walletSecret: process.env.OPENFORT_WALLET_SECRET,
+});
+
+// Create a backend account
+const account = await openfort.accounts.evm.backend.create({
+  name: `Wallet-${Date.now()}`,
+});
+console.log("Created account:", account.address);
+
+// Sign a message
+const message = "Hello, Openfort!";
+const signature = await account.signMessage({ message });
+
+console.log("\nMessage:", message);
+console.log("Signature:", signature);
+
+// Verify the signature using viem
+const isValid = await verifyMessage({
+  address: account.address,
+  message,
+  signature,
+});
+
+console.log("Signature valid:", isValid);

package/examples/evm/signing/signTransaction.ts

@@ -0,0 +1,42 @@
+// Usage: npx tsx evm/signing/signTransaction.ts
+
+import Openfort from "@openfort/openfort-node";
+import "dotenv/config";
+import { parseEther, parseTransaction } from "viem";
+
+const openfort = new Openfort(process.env.OPENFORT_API_KEY!, {
+  basePath: process.env.OPENFORT_BASE_URL,
+  walletSecret: process.env.OPENFORT_WALLET_SECRET,
+});
+
+// Create a backend account
+const account = await openfort.accounts.evm.backend.create({
+  name: `Wallet-${Date.now()}`,
+});
+console.log("Created account:", account.address);
+
+// Define a transaction to sign
+const transaction = {
+  to: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8" as const,
+  value: parseEther("0.001"),
+  nonce: 0,
+  gas: 21000n,
+  maxFeePerGas: 20000000000n,
+  maxPriorityFeePerGas: 1000000000n,
+  chainId: Number(process.env.CHAIN_ID) || 80002,
+};
+
+console.log("\nTransaction to sign:");
+console.log("  To:", transaction.to);
+console.log("  Value:", transaction.value.toString(), "wei");
+console.log("  Chain ID:", transaction.chainId);
+
+// Sign the transaction
+const signedTransaction = await account.signTransaction(transaction);
+
+console.log("\nSigned transaction:", signedTransaction);
+
+// Parse and display the signed transaction
+const parsed = parseTransaction(signedTransaction);
+console.log("\nParsed signed transaction:");
+console.log("  To:", parsed.to);

package/examples/evm/signing/signTypedData.ts

@@ -0,0 +1,71 @@
+// Usage: npx tsx evm/signing/signTypedData.ts
+
+import Openfort from "@openfort/openfort-node";
+import "dotenv/config";
+import { verifyTypedData } from "viem";
+
+const openfort = new Openfort(process.env.OPENFORT_API_KEY!, {
+  basePath: process.env.OPENFORT_BASE_URL,
+  walletSecret: process.env.OPENFORT_WALLET_SECRET,
+});
+
+// Create a backend account
+const account = await openfort.accounts.evm.backend.create({
+  name: `Wallet-${Date.now()}`,
+});
+console.log("Created account:", account.address);
+
+// Define EIP-712 typed data
+const domain = {
+  name: "Example App",
+  version: "1",
+  chainId: 1,
+  verifyingContract: "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC" as const,
+};
+
+const types = {
+  Person: [
+    { name: "name", type: "string" },
+    { name: "wallet", type: "address" },
+  ],
+  Mail: [
+    { name: "from", type: "Person" },
+    { name: "to", type: "Person" },
+    { name: "contents", type: "string" },
+  ],
+} as const;
+
+const message = {
+  from: {
+    name: "Alice",
+    wallet: "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826" as const,
+  },
+  to: {
+    name: "Bob",
+    wallet: "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB" as const,
+  },
+  contents: "Hello, Bob!",
+};
+
+// Sign the typed data
+const signature = await account.signTypedData({
+  domain,
+  types,
+  primaryType: "Mail",
+  message,
+});
+
+console.log("\nTyped data signed successfully!");
+console.log("Signature:", signature);
+
+// Verify the signature
+const isValid = await verifyTypedData({
+  address: account.address,
+  domain,
+  types,
+  primaryType: "Mail",
+  message,
+  signature,
+});
+
+console.log("Signature valid:", isValid);

package/examples/exchange/createSwap.ts

@@ -0,0 +1,49 @@
+// Usage: npx tsx exchange/createSwap.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 the swap
+const policy = await openfort.policies.create({
+  name: `SwapPolicy-${Date.now()}`,
+  chainId,
+  strategy: {
+    sponsorSchema: "pay_for_user",
+  },
+});
+
+await openfort.policyRules.create({
+  type: "account_functions",
+  policy: policy.id,
+});
+
+console.log("Account address:", account.address);
+console.log("Policy ID:", policy.id);
+
+// Create a swap transaction
+// Note: Token addresses and amounts will vary by network
+// The account must have sufficient balance for the swap
+const swap = await openfort.exchange.createSwap({
+  fromAddress: account.id,
+  chainId,
+  tokenInAddress: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", // Native token
+  tokenOutAddress: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174", // USDC
+  amount: "1000000000000000", // 0.001 native token
+  tradeType: "EXACT_INPUT",
+  policy: policy.id,
+});
+
+console.log("\nSwap created:");
+console.log("  Transaction Intent ID:", swap.id);
+console.log("  Status:", swap.response?.status || "pending");

package/examples/exchange/quoteSwap.ts

@@ -0,0 +1,34 @@
+// Usage: npx tsx exchange/quoteSwap.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,
+});
+
+console.log("Account address:", account.address);
+
+// Get a quote for swapping tokens
+// Note: Token addresses and amounts will vary by network
+const quote = await openfort.exchange.quoteSwap({
+  fromAddress: account.id,
+  chainId,
+  tokenInAddress: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", // Native token (ETH/MATIC)
+  tokenOutAddress: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174", // USDC on Polygon
+  amount: "1000000000000000", // 0.001 native token
+  tradeType: "EXACT_INPUT",
+});
+
+console.log("\nSwap quote:");
+console.log("  Amount:", quote.amount);
+console.log("  Slippage:", quote.slippage);
+console.log("  Estimated Gas Fee:", quote.estimatedTXGasFee);
+console.log("  Estimated Gas Fee (USD):", quote.estimatedTXGasFeeUSD);