fangorn-sdk 0.0.5 → 2026.2.24

package/README.md

@@ -4,7 +4,7 @@ Programmable data.
 
 ## Overview
 
-Fangorn is a programmable data framework that lets you **register datasources** and **publish encrypted data** under public conditions, or predicates, such that it can only be decrypted if you meet the condition.
+Fangorn is a programmable data framework that lets you **register datasources** and **publish encrypted data** under public conditions, or predicates, such that it can only be decrypted if you meet the condition(s).
 
 ## Supported Networks
 
@@ -12,7 +12,7 @@ Fangorn can be deployed on any EVM chain that has a brige to Lit protocol. Curre
 
 ## Build
 
-`pnpm i`.
+`pnpm i
 
 ### Usage
 

package/lib/cli.js

@@ -10,34 +10,49 @@ import { Command } from "commander";
 import { confirm, intro, isCancel, multiselect, note, outro, select, spinner, text } from "@clack/prompts";
 import { createWalletClient, http } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
-import { createLitClient } from "@lit-protocol/lit-client";
-import { nagaDev } from "@lit-protocol/networks";
-import { readFileSync, writeFileSync } from "fs";
-import { basename, extname } from "path";
 import "dotenv/config";
 import { PinataSDK } from "pinata";
 import { SDK } from "agent0-sdk";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { basename, extname, join } from "path";
+import { homedir } from "os";
 
 //#region src/cli.ts
+const CONFIG_DIR = join(homedir(), ".fangorn");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
 let _config = null;
 let _account = null;
 let _fangorn = null;
 function loadConfig() {
 	if (_config) return _config;
+	const privateKey = process.env.DELEGATOR_ETH_PRIVATE_KEY;
 	const jwt = process.env.PINATA_JWT;
 	const gateway = process.env.PINATA_GATEWAY;
-	const privateKey = process.env.DELEGATOR_ETH_PRIVATE_KEY;
 	const chainName = process.env.CHAIN_NAME;
-	if (!chainName || !jwt || !gateway || !privateKey) throw new Error("Missing required env vars: CHAIN_NAME, PINATA_JWT, PINATA_GATEWAY, DELEGATOR_ETH_PRIVATE_KEY");
-	let config = FangornConfig.BaseSepolia;
-	if (chainName === SupportedNetworks.ArbitrumSepolia.name) config = FangornConfig.ArbitrumSepolia;
-	_config = {
+	if (privateKey && jwt && gateway && chainName) {
+		_config = buildConfig({
+			privateKey,
+			jwt,
+			gateway,
+			chainName
+		});
+		return _config;
+	}
+	if (existsSync(CONFIG_PATH)) {
+		_config = buildConfig(JSON.parse(readFileSync(CONFIG_PATH, "utf-8")));
+		return _config;
+	}
+	throw new Error("No configuration found. Run `fangorn init` to set up your credentials, or set DELEGATOR_ETH_PRIVATE_KEY, PINATA_JWT, PINATA_GATEWAY, and CHAIN_NAME env vars.");
+}
+function buildConfig({ privateKey, jwt, gateway, chainName }) {
+	let cfg = FangornConfig.BaseSepolia;
+	if (chainName === SupportedNetworks.ArbitrumSepolia.name) cfg = FangornConfig.ArbitrumSepolia;
+	return {
+		privateKey,
 		jwt,
 		gateway,
-		privateKey,
-		cfg: config
+		cfg
 	};
-	return _config;
 }
 function getAccount() {
 	if (_account) return _account;
@@ -52,7 +67,6 @@ async function getFangorn(chain) {
 		transport: http(cfg.cfg.rpcUrl),
 		chain
 	});
-	const litClient = await createLitClient({ network: nagaDev });
 	const appConfig = cfg.cfg;
 	const domain = process.env.DOMAIN || "localhost:3000";
 	const storage = new PinataStorage(new PinataSDK({
@@ -60,7 +74,7 @@ async function getFangorn(chain) {
 		pinataGateway: cfg.gateway
 	}));
 	const chainName = process.env.CHAIN_NAME;
-	const encryptionService = new LitEncryptionService(litClient, { chainName });
+	const encryptionService = await LitEncryptionService.init(chainName);
 	_fangorn = await Fangorn.init(walletClient, storage, encryptionService, domain, appConfig);
 	return _fangorn;
 }
@@ -85,7 +99,54 @@ const selectChain = async () => {
 	return getNetwork(chainChoice.toString());
 };
 const program = new Command();
-program.name("Fangorn").description("CLI for Fangorn").version("9129129");
+program.name("Fangorn").description("CLI for Fangorn").version("0.0.1");
+program.command("init").description("Configure your Fangorn credentials").action(async () => {
+	intro("Fangorn Setup");
+	const privateKey = await text({
+		message: "Your wallet private key (stored locally, never transmitted):",
+		placeholder: "0x...",
+		validate: (v) => {
+			if (!v.startsWith("0x") || v.length !== 66) return "Must be a valid 0x-prefixed 32-byte hex key";
+		}
+	});
+	handleCancel(privateKey);
+	const jwt = await text({
+		message: "Pinata JWT:",
+		validate: (v) => {
+			if (!v) return "Required";
+		}
+	});
+	handleCancel(jwt);
+	const gateway = await text({
+		message: "Pinata Gateway URL:",
+		placeholder: "https://your-gateway.mypinata.cloud",
+		validate: (v) => {
+			if (!v) return "Required";
+		}
+	});
+	handleCancel(gateway);
+	const chainName = await select({
+		message: "Default chain:",
+		options: [{
+			value: SupportedNetworks.ArbitrumSepolia.name,
+			label: "Arbitrum Sepolia"
+		}, {
+			value: SupportedNetworks.BaseSepolia.name,
+			label: "Base Sepolia"
+		}]
+	});
+	handleCancel(chainName);
+	const stored = {
+		privateKey,
+		jwt,
+		gateway,
+		chainName
+	};
+	if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+	writeFileSync(CONFIG_PATH, JSON.stringify(stored, null, 2), "utf-8");
+	chmodSync(CONFIG_PATH, 384);
+	outro(`Config saved to ${CONFIG_PATH}`);
+});
 program.command("register").description("Register a new datasource as an agent.").argument("<name>", "Name of the datasource").option("-s, --skip-card", "Skip agent card creation").option("-e, --skip-erc", "Skip ERC-8007 registrion").option("-d, --skip-ds", "Skip datasource registrion").action(async (name, options) => {
 	try {
 		intro("Chain selection");
@@ -354,7 +415,7 @@ program.command("upload").description("Upload file(s) to a data source").argumen
 			return new PaymentGadget({
 				commitment: fieldToHex(await computeTagCommitment(owner, name, file.tag, options.price)),
 				chainName: "arbitrumSepolia",
-				settlementTrackerContractAddress: "0xb32ed201896ba765e6aa118a5c18c263f559474e",
+				settlementTrackerContractAddress: "0x7c6ae9eb3398234eb69b2f3acfae69065505ff69",
 				usdcPrice: options.price
 			});
 		}, options.overwrite);
@@ -365,6 +426,50 @@ program.command("upload").description("Upload file(s) to a data source").argumen
 		process.exit(1);
 	}
 });
+program.command("list").description("List contents (index) of a data source").argument("<name>", "Data source name").option("-c, --chain <chain>", "The chain to use as the backend (arbitrumSepolia or baseSepolia)").action(async (name, options) => {
+	try {
+		const owner = getAccount().address;
+		const manifest = await (await getFangorn(getChain(options.chain))).getManifest(owner, name);
+		if (!manifest) {
+			console.log("The data source is empty. \n");
+			console.log("Upload data with `fangorn upload <dataSourceName> <file> --price <set-price>");
+			process.exit(0);
+		}
+		console.log(`Datasource: ${name} (${owner})`);
+		console.log(`Entries (${manifest.entries.length}):`);
+		for (const entry of manifest.entries) console.log(`  - ${entry.tag} | gadget descriptor: ${JSON.stringify(entry.gadgetDescriptor)} | cid: ${entry.cid}`);
+		process.exit(0);
+	} catch (err) {
+		console.error("Failed to list vault:", err.message);
+		process.exit(1);
+	}
+});
+program.command("info").description("Get data source info from contract").argument("<name>", "Data source name").option("-c, --chain <chain>", "The chain to use as the backend (arbitrumSepolia or baseSepolia)").action(async (name, options) => {
+	try {
+		const owner = getAccount().address;
+		const vault = await (await getFangorn(getChain(options.chain))).getDataSource(owner, name);
+		console.log(`Datasource: ${name} (${owner})`);
+		console.log(`Owner: ${vault.owner}`);
+		console.log(`Manifest CID: ${vault.manifestCid == "" ? "Upload data with `fangorn upload <vaultName> <file> --price <set-price>`" : vault.manifestCid}`);
+		process.exit(0);
+	} catch (err) {
+		console.error("Failed to get vault info:", err.message);
+		process.exit(1);
+	}
+});
+program.command("entry").description("Get info about a specific entry").argument("<name>", "Vault name").argument("<tag>", "File tag").option("-c, --chain <chain>", "The chain to use as the backend (arbitrumSepolia or baseSepolia").action(async (name, tag, options) => {
+	try {
+		const owner = getAccount().address;
+		const entry = await (await getFangorn(getChain(options.chain))).getDataSourceData(owner, name, tag);
+		console.log(`Entry: ${tag}`);
+		console.log(`  CID: ${entry.cid}`);
+		console.log(`  Gadget Descriptor: ${JSON.stringify(entry.gadgetDescriptor)}`);
+		process.exit(0);
+	} catch (err) {
+		console.error("Failed to get entry:", err.message);
+		process.exit(1);
+	}
+});
 program.command("decrypt").description("Decrypt a file from a vault").argument("<owner>", "The owner of the datasource").argument("<name>", "The name of the datasource").argument("<tag>", "File tag").option("-c, --chain <chain>", "The chain to use as the backend (arbitrumSepolia or baseSepolia").option("-o, --output <path>", "Output file path").action(async (owner, name, tag, options) => {
 	try {
 		const decrypted = await (await getFangorn(getChain(options.chain))).decryptFile(owner, name, tag);

package/lib/fangorn.d.ts

@@ -48,6 +48,7 @@ declare class Fangorn {
    */
   decryptFile(owner: Address, name: string, tag: string, authContext?: any): Promise<Uint8Array>;
   getDataSource(owner: Address, name: string): Promise<Vault>;
+  registry(): DataSourceRegistry;
   getManifest(owner: Address, name: string): Promise<VaultManifest | undefined>;
   getDataSourceData(owner: Address, name: string, tag: string): Promise<VaultEntry>;
   getAddress(): Hex;

package/lib/fangorn.js

@@ -107,6 +107,9 @@ var Fangorn = class Fangorn {
 	async getDataSource(owner, name) {
 		return await this.dataSourceRegistry.getDataSource(owner, name);
 	}
+	registry() {
+		return this.dataSourceRegistry;
+	}
 	async getManifest(owner, name) {
 		const vault = await this.getDataSource(owner, name);
 		if (!vault.manifestCid || vault.manifestCid === "") return;

package/lib/modules/encryption/lit.d.ts

@@ -11,9 +11,22 @@ interface LitEncryptionServiceConfig {
 }
 declare class LitEncryptionService implements EncryptionService {
   private litClient;
-  private config;
-  constructor(litClient: LitClient, config: LitEncryptionServiceConfig);
+  private chainName;
+  constructor(litClient: LitClient, chainName: string);
+  static init(chain: string): Promise<LitEncryptionService>;
+  /**
+   * Encrypt filedata under the given gadget
+   * @param file The filedata to encrypt
+   * @param gadget The gadget to use
+   * @returns The ciphertext bundle
+   */
   encrypt(file: Filedata, gadget: Gadget): Promise<EncryptedPayload>;
+  /**
+   * Attempt to decrypt some encrypted data
+   * @param payload The encrytped bundle to recover
+   * @param authContext The authorization context
+   * @returns The decrytped output (on success), else empty
+   */
   decrypt(payload: EncryptedPayload, authContext: AuthContextWrapper): Promise<DecryptedPayload>;
   createAuthContext(walletClient: WalletClient, domain: string): Promise<AuthContextWrapper>;
   private createAuthSig;

package/lib/modules/encryption/lit.js

@@ -1,6 +1,8 @@
 import { decryptData, encryptData } from "./aes.js";
 import { LitAccessControlConditionResource, LitActionResource, LitPKPResource, createSiweMessage } from "@lit-protocol/auth-helpers";
+import { createLitClient } from "@lit-protocol/lit-client";
 import { createAuthManager, storagePlugins } from "@lit-protocol/auth";
+import { nagaDev } from "@lit-protocol/networks";
 
 //#region src/modules/encryption/lit.ts
 const createDecryptLitActionCode = (chainName) => `(async () => {
@@ -23,18 +25,27 @@ const createDecryptLitActionCode = (chainName) => `(async () => {
         });
     }
 })();`;
-var LitEncryptionService = class {
-	constructor(litClient, config) {
+var LitEncryptionService = class LitEncryptionService {
+	constructor(litClient, chainName) {
 		this.litClient = litClient;
-		this.config = config;
+		this.chainName = chainName;
 	}
+	static async init(chain) {
+		return new LitEncryptionService(await createLitClient({ network: nagaDev }), chain);
+	}
+	/**
+	* Encrypt filedata under the given gadget
+	* @param file The filedata to encrypt
+	* @param gadget The gadget to use
+	* @returns The ciphertext bundle
+	*/
 	async encrypt(file, gadget) {
 		const { encryptedData, keyMaterial } = await encryptData(file.data);
 		const acc = await gadget.toAccessCondition();
 		const litEncryptedKey = await this.litClient.encrypt({
 			dataToEncrypt: keyMaterial.toString(),
 			unifiedAccessControlConditions: acc,
-			chain: this.config.chainName
+			chain: this.chainName
 		});
 		return {
 			data: encryptedData,
@@ -46,6 +57,12 @@ var LitEncryptionService = class {
 			litAction: gadget.toLitAction()
 		};
 	}
+	/**
+	* Attempt to decrypt some encrypted data
+	* @param payload The encrytped bundle to recover 
+	* @param authContext The authorization context
+	* @returns The decrytped output (on success), else empty
+	*/
 	async decrypt(payload, authContext) {
 		const result = await this.litClient.executeJs({
 			code: createDecryptLitActionCode(authContext.chainName),
@@ -61,12 +78,16 @@ var LitEncryptionService = class {
 		return { data: await decryptData(payload.data, key) };
 	}
 	async createAuthContext(walletClient, domain) {
-		const account = walletClient.account;
-		const sessionContext = await createAuthManager({ storage: storagePlugins.localStorageNode({
+		const isWindowUndefined = typeof window === "undefined";
+		const account = isWindowUndefined ? walletClient.account : walletClient;
+		const sessionContext = await (isWindowUndefined ? createAuthManager({ storage: storagePlugins.localStorageNode({
 			appName: "fangorn",
 			networkName: "naga-dev",
 			storagePath: "./lit-auth-storage"
-		}) }).createEoaAuthContext({
+		}) }) : createAuthManager({ storage: storagePlugins.localStorage({
+			appName: "fangorn",
+			networkName: "naga-dev"
+		}) })).createEoaAuthContext({
 			litClient: this.litClient,
 			config: { account },
 			authConfig: {

package/lib/test/testbed.js

@@ -6,8 +6,6 @@ import { PaymentGadget } from "../modules/gadgets/payment.js";
 import { emptyWallet } from "./test-gadget.js";
 import { SettlementTracker } from "../interface/settlement-tracker/settlementTracker.js";
 import { createPublicClient, http, keccak256, parseUnits, toHex } from "viem";
-import { createLitClient } from "@lit-protocol/lit-client";
-import { nagaDev } from "@lit-protocol/networks";
 import { arbitrumSepolia, baseSepolia } from "viem/chains";
 import { PinataSDK } from "pinata";
 
@@ -41,10 +39,8 @@ var TestBed = class TestBed {
 			rpcUrl,
 			caip2
 		};
-		const delegatorLitClient = await createLitClient({ network: nagaDev });
-		const delegateeLitClient = await createLitClient({ network: nagaDev });
-		const delegatorEncryption = new LitEncryptionService(delegatorLitClient, { chainName: chain });
-		const delegateeEncryption = new LitEncryptionService(delegateeLitClient, { chainName: chain });
+		const delegatorEncryption = await LitEncryptionService.init(chain);
+		const delegateeEncryption = await LitEncryptionService.init(chain);
 		const pinata = new PinataSDK({
 			pinataJwt: jwt,
 			pinataGateway: gateway

package/package.json

@@ -1,11 +1,14 @@
 {
 	"name": "fangorn-sdk",
-	"version": "0.0.5",
+	"version": "2026.02.24",
 	"description": "A zero-knowledge conditional access control framework",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/fangorn-network/fangorn.git"
 	},
+	"bin": {
+		"fangorn": "lib/cli.js"
+	},
 	"license": "MIT",
 	"type": "module",
 	"main": "lib/index.js",