@cascade-fyi/sati-sdk 0.4.2 → 0.5.0

package/CHANGELOG.md

@@ -5,6 +5,25 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.0] - 2026-02-12
+
+### Added
+
+- `createPinataUploader(jwt)` and `MetadataUploader` interface exported from main entry - pluggable IPFS upload for agent registration
+- `uploadRegistrationFile(params, uploader)` convenience method on `Sati` class
+- Registration `Endpoint` type extended with optional fields: `mcpTools`, `mcpPrompts`, `mcpResources`, `a2aSkills`, `skills`, `domains`
+- Gateway verification after Pinata uploads - catches silent upload failures with 5s timeout (non-fatal for timeouts/rate limits)
+
+### Changed
+
+- **BREAKING**: Pinata uploader migrated from v1 (`pinJSONToIPFS`) to v3 Files API (`uploads.pinata.cloud/v3/files`) - returns CIDv1 (`bafkrei...`) instead of CIDv0 (`Qm...`). Both formats are valid IPFS URIs.
+- Compressed attestation queries now use server-side memcmp filtering via Photon RPC for `sasSchema` and `agentMint` (significant performance improvement for large datasets)
+- Client-side filtering retained for `counterparty` and `outcome` fields only
+
+### Dependencies
+
+- Requires `@cascade-fyi/compression-kit` >= 0.2.1 (memcmp filter support)
+
 ## [0.4.2] - 2026-02-10
 
 ### Fixed
@@ -85,6 +104,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Compressed attestation storage via Light Protocol
 - Basic querying via Photon RPC
 
+[0.5.0]: https://github.com/cascade-protocol/sati/compare/@cascade-fyi/sati-sdk@0.4.2...@cascade-fyi/sati-sdk@0.5.0
 [0.4.2]: https://github.com/cascade-protocol/sati/compare/@cascade-fyi/sati-sdk@0.4.1...@cascade-fyi/sati-sdk@0.4.2
 [0.4.1]: https://github.com/cascade-protocol/sati/compare/@cascade-fyi/sati-sdk@0.4.0...@cascade-fyi/sati-sdk@0.4.1
 [0.4.0]: https://github.com/cascade-protocol/sati/compare/@cascade-fyi/sati-sdk@0.3.0...@cascade-fyi/sati-sdk@0.4.0

package/README.md

