@solana-mobile/dapp-store-cli 0.14.0 → 0.16.0

package/src/upload/TurboStorageDriver.ts

@@ -3,6 +3,7 @@ import type { MetaplexFile } from "@metaplex-foundation/js";
 import { TurboFactory, lamportToTokenAmount } from "@ardrive/turbo-sdk";
 import bs58 from "bs58";
 import debugModule from "debug";
+import { buildPublicContentUrl, type StorageNetwork } from "./contentGateway.js";
 
 const debug = debugModule("cli:turbo-storage");
 
@@ -22,18 +23,33 @@ interface TurboClient {
   }): Promise<{ id: string }>;
 }
 
+type TurboServiceConfig = {
+  gatewayUrl?: string;
+  paymentServiceConfig?: { url: string };
+  uploadServiceConfig?: { url: string };
+};
+
+const SOL_IN_LAMPORTS = 1_000_000_000;
+const MIN_TOP_UP_LAMPORTS = 1_000_000;
+const MIN_TOP_UP_SOL = MIN_TOP_UP_LAMPORTS / SOL_IN_LAMPORTS;
+
 const CONSTANTS = {
   FREE_UPLOAD_LIMIT: 97_280, // 95 KiB
   UPLOAD_DELAY_MS: 2000,
   MAX_RETRIES: 5,
-  SOL_IN_LAMPORTS: 1_000_000_000,
+  SOL_IN_LAMPORTS,
+  MIN_TOP_UP_SOL,
+  MIN_TOP_UP_LAMPORTS,
   BACKOFF: {
     BASE_MS: 500,
     MAX_MS: 8000,
   },
-  GATEWAYS: {
-    devnet: "https://turbo.ardrive.dev/raw",
-    mainnet: "https://arweave.net",
+  SERVICE_URLS: {
+    devnet: {
+      gatewayUrl: "https://api.devnet.solana.com",
+      uploadServiceConfig: { url: "https://upload.ardrive.dev" },
+      paymentServiceConfig: { url: "https://payment.ardrive.dev" },
+    },
   },
 } as const;
 
@@ -43,7 +59,7 @@ const delay = (ms: number): Promise<void> =>
 export class TurboStorageDriver {
   private turbo: TurboClient;
   private bufferPercentage: number;
-  private network: "devnet" | "mainnet";
+  private network: StorageNetwork;
 
   private uploadQueue: Array<{
     file: MetaplexFile;
@@ -54,7 +70,7 @@ export class TurboStorageDriver {
 
   constructor(
     keypair: Keypair,
-    network: "devnet" | "mainnet" = "mainnet",
+    network: StorageNetwork = "mainnet",
     bufferPercentage = 20
   ) {
     this.network = network;
@@ -63,18 +79,10 @@ export class TurboStorageDriver {
     this.turbo = TurboFactory.authenticated({
       privateKey: bs58.encode(keypair.secretKey),
       token: "solana",
-      ...this.getServiceUrls(network === "devnet"),
+      ...getTurboServiceConfig(network),
     }) as TurboClient;
   }
 
-  private getServiceUrls(isDev: boolean) {
-    const base = isDev ? "ardrive.dev" : "ardrive.io";
-    return {
-      uploadUrl: `https://upload.${base}`,
-      paymentUrl: `https://payment.${base}`,
-    };
-  }
-
   async getUploadPrice(bytes: number): Promise<bigint> {
     if (bytes <= CONSTANTS.FREE_UPLOAD_LIMIT) return BigInt(0);
 
@@ -131,6 +139,11 @@ export class TurboStorageDriver {
   }
 
   private async topUpCredits(wincAmount: bigint): Promise<void> {
+    if (wincAmount === 0n) {
+      debug("No Winston Credits requested; skipping top-up.");
+      return;
+    }
+
     try {
       await this.withRetry(async () => {
         const exchangeRate = await this.turbo.getWincForToken?.({
@@ -142,17 +155,35 @@ export class TurboStorageDriver {
         }
 
         const wincPerSol = BigInt(String(exchangeRate.winc));
-        const lamportsNeeded =
-          (wincAmount * BigInt(CONSTANTS.SOL_IN_LAMPORTS)) / wincPerSol;
+        if (wincPerSol <= 0n) {
+          throw new Error("Invalid Winston Credits exchange rate");
+        }
+
+        const solInLamports = BigInt(CONSTANTS.SOL_IN_LAMPORTS);
+        const numerator = wincAmount * solInLamports;
+        const lamportsCalculated =
+          (numerator + (wincPerSol - 1n)) / wincPerSol;
+
+        const minLamports = BigInt(CONSTANTS.MIN_TOP_UP_LAMPORTS);
+        const lamportsToUse =
+          lamportsCalculated < minLamports ? minLamports : lamportsCalculated;
+
+        if (lamportsToUse > lamportsCalculated) {
+          debug(
+            `Applying minimum top-up of ${CONSTANTS.MIN_TOP_UP_SOL} SOL (${CONSTANTS.MIN_TOP_UP_LAMPORTS} lamports)`
+          );
+        }
+        const solAmount =
+          Number(lamportsToUse) / CONSTANTS.SOL_IN_LAMPORTS;
 
         debug(
-          `Buying ${wincAmount} Winston Credits for ~${
-            Number(lamportsNeeded) / 1e9
-          } SOL`
+          `Buying at least ${wincAmount} Winston Credits (~${solAmount.toFixed(9)} SOL / ${lamportsToUse} lamports)`
         );
 
         await this.turbo.topUpWithTokens?.({
-          tokenAmount: String(lamportToTokenAmount(lamportsNeeded.toString())),
+          tokenAmount: String(
+            lamportToTokenAmount(lamportsToUse.toString())
+          ),
         });
 
         debug(`Top-up initiated for ${wincAmount} Winston Credits`);
@@ -219,8 +250,7 @@ export class TurboStorageDriver {
           dataItemOpts: { tags },
         });
 
-        const gateway = CONSTANTS.GATEWAYS[this.network];
-        const url = `${gateway}/${uploadResult.id}`;
+        const url = buildPublicContentUrl(uploadResult.id, this.network);
         debug(`Upload complete: ${url}`);
         item.resolve(url);
 
@@ -246,3 +276,8 @@ export class TurboStorageDriver {
     });
   }
 }
+
+export const getTurboServiceConfig = (
+  network: StorageNetwork
+): TurboServiceConfig =>
+  network === "devnet" ? CONSTANTS.SERVICE_URLS.devnet : {};

package/src/upload/__tests__/CachedStorageDriver.test.ts

@@ -0,0 +1,246 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { createHash } from "crypto";
+import { jest } from "@jest/globals";
+import type { MetaplexFile, StorageDriver } from "@metaplex-foundation/js";
+import { CachedStorageDriver } from "../CachedStorageDriver";
+
+type MockStorageDriver = Pick<StorageDriver, "getUploadPrice" | "upload">;
+
+describe("CachedStorageDriver", () => {
+  const originalCwd = process.cwd();
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "cached-storage-driver-"));
+    process.chdir(tempDir);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  test("normalizes a cached legacy arweave URL and persists the rewritten manifest", async () => {
+    const file = makeMetaplexFile("icon.png", Buffer.from("cached-asset"));
+    const hash = hashBuffer(file.buffer);
+    const manifestPath = ".asset-manifest.json";
+
+    fs.writeFileSync(
+      path.join(tempDir, manifestPath),
+      JSON.stringify(
+        {
+          assets: {
+            [file.fileName]: {
+              path: file.fileName,
+              sha256: hash,
+              uri: "https://arweave.net/legacy-id",
+            },
+          },
+        },
+        null,
+        2
+      )
+    );
+
+    let uploadCalls = 0;
+    const storageDriver: MockStorageDriver = {
+      getUploadPrice: async (_bytes: number) => {
+        throw new Error("getUploadPrice should not be called in this test");
+      },
+      upload: async (_file: MetaplexFile) => {
+        uploadCalls += 1;
+        throw new Error("upload should not be called in this test");
+      },
+    };
+
+    const driver = new CachedStorageDriver(storageDriver as StorageDriver, {
+      assetManifestPath: manifestPath,
+    });
+
+    await expect(driver.upload(file)).resolves.toBe(
+      "https://dappstorecontent.com/legacy-id"
+    );
+    expect(uploadCalls).toBe(0);
+
+    const rewrittenManifest = JSON.parse(
+      fs.readFileSync(path.join(tempDir, manifestPath), "utf-8")
+    );
+    expect(rewrittenManifest.schema_version).toBe("0.1");
+    expect(rewrittenManifest.assets[file.fileName].uri).toBe(
+      "https://dappstorecontent.com/legacy-id"
+    );
+  });
+
+  test("supports absolute asset manifest paths", async () => {
+    const file = makeMetaplexFile("absolute-icon.png", Buffer.from("cached-asset"));
+    const hash = hashBuffer(file.buffer);
+    const manifestPath = path.join(tempDir, ".asset-manifest.json");
+
+    fs.writeFileSync(
+      manifestPath,
+      JSON.stringify(
+        {
+          assets: {
+            [file.fileName]: {
+              path: file.fileName,
+              sha256: hash,
+              uri: "https://arweave.net/absolute-id",
+            },
+          },
+        },
+        null,
+        2
+      )
+    );
+
+    let uploadCalls = 0;
+    const storageDriver: MockStorageDriver = {
+      getUploadPrice: async (_bytes: number) => {
+        throw new Error("getUploadPrice should not be called in this test");
+      },
+      upload: async (_file: MetaplexFile) => {
+        uploadCalls += 1;
+        throw new Error("upload should not be called in this test");
+      },
+    };
+
+    const driver = new CachedStorageDriver(storageDriver as StorageDriver, {
+      assetManifestPath: manifestPath,
+    });
+
+    await expect(driver.upload(file)).resolves.toBe(
+      "https://dappstorecontent.com/absolute-id"
+    );
+    expect(uploadCalls).toBe(0);
+
+    const rewrittenManifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+    expect(rewrittenManifest.assets[file.fileName].uri).toBe(
+      "https://dappstorecontent.com/absolute-id"
+    );
+  });
+
+  test("normalizes fresh uploads before persisting them in the manifest", async () => {
+    const file = makeMetaplexFile("banner.png", Buffer.from("fresh-asset"));
+    const manifestPath = ".asset-manifest.json";
+
+    let uploadCalls = 0;
+    const storageDriver: MockStorageDriver = {
+      getUploadPrice: async (_bytes: number) => {
+        throw new Error("getUploadPrice should not be called in this test");
+      },
+      upload: async (_file: MetaplexFile) => {
+        uploadCalls += 1;
+        return "https://arweave.com/fresh-id";
+      },
+    };
+
+    const driver = new CachedStorageDriver(storageDriver as StorageDriver, {
+      assetManifestPath: manifestPath,
+    });
+
+    await expect(driver.upload(file)).resolves.toBe(
+      "https://dappstorecontent.com/fresh-id"
+    );
+    expect(uploadCalls).toBe(1);
+
+    const persistedManifest = JSON.parse(
+      fs.readFileSync(path.join(tempDir, manifestPath), "utf-8")
+    );
+    expect(persistedManifest.schema_version).toBe("0.1");
+    expect(persistedManifest.assets[file.fileName].uri).toBe(
+      "https://dappstorecontent.com/fresh-id"
+    );
+  });
+
+  test("normalizes inline metadata uploads without caching them", async () => {
+    const file = makeMetaplexFile("inline.json", Buffer.from("{}"));
+    let uploadCalls = 0;
+    const storageDriver: MockStorageDriver = {
+      getUploadPrice: async (_bytes: number) => {
+        throw new Error("getUploadPrice should not be called in this test");
+      },
+      upload: async (_file: MetaplexFile) => {
+        uploadCalls += 1;
+        return "https://arweave.net/metadata-id";
+      },
+    };
+
+    const driver = new CachedStorageDriver(storageDriver as StorageDriver, {
+      assetManifestPath: ".asset-manifest.json",
+    });
+
+    await expect(driver.upload(file)).resolves.toBe(
+      "https://dappstorecontent.com/metadata-id"
+    );
+    expect(uploadCalls).toBe(1);
+    expect(fs.existsSync(path.join(tempDir, ".asset-manifest.json"))).toBe(
+      false
+    );
+  });
+
+  test("returns a normalized cached URL even when manifest rewrite persistence fails", async () => {
+    const file = makeMetaplexFile("icon.png", Buffer.from("cached-asset"));
+    const hash = hashBuffer(file.buffer);
+    const manifestPath = ".asset-manifest.json";
+
+    fs.writeFileSync(
+      path.join(tempDir, manifestPath),
+      JSON.stringify(
+        {
+          assets: {
+            [file.fileName]: {
+              path: file.fileName,
+              sha256: hash,
+              uri: "https://arweave.net/rewrite-failure-id",
+            },
+          },
+        },
+        null,
+        2
+      )
+    );
+
+    const writeFileSpy = jest
+      .spyOn(fs.promises, "writeFile")
+      .mockRejectedValueOnce(new Error("disk full"));
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => undefined);
+
+    const storageDriver: MockStorageDriver = {
+      getUploadPrice: async (_bytes: number) => {
+        throw new Error("getUploadPrice should not be called in this test");
+      },
+      upload: async (_file: MetaplexFile) => {
+        throw new Error("upload should not be called in this test");
+      },
+    };
+
+    const driver = new CachedStorageDriver(storageDriver as StorageDriver, {
+      assetManifestPath: manifestPath,
+    });
+
+    try {
+      await expect(driver.upload(file)).resolves.toBe(
+        "https://dappstorecontent.com/rewrite-failure-id"
+      );
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining(
+          "Failed to rewrite .asset-manifest.json; continuing with normalized URL"
+        )
+      );
+    } finally {
+      writeFileSpy.mockRestore();
+      warnSpy.mockRestore();
+    }
+  });
+});
+
+const makeMetaplexFile = (fileName: string, buffer: Buffer): MetaplexFile =>
+  ({
+    fileName,
+    buffer,
+  }) as MetaplexFile;
+
+const hashBuffer = (buffer: Buffer): string =>
+  createHash("sha256").update(buffer).digest("base64");

package/src/upload/__tests__/TurboStorageDriver.test.ts

@@ -0,0 +1,15 @@
+import { getTurboServiceConfig } from "../TurboStorageDriver";
+
+describe("TurboStorageDriver", () => {
+  test("uses the latest Turbo SDK service config shape for devnet", () => {
+    expect(getTurboServiceConfig("devnet")).toEqual({
+      gatewayUrl: "https://api.devnet.solana.com",
+      uploadServiceConfig: { url: "https://upload.ardrive.dev" },
+      paymentServiceConfig: { url: "https://payment.ardrive.dev" },
+    });
+  });
+
+  test("relies on the SDK defaults for mainnet service URLs", () => {
+    expect(getTurboServiceConfig("mainnet")).toEqual({});
+  });
+});

package/src/upload/__tests__/contentGateway.test.ts

@@ -0,0 +1,31 @@
+import { buildPublicContentUrl, normalizePublicContentUrl } from "../contentGateway";
+
+describe("contentGateway", () => {
+  test("builds a mainnet dappstorecontent URL from an upload id", () => {
+    expect(buildPublicContentUrl("abc123", "mainnet")).toBe(
+      "https://dappstorecontent.com/abc123"
+    );
+  });
+
+  test("builds a devnet Turbo raw URL from an upload id", () => {
+    expect(buildPublicContentUrl("abc123", "devnet")).toBe(
+      "https://turbo.ardrive.dev/raw/abc123"
+    );
+  });
+
+  test("normalizes arweave.net and arweave.com URLs to dappstorecontent", () => {
+    expect(normalizePublicContentUrl("https://arweave.net/abc123")).toBe(
+      "https://dappstorecontent.com/abc123"
+    );
+    expect(
+      normalizePublicContentUrl("https://www.arweave.com/abc123?ext=png")
+    ).toBe("https://dappstorecontent.com/abc123?ext=png");
+  });
+
+  test("leaves non-arweave URLs unchanged", () => {
+    expect(
+      normalizePublicContentUrl("https://turbo.ardrive.dev/raw/abc123")
+    ).toBe("https://turbo.ardrive.dev/raw/abc123");
+    expect(normalizePublicContentUrl("not-a-url")).toBe("not-a-url");
+  });
+});

package/src/upload/contentGateway.ts

@@ -0,0 +1,37 @@
+export type StorageNetwork = "devnet" | "mainnet";
+
+const MAINNET_PUBLIC_CONTENT_GATEWAY = "https://dappstorecontent.com";
+const DEVNET_PUBLIC_CONTENT_GATEWAY = "https://turbo.ardrive.dev/raw";
+
+const LEGACY_MAINNET_CONTENT_HOSTS = new Set([
+  "arweave.net",
+  "www.arweave.net",
+  "arweave.com",
+  "www.arweave.com",
+]);
+
+export const buildPublicContentUrl = (
+  id: string,
+  network: StorageNetwork
+): string => {
+  const gateway =
+    network === "devnet"
+      ? DEVNET_PUBLIC_CONTENT_GATEWAY
+      : MAINNET_PUBLIC_CONTENT_GATEWAY;
+
+  return `${gateway}/${id}`;
+};
+
+export const normalizePublicContentUrl = (url: string): string => {
+  try {
+    const parsed = new URL(url);
+
+    if (!LEGACY_MAINNET_CONTENT_HOSTS.has(parsed.host.toLowerCase())) {
+      return url;
+    }
+
+    return `${MAINNET_PUBLIC_CONTENT_GATEWAY}${parsed.pathname}${parsed.search}${parsed.hash}`;
+  } catch {
+    return url;
+  }
+};