mneme-sdk 0.0.1 → 0.1.0

package/dist/index.cjs

@@ -74,6 +74,24 @@ function randomNonce() {
 }
 
 // src/client.ts
+async function toUint8Array(input) {
+  if (input instanceof Uint8Array) return input;
+  if (input instanceof ArrayBuffer) return new Uint8Array(input);
+  if (typeof Blob !== "undefined" && input instanceof Blob) {
+    return new Uint8Array(await input.arrayBuffer());
+  }
+  if (typeof input === "string") return new TextEncoder().encode(input);
+  throw new Error("unsupported file type for storage.upload");
+}
+function uint8ToBase64(bytes) {
+  const CHUNK = 32768;
+  const parts = [];
+  for (let i = 0; i < bytes.byteLength; i += CHUNK) {
+    parts.push(String.fromCharCode(...bytes.subarray(i, i + CHUNK)));
+  }
+  if (typeof btoa !== "undefined") return btoa(parts.join(""));
+  return Buffer.from(parts.join(""), "binary").toString("base64");
+}
 var MnemeError = class extends Error {
   constructor(status, message) {
     super(message);
@@ -122,6 +140,50 @@ var Mneme = class {
   from(table) {
     return new Collection(this, table);
   }
+  // ─── Storage (Cloudflare R2 backend, $MNEME burn quota) ──────────────────
+  storage = {
+    upload: async (args) => {
+      const bytes = await toUint8Array(args.file);
+      const content_base64 = uint8ToBase64(bytes);
+      return this.request("POST", "/v1/storage/upload", {
+        key: args.key,
+        visibility: args.visibility ?? "private",
+        content_type: args.contentType ?? "application/octet-stream",
+        content_base64
+      });
+    },
+    list: (args) => {
+      const q = new URLSearchParams();
+      if (args?.visibility) q.set("visibility", args.visibility);
+      if (args?.prefix) q.set("prefix", args.prefix);
+      return this.request("GET", `/v1/storage/list${q.toString() ? `?${q}` : ""}`);
+    },
+    delete: (args) => {
+      const q = new URLSearchParams({ key: args.key });
+      if (args.visibility) q.set("visibility", args.visibility);
+      return this.request(
+        "DELETE",
+        `/v1/storage/object?${q}`
+      );
+    },
+    url: (args) => {
+      const q = new URLSearchParams({ key: args.key });
+      if (args.visibility) q.set("visibility", args.visibility);
+      if (args.expiresIn != null) q.set("expires_in", String(args.expiresIn));
+      return this.request(
+        "GET",
+        `/v1/storage/url?${q}`
+      );
+    },
+    quota: () => this.request("GET", "/v1/storage/quota"),
+    /**
+     * Credit a $MNEME burn tx → extend storage capacity.
+     *   100 $MNEME →   1 GB / 30d
+     *   1000 $MNEME →  10 GB / 30d
+     *  10000 $MNEME → 100 GB / 30d
+     */
+    burn: (args) => this.request("POST", "/v1/storage/burn", { tx_hash: args.tx_hash })
+  };
   async request(method, path, body) {
     const bodyText = body === void 0 ? "" : JSON.stringify(body);
     const headers = { "Content-Type": "application/json" };

package/dist/index.d.cts

@@ -112,6 +112,75 @@ declare class Mneme {
     }>;
     stats(): Promise<StatsResponse>;
     from<T = unknown>(table: string): Collection<T>;
+    readonly storage: {
+        upload: (args: {
+            key: string;
+            file: Blob | Uint8Array | ArrayBuffer | string;
+            visibility?: "public" | "private";
+            contentType?: string;
+        }) => Promise<{
+            ok: true;
+            key: string;
+            visibility: "public" | "private";
+            size: number;
+            content_type: string;
+            public_url?: string;
+        }>;
+        list: (args?: {
+            visibility?: "public" | "private";
+            prefix?: string;
+        }) => Promise<{
+            visibility: "public" | "private";
+            count: number;
+            objects: Array<{
+                key: string;
+                size: number;
+                last_modified: string;
+                public_url?: string;
+            }>;
+        }>;
+        delete: (args: {
+            key: string;
+            visibility?: "public" | "private";
+        }) => Promise<{
+            ok: true;
+            key: string;
+            freed_bytes: number;
+        }>;
+        url: (args: {
+            key: string;
+            visibility?: "public" | "private";
+            expiresIn?: number;
+        }) => Promise<{
+            url: string;
+            expires_in: number;
+        }>;
+        quota: () => Promise<{
+            wallet: string;
+            bytes_used: number;
+            bytes_limit: number;
+            bytes_available: number;
+            free_tier_bytes: number;
+            bonus_expires_at: string | null;
+        }>;
+        /**
+         * Credit a $MNEME burn tx → extend storage capacity.
+         *   100 $MNEME →   1 GB / 30d
+         *   1000 $MNEME →  10 GB / 30d
+         *  10000 $MNEME → 100 GB / 30d
+         */
+        burn: (args: {
+            tx_hash: string;
+        }) => Promise<{
+            ok: true;
+            tx_hash: string;
+            burned_tokens: number;
+            tier: string;
+            bytes_added: number;
+            days_added: number;
+            new_expires_at: string;
+        }>;
+    };
     request<T = unknown>(method: string, path: string, body?: unknown): Promise<T>;
 }
 declare class Collection<T = unknown> {

package/dist/index.d.ts

@@ -112,6 +112,75 @@ declare class Mneme {
     }>;
     stats(): Promise<StatsResponse>;
     from<T = unknown>(table: string): Collection<T>;
+    readonly storage: {
+        upload: (args: {
+            key: string;
+            file: Blob | Uint8Array | ArrayBuffer | string;
+            visibility?: "public" | "private";
+            contentType?: string;
+        }) => Promise<{
+            ok: true;
+            key: string;
+            visibility: "public" | "private";
+            size: number;
+            content_type: string;
+            public_url?: string;
+        }>;
+        list: (args?: {
+            visibility?: "public" | "private";
+            prefix?: string;
+        }) => Promise<{
+            visibility: "public" | "private";
+            count: number;
+            objects: Array<{
+                key: string;
+                size: number;
+                last_modified: string;
+                public_url?: string;
+            }>;
+        }>;
+        delete: (args: {
+            key: string;
+            visibility?: "public" | "private";
+        }) => Promise<{
+            ok: true;
+            key: string;
+            freed_bytes: number;
+        }>;
+        url: (args: {
+            key: string;
+            visibility?: "public" | "private";
+            expiresIn?: number;
+        }) => Promise<{
+            url: string;
+            expires_in: number;
+        }>;
+        quota: () => Promise<{
+            wallet: string;
+            bytes_used: number;
+            bytes_limit: number;
+            bytes_available: number;
+            free_tier_bytes: number;
+            bonus_expires_at: string | null;
+        }>;
+        /**
+         * Credit a $MNEME burn tx → extend storage capacity.
+         *   100 $MNEME →   1 GB / 30d
+         *   1000 $MNEME →  10 GB / 30d
+         *  10000 $MNEME → 100 GB / 30d
+         */
+        burn: (args: {
+            tx_hash: string;
+        }) => Promise<{
+            ok: true;
+            tx_hash: string;
+            burned_tokens: number;
+            tier: string;
+            bytes_added: number;
+            days_added: number;
+            new_expires_at: string;
+        }>;
+    };
     request<T = unknown>(method: string, path: string, body?: unknown): Promise<T>;
 }
 declare class Collection<T = unknown> {

package/dist/index.js

@@ -42,6 +42,24 @@ function randomNonce() {
 }
 
 // src/client.ts
+async function toUint8Array(input) {
+  if (input instanceof Uint8Array) return input;
+  if (input instanceof ArrayBuffer) return new Uint8Array(input);
+  if (typeof Blob !== "undefined" && input instanceof Blob) {
+    return new Uint8Array(await input.arrayBuffer());
+  }
+  if (typeof input === "string") return new TextEncoder().encode(input);
+  throw new Error("unsupported file type for storage.upload");
+}
+function uint8ToBase64(bytes) {
+  const CHUNK = 32768;
+  const parts = [];
+  for (let i = 0; i < bytes.byteLength; i += CHUNK) {
+    parts.push(String.fromCharCode(...bytes.subarray(i, i + CHUNK)));
+  }
+  if (typeof btoa !== "undefined") return btoa(parts.join(""));
+  return Buffer.from(parts.join(""), "binary").toString("base64");
+}
 var MnemeError = class extends Error {
   constructor(status, message) {
     super(message);
@@ -90,6 +108,50 @@ var Mneme = class {
   from(table) {
     return new Collection(this, table);
   }
+  // ─── Storage (Cloudflare R2 backend, $MNEME burn quota) ──────────────────
+  storage = {
+    upload: async (args) => {
+      const bytes = await toUint8Array(args.file);
+      const content_base64 = uint8ToBase64(bytes);
+      return this.request("POST", "/v1/storage/upload", {
+        key: args.key,
+        visibility: args.visibility ?? "private",
+        content_type: args.contentType ?? "application/octet-stream",
+        content_base64
+      });
+    },
+    list: (args) => {
+      const q = new URLSearchParams();
+      if (args?.visibility) q.set("visibility", args.visibility);
+      if (args?.prefix) q.set("prefix", args.prefix);
+      return this.request("GET", `/v1/storage/list${q.toString() ? `?${q}` : ""}`);
+    },
+    delete: (args) => {
+      const q = new URLSearchParams({ key: args.key });
+      if (args.visibility) q.set("visibility", args.visibility);
+      return this.request(
+        "DELETE",
+        `/v1/storage/object?${q}`
+      );
+    },
+    url: (args) => {
+      const q = new URLSearchParams({ key: args.key });
+      if (args.visibility) q.set("visibility", args.visibility);
+      if (args.expiresIn != null) q.set("expires_in", String(args.expiresIn));
+      return this.request(
+        "GET",
+        `/v1/storage/url?${q}`
+      );
+    },
+    quota: () => this.request("GET", "/v1/storage/quota"),
+    /**
+     * Credit a $MNEME burn tx → extend storage capacity.
+     *   100 $MNEME →   1 GB / 30d
+     *   1000 $MNEME →  10 GB / 30d
+     *  10000 $MNEME → 100 GB / 30d
+     */
+    burn: (args) => this.request("POST", "/v1/storage/burn", { tx_hash: args.tx_hash })
+  };
   async request(method, path, body) {
     const bodyText = body === void 0 ? "" : JSON.stringify(body);
     const headers = { "Content-Type": "application/json" };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mneme-sdk",
-  "version": "0.0.1",
-  "description": "TypeScript SDK for Mneme — agent-native Postgres database platform on Base. Wallet-auth, runtime DDL, pgvector built-in.",
+  "version": "0.1.0",
+  "description": "TypeScript SDK for Mneme — agent-native Postgres + R2 storage on Base. Wallet-auth, runtime DDL, pgvector, wallet-bound files with $MNEME burn quota.",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",