@@ -41,6 +41,7 @@ const result = await sati.registerAgent({
   payer,                          // KeyPairSigner (pays fees + becomes owner)
   name: "MyAgent",                // Max 32 chars
   uri: "ipfs://Qm...",            // Agent metadata JSON
+  owner: ownerAddress,            // Optional: mint NFT to a different address
   additionalMetadata: [           // Optional key-value pairs
     { key: "version", value: "1.0" },
   ],
@@ -51,6 +52,48 @@ console.log(result.mint);         // Agent's token address (identity)
 console.log(result.memberNumber); // Registry member number
 ```
 
+### IPFS Upload + Registration
+
+Upload a registration file to IPFS and register in one flow:
+
+```typescript
+import { createPinataUploader } from "@cascade-fyi/sati-sdk";
+
+const uploader = createPinataUploader(process.env.PINATA_JWT!);
+
+// Build + upload registration file, then register
+const uri = await sati.uploadRegistrationFile(
+  {
+    name: "MyAgent",
+    description: "AI assistant",
+    image: "https://example.com/avatar.png",
+    endpoints: [
+      { name: "MCP", endpoint: "https://myagent.com/mcp", version: "2025-06-18", mcpTools: ["search"] },
+      { name: "A2A", endpoint: "https://myagent.com/.well-known/agent.json", version: "0.3.0" },
+    ],
+    supportedTrust: ["reputation"],
+  },
+  uploader,
+);
+
+const result = await sati.registerAgent({ payer, name: "MyAgent", uri });
+```
+
+### Custom Storage Providers
+
+Implement the `MetadataUploader` interface for any storage backend:
+
+```typescript
+import type { MetadataUploader } from "@cascade-fyi/sati-sdk";
+
+const arweaveUploader: MetadataUploader = {
+  async upload(data: unknown): Promise<string> {
+    // Upload to Arweave and return ar:// URI
+    return `ar://${txId}`;
+  },
+};
+```
+
 ---
 
 ## Creating Attestations

package/dist/index.cjs

@@ -3832,9 +3832,19 @@ var SATILightClientImpl = class {
 		};
 	}
 	async queryAttestations(filter, deserializer) {
+		const memcmpFilters = [];
+		memcmpFilters.push({
+			offset: BORSH_OFFSETS.SAS_SCHEMA,
+			bytes: filter.sasSchema
+		});
+		if (filter.agentMint) memcmpFilters.push({
+			offset: BORSH_OFFSETS.AGENT_MINT,
+			bytes: filter.agentMint
+		});
 		const result = await this.rpc.getCompressedAccountsByOwner(this.programId, {
 			cursor: filter.cursor,
-			limit: filter.limit
+			limit: filter.limit,
+			filters: memcmpFilters
 		});
 		const attestations = [];
 		for (const account of result.items) {
@@ -3842,8 +3852,8 @@ var SATILightClientImpl = class {
 			try {
 				const parsed = this.parseAttestation(account, deserializer);
 				if (!parsed) continue;
-				if (parsed.attestation.sasSchema !== filter.sasSchema) continue;
-				if (filter.agentMint && parsed.attestation.agentMint !== filter.agentMint) continue;
+				if (filter.counterparty && parsed.data.counterparty !== filter.counterparty) continue;
+				if (filter.outcome !== void 0 && parsed.data.outcome !== filter.outcome) continue;
 				attestations.push(parsed);
 			} catch {}
 		}
@@ -4629,6 +4639,51 @@ function deserializeEncryptedPayload(bytes) {
 	};
 }
 
+//#endregion
+//#region src/uploaders.ts
+/**
+* Create a Pinata IPFS uploader using the v3 Files API.
+*
+* @param jwt - Pinata API JWT token (requires `files:write` permission)
+* @returns MetadataUploader that pins JSON to public IPFS via Pinata
+*
+* @example
+* ```typescript
+* const uploader = createPinataUploader(process.env.PINATA_JWT!);
+* const uri = await uploader.upload({ name: "MyAgent" });
+* // "ipfs://QmXyz..."
+* ```
+*/
+function createPinataUploader(jwt) {
+	return { async upload(data) {
+		const jsonStr = JSON.stringify(data, null, 2);
+		const blob = new Blob([jsonStr], { type: "application/json" });
+		const formData = new FormData();
+		formData.append("file", blob, "registration.json");
+		formData.append("network", "public");
+		const response = await fetch("https://uploads.pinata.cloud/v3/files", {
+			method: "POST",
+			headers: { Authorization: `Bearer ${jwt}` },
+			body: formData
+		});
+		if (!response.ok) {
+			const text = await response.text();
+			throw new Error(`IPFS upload failed (${response.status}): ${text}`);
+		}
+		const result = await response.json();
+		const cid = result.data?.cid;
+		if (!cid) throw new Error(`No CID returned from Pinata. Response: ${JSON.stringify(result)}`);
+		try {
+			const verifyResponse = await fetch(`https://gateway.pinata.cloud/ipfs/${cid}`, { signal: AbortSignal.timeout(5e3) });
+			if (!verifyResponse.ok && verifyResponse.status !== 429) throw new Error(`Pinata returned CID ${cid} but content not accessible on gateway (HTTP ${verifyResponse.status})`);
+		} catch (verifyError) {
+			if (verifyError instanceof Error && !verifyError.message.includes("not accessible")) console.warn(`[SATI] Pinata gateway verification skipped for ${cid}: ${verifyError.message}`);
+			else throw verifyError;
+		}
+		return `ipfs://${cid}`;
+	} };
+}
+
 //#endregion
 //#region src/deployed/devnet.json
 var config$1 = {
@@ -4691,6 +4746,221 @@ function getDeployedNetworks() {
 	return Object.entries(configs).filter(([_, config$2]) => config$2 !== null).map(([network]) => network);
 }
 
+//#endregion
+//#region src/registration.ts
+/**
+* SATI Registration File
+*
+* Helpers for building, fetching, and working with ERC-8004 + Phantom
+* compatible registration files.
+*
+* @example
+* ```typescript
+* import {
+*   buildRegistrationFile,
+*   fetchRegistrationFile,
+*   getImageUrl,
+* } from "@cascade-fyi/sati-sdk";
+*
+* // Build a registration file
+* const file = buildRegistrationFile({
+*   name: "MyAgent",
+*   description: "AI assistant",
+*   image: "https://example.com/avatar.png",
+* });
+*
+* // Fetch from URI
+* const metadata = await fetchRegistrationFile(uri);
+* const imageUrl = getImageUrl(metadata);
+* ```
+*/
+const PropertyFileSchema = zod.object({
+	uri: zod.url(),
+	type: zod.string()
+});
+const PropertiesSchema = zod.object({
+	files: zod.array(PropertyFileSchema).min(1),
+	category: zod.enum([
+		"image",
+		"video",
+		"audio"
+	]).optional()
+});
+const EndpointSchema = zod.object({
+	name: zod.string(),
+	endpoint: zod.string(),
+	version: zod.string().optional(),
+	mcpTools: zod.array(zod.string()).optional(),
+	mcpPrompts: zod.array(zod.string()).optional(),
+	mcpResources: zod.array(zod.string()).optional(),
+	a2aSkills: zod.array(zod.string()).optional(),
+	skills: zod.array(zod.string()).optional(),
+	domains: zod.array(zod.string()).optional()
+});
+const RegistrationEntrySchema = zod.object({
+	agentId: zod.union([zod.string(), zod.number()]),
+	agentRegistry: zod.string()
+});
+const TrustMechanismSchema = zod.enum([
+	"reputation",
+	"crypto-economic",
+	"tee-attestation"
+]);
+const RegistrationFileSchema = zod.object({
+	type: zod.literal("https://eips.ethereum.org/EIPS/eip-8004#registration-v1"),
+	name: zod.string().min(1),
+	description: zod.string().min(1),
+	image: zod.url(),
+	properties: PropertiesSchema,
+	external_url: zod.url().optional(),
+	endpoints: zod.array(EndpointSchema).optional(),
+	registrations: zod.array(RegistrationEntrySchema).optional(),
+	supportedTrust: zod.array(TrustMechanismSchema).optional(),
+	active: zod.boolean().optional().default(true),
+	x402support: zod.boolean().optional()
+});
+const MIME_TYPES = {
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	webp: "image/webp",
+	svg: "image/svg+xml"
+};
+/**
+* Infer MIME type from image URL extension.
+* Returns "image/png" as default if unrecognized.
+*/
+function inferMimeType(url) {
+	return MIME_TYPES[url.split(".").pop()?.toLowerCase().split("?")[0] ?? ""] ?? "image/png";
+}
+/**
+* Build a registration file from parameters.
+*
+* Automatically:
+* - Sets the ERC-8004 type identifier
+* - Generates properties.files from image URL
+* - Infers MIME type from extension
+* - Sets active to true by default
+*
+* @throws Error if required fields are missing or invalid
+*/
+function buildRegistrationFile(params) {
+	const mimeType = params.imageMimeType ?? inferMimeType(params.image);
+	const file = {
+		type: "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
+		name: params.name,
+		description: params.description,
+		image: params.image,
+		properties: {
+			files: [{
+				uri: params.image,
+				type: mimeType
+			}],
+			category: "image"
+		},
+		...params.externalUrl && { external_url: params.externalUrl },
+		...params.endpoints?.length && { endpoints: params.endpoints },
+		...params.registrations?.length && { registrations: params.registrations },
+		...params.supportedTrust?.length && { supportedTrust: params.supportedTrust },
+		active: params.active ?? true,
+		...params.x402support !== void 0 && { x402support: params.x402support }
+	};
+	return RegistrationFileSchema.parse(file);
+}
+/**
+* Fetch and parse a registration file from URI.
+*
+* - Returns null on network errors or invalid URIs
+* - Validates structure, logs warnings for non-conforming files
+* - Never throws
+*/
+async function fetchRegistrationFile(uri) {
+	if (!uri) return null;
+	let url = uri;
+	if (uri.startsWith("ipfs://")) url = `https://ipfs.io/ipfs/${uri.slice(7)}`;
+	else if (uri.startsWith("ar://")) url = `https://arweave.net/${uri.slice(5)}`;
+	else if (!uri.startsWith("http://") && !uri.startsWith("https://")) return null;
+	try {
+		const response = await fetch(url);
+		if (!response.ok) {
+			console.warn(`[SATI] Failed to fetch metadata from ${url}: ${response.status}`);
+			return null;
+		}
+		const data = await response.json();
+		const result = RegistrationFileSchema.safeParse(data);
+		if (!result.success) {
+			console.warn(`[SATI] Registration file validation issues:`, result.error.issues);
+			return data;
+		}
+		return result.data;
+	} catch (error) {
+		console.warn(`[SATI] Failed to fetch metadata from ${uri}:`, error);
+		return null;
+	}
+}
+/**
+* Extract image URL from a registration file.
+*
+* Prefers properties.files (Phantom format), falls back to image field.
+* Handles IPFS/Arweave URI conversion.
+*/
+function getImageUrl(file) {
+	if (!file) return null;
+	const uri = file.properties?.files?.[0]?.uri ?? file.image;
+	if (!uri) return null;
+	if (uri.startsWith("ipfs://")) return `https://ipfs.io/ipfs/${uri.slice(7)}`;
+	if (uri.startsWith("ar://")) return `https://arweave.net/${uri.slice(5)}`;
+	if (uri.startsWith("http://") || uri.startsWith("https://")) return uri;
+	return null;
+}
+/**
+* Serialize a registration file to JSON string.
+*/
+function stringifyRegistrationFile(file, space = 2) {
+	return JSON.stringify(file, null, space);
+}
+/** CAIP-2 chain identifier for Solana mainnet */
+const SATI_CHAIN_ID = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+/** SATI program ID */
+const SATI_PROGRAM_ID = "satiRkxEiwZ51cv8PRu8UMzuaqeaNU9jABo6oAFMsLe";
+/**
+* Build a registrations[] entry for linking a SATI agent to an off-chain registration file.
+*
+* @param agentMint - SATI agent mint address
+* @returns RegistrationEntry for the registrations[] array
+*
+* @example
+* ```typescript
+* const entry = buildSatiRegistrationEntry("AgentMint...");
+* // { agentId: "AgentMint...", agentRegistry: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:satiR3q7..." }
+* ```
+*/
+function buildSatiRegistrationEntry(agentMint) {
+	return {
+		agentId: agentMint,
+		agentRegistry: `${SATI_CHAIN_ID}:${SATI_PROGRAM_ID}`
+	};
+}
+/**
+* Check if a registration file contains a SATI registration.
+*
+* @param file - Registration file to check
+* @returns true if file contains at least one SATI registration
+*/
+function hasSatiRegistration(file) {
+	return file.registrations?.some((r) => typeof r.agentRegistry === "string" && r.agentRegistry.startsWith(SATI_CHAIN_ID)) ?? false;
+}
+/**
+* Find SATI agent IDs from a registration file.
+*
+* @param file - Registration file to search
+* @returns Array of SATI agent mint addresses
+*/
+function getSatiAgentIds(file) {
+	return file.registrations?.filter((r) => typeof r.agentRegistry === "string" && r.agentRegistry.startsWith(SATI_CHAIN_ID)).map((r) => String(r.agentId)) ?? [];
+}
+
 //#endregion
 //#region src/client.ts
 /**
@@ -4842,6 +5112,25 @@ var Sati = class {
 		};
 	}
 	/**
+	* Build a registration file from params, upload it via the provided uploader,
+	* and return the resulting URI.
+	*
+	* @example
+	* ```typescript
+	* import { createPinataUploader } from "@cascade-fyi/sati-sdk";
+	*
+	* const uploader = createPinataUploader(process.env.PINATA_JWT!);
+	* const uri = await sati.uploadRegistrationFile(
+	*   { name: "MyAgent", description: "AI assistant", image: "https://example.com/img.png" },
+	*   uploader,
+	* );
+	* ```
+	*/
+	async uploadRegistrationFile(params, uploader) {
+		const regFile = buildRegistrationFile(params);
+		return uploader.upload(regFile);
+	}
+	/**
 	* Load agent identity from mint address
 	*/
 	async loadAgent(mint) {
@@ -5892,215 +6181,6 @@ var Sati = class {
 	}
 };
 
-//#endregion
-//#region src/registration.ts
-/**
-* SATI Registration File
-*
-* Helpers for building, fetching, and working with ERC-8004 + Phantom
-* compatible registration files.
-*
-* @example
-* ```typescript
-* import {
-*   buildRegistrationFile,
-*   fetchRegistrationFile,
-*   getImageUrl,
-* } from "@cascade-fyi/sati-sdk";
-*
-* // Build a registration file
-* const file = buildRegistrationFile({
-*   name: "MyAgent",
-*   description: "AI assistant",
-*   image: "https://example.com/avatar.png",
-* });
-*
-* // Fetch from URI
-* const metadata = await fetchRegistrationFile(uri);
-* const imageUrl = getImageUrl(metadata);
-* ```
-*/
-const PropertyFileSchema = zod.object({
-	uri: zod.url(),
-	type: zod.string()
-});
-const PropertiesSchema = zod.object({
-	files: zod.array(PropertyFileSchema).min(1),
-	category: zod.enum([
-		"image",
-		"video",
-		"audio"
-	]).optional()
-});
-const EndpointSchema = zod.object({
-	name: zod.string(),
-	endpoint: zod.string(),
-	version: zod.string().optional()
-});
-const RegistrationEntrySchema = zod.object({
-	agentId: zod.union([zod.string(), zod.number()]),
-	agentRegistry: zod.string()
-});
-const TrustMechanismSchema = zod.enum([
-	"reputation",
-	"crypto-economic",
-	"tee-attestation"
-]);
-const RegistrationFileSchema = zod.object({
-	type: zod.literal("https://eips.ethereum.org/EIPS/eip-8004#registration-v1"),
-	name: zod.string().min(1),
-	description: zod.string().min(1),
-	image: zod.url(),
-	properties: PropertiesSchema,
-	external_url: zod.url().optional(),
-	endpoints: zod.array(EndpointSchema).optional(),
-	registrations: zod.array(RegistrationEntrySchema).optional(),
-	supportedTrust: zod.array(TrustMechanismSchema).optional(),
-	active: zod.boolean().optional().default(true),
-	x402support: zod.boolean().optional()
-});
-const MIME_TYPES = {
-	png: "image/png",
-	jpg: "image/jpeg",
-	jpeg: "image/jpeg",
-	gif: "image/gif",
-	webp: "image/webp",
-	svg: "image/svg+xml"
-};
-/**
-* Infer MIME type from image URL extension.
-* Returns "image/png" as default if unrecognized.
-*/
-function inferMimeType(url) {
-	return MIME_TYPES[url.split(".").pop()?.toLowerCase().split("?")[0] ?? ""] ?? "image/png";
-}
-/**
-* Build a registration file from parameters.
-*
-* Automatically:
-* - Sets the ERC-8004 type identifier
-* - Generates properties.files from image URL
-* - Infers MIME type from extension
-* - Sets active to true by default
-*
-* @throws Error if required fields are missing or invalid
-*/
-function buildRegistrationFile(params) {
-	const mimeType = params.imageMimeType ?? inferMimeType(params.image);
-	const file = {
-		type: "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
-		name: params.name,
-		description: params.description,
-		image: params.image,
-		properties: {
-			files: [{
-				uri: params.image,
-				type: mimeType
-			}],
-			category: "image"
-		},
-		...params.externalUrl && { external_url: params.externalUrl },
-		...params.endpoints?.length && { endpoints: params.endpoints },
-		...params.registrations?.length && { registrations: params.registrations },
-		...params.supportedTrust?.length && { supportedTrust: params.supportedTrust },
-		active: params.active ?? true,
-		...params.x402support !== void 0 && { x402support: params.x402support }
-	};
-	return RegistrationFileSchema.parse(file);
-}
-/**
-* Fetch and parse a registration file from URI.
-*
-* - Returns null on network errors or invalid URIs
-* - Validates structure, logs warnings for non-conforming files
-* - Never throws
-*/
-async function fetchRegistrationFile(uri) {
-	if (!uri) return null;
-	let url = uri;
-	if (uri.startsWith("ipfs://")) url = `https://ipfs.io/ipfs/${uri.slice(7)}`;
-	else if (uri.startsWith("ar://")) url = `https://arweave.net/${uri.slice(5)}`;
-	else if (!uri.startsWith("http://") && !uri.startsWith("https://")) return null;
-	try {
-		const response = await fetch(url);
-		if (!response.ok) {
-			console.warn(`[SATI] Failed to fetch metadata from ${url}: ${response.status}`);
-			return null;
-		}
-		const data = await response.json();
-		const result = RegistrationFileSchema.safeParse(data);
-		if (!result.success) {
-			console.warn(`[SATI] Registration file validation issues:`, result.error.issues);
-			return data;
-		}
-		return result.data;
-	} catch (error) {
-		console.warn(`[SATI] Failed to fetch metadata from ${uri}:`, error);
-		return null;
-	}
-}
-/**
-* Extract image URL from a registration file.
-*
-* Prefers properties.files (Phantom format), falls back to image field.
-* Handles IPFS/Arweave URI conversion.
-*/
-function getImageUrl(file) {
-	if (!file) return null;
-	const uri = file.properties?.files?.[0]?.uri ?? file.image;
-	if (!uri) return null;
-	if (uri.startsWith("ipfs://")) return `https://ipfs.io/ipfs/${uri.slice(7)}`;
-	if (uri.startsWith("ar://")) return `https://arweave.net/${uri.slice(5)}`;
-	if (uri.startsWith("http://") || uri.startsWith("https://")) return uri;
-	return null;
-}
-/**
-* Serialize a registration file to JSON string.
-*/
-function stringifyRegistrationFile(file, space = 2) {
-	return JSON.stringify(file, null, space);
-}
-/** CAIP-2 chain identifier for Solana mainnet */
-const SATI_CHAIN_ID = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
-/** SATI program ID */
-const SATI_PROGRAM_ID = "satiRkxEiwZ51cv8PRu8UMzuaqeaNU9jABo6oAFMsLe";
-/**
-* Build a registrations[] entry for linking a SATI agent to an off-chain registration file.
-*
-* @param agentMint - SATI agent mint address
-* @returns RegistrationEntry for the registrations[] array
-*
-* @example
-* ```typescript
-* const entry = buildSatiRegistrationEntry("AgentMint...");
-* // { agentId: "AgentMint...", agentRegistry: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:satiR3q7..." }
-* ```
-*/
-function buildSatiRegistrationEntry(agentMint) {
-	return {
-		agentId: agentMint,
-		agentRegistry: `${SATI_CHAIN_ID}:${SATI_PROGRAM_ID}`
-	};
-}
-/**
-* Check if a registration file contains a SATI registration.
-*
-* @param file - Registration file to check
-* @returns true if file contains at least one SATI registration
-*/
-function hasSatiRegistration(file) {
-	return file.registrations?.some((r) => typeof r.agentRegistry === "string" && r.agentRegistry.startsWith(SATI_CHAIN_ID)) ?? false;
-}
-/**
-* Find SATI agent IDs from a registration file.
-*
-* @param file - Registration file to search
-* @returns Array of SATI agent mint addresses
-*/
-function getSatiAgentIds(file) {
-	return file.registrations?.filter((r) => typeof r.agentRegistry === "string" && r.agentRegistry.startsWith(SATI_CHAIN_ID)).map((r) => String(r.agentId)) ?? [];
-}
-
 //#endregion
 //#region src/errors.ts
 /** Base class for all SATI SDK errors */
@@ -6398,6 +6478,7 @@ exports.computeReputationNonce = computeReputationNonce;
 exports.createBatchEd25519Instruction = createBatchEd25519Instruction;
 exports.createEd25519Instruction = createEd25519Instruction;
 exports.createJsonContent = createJsonContent;
+exports.createPinataUploader = createPinataUploader;
 exports.createSATILightClient = createSATILightClient;
 exports.decodeAgentIndex = decodeAgentIndex;
 exports.decodeRegistryConfig = decodeRegistryConfig;