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

package/lib/upload/__tests__/CachedStorageDriver.test.js

@@ -0,0 +1,437 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { createHash } from "crypto";
+import { jest } from "@jest/globals";
+import { CachedStorageDriver } from "../CachedStorageDriver";
+describe("CachedStorageDriver", function() {
+    var originalCwd = process.cwd();
+    var tempDir;
+    beforeEach(function() {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "cached-storage-driver-"));
+        process.chdir(tempDir);
+    });
+    afterEach(function() {
+        process.chdir(originalCwd);
+        fs.rmSync(tempDir, {
+            recursive: true,
+            force: true
+        });
+    });
+    test("normalizes a cached legacy arweave URL and persists the rewritten manifest", function() {
+        return _async_to_generator(function() {
+            var file, hash, manifestPath, uploadCalls, storageDriver, driver, rewrittenManifest;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        file = makeMetaplexFile("icon.png", Buffer.from("cached-asset"));
+                        hash = hashBuffer(file.buffer);
+                        manifestPath = ".asset-manifest.json";
+                        fs.writeFileSync(path.join(tempDir, manifestPath), JSON.stringify({
+                            assets: _define_property({}, file.fileName, {
+                                path: file.fileName,
+                                sha256: hash,
+                                uri: "https://arweave.net/legacy-id"
+                            })
+                        }, null, 2));
+                        uploadCalls = 0;
+                        storageDriver = {
+                            getUploadPrice: function(_bytes) {
+                                return _async_to_generator(function() {
+                                    return _ts_generator(this, function(_state) {
+                                        throw new Error("getUploadPrice should not be called in this test");
+                                    });
+                                })();
+                            },
+                            upload: function(_file) {
+                                return _async_to_generator(function() {
+                                    return _ts_generator(this, function(_state) {
+                                        uploadCalls += 1;
+                                        throw new Error("upload should not be called in this test");
+                                    });
+                                })();
+                            }
+                        };
+                        driver = new CachedStorageDriver(storageDriver, {
+                            assetManifestPath: manifestPath
+                        });
+                        return [
+                            4,
+                            expect(driver.upload(file)).resolves.toBe("https://dappstorecontent.com/legacy-id")
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(uploadCalls).toBe(0);
+                        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");
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    test("supports absolute asset manifest paths", function() {
+        return _async_to_generator(function() {
+            var file, hash, manifestPath, uploadCalls, storageDriver, driver, rewrittenManifest;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        file = makeMetaplexFile("absolute-icon.png", Buffer.from("cached-asset"));
+                        hash = hashBuffer(file.buffer);
+                        manifestPath = path.join(tempDir, ".asset-manifest.json");
+                        fs.writeFileSync(manifestPath, JSON.stringify({
+                            assets: _define_property({}, file.fileName, {
+                                path: file.fileName,
+                                sha256: hash,
+                                uri: "https://arweave.net/absolute-id"
+                            })
+                        }, null, 2));
+                        uploadCalls = 0;
+                        storageDriver = {
+                            getUploadPrice: function(_bytes) {
+                                return _async_to_generator(function() {
+                                    return _ts_generator(this, function(_state) {
+                                        throw new Error("getUploadPrice should not be called in this test");
+                                    });
+                                })();
+                            },
+                            upload: function(_file) {
+                                return _async_to_generator(function() {
+                                    return _ts_generator(this, function(_state) {
+                                        uploadCalls += 1;
+                                        throw new Error("upload should not be called in this test");
+                                    });
+                                })();
+                            }
+                        };
+                        driver = new CachedStorageDriver(storageDriver, {
+                            assetManifestPath: manifestPath
+                        });
+                        return [
+                            4,
+                            expect(driver.upload(file)).resolves.toBe("https://dappstorecontent.com/absolute-id")
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(uploadCalls).toBe(0);
+                        rewrittenManifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+                        expect(rewrittenManifest.assets[file.fileName].uri).toBe("https://dappstorecontent.com/absolute-id");
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    test("normalizes fresh uploads before persisting them in the manifest", function() {
+        return _async_to_generator(function() {
+            var file, manifestPath, uploadCalls, storageDriver, driver, persistedManifest;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        file = makeMetaplexFile("banner.png", Buffer.from("fresh-asset"));
+                        manifestPath = ".asset-manifest.json";
+                        uploadCalls = 0;
+                        storageDriver = {
+                            getUploadPrice: function(_bytes) {
+                                return _async_to_generator(function() {
+                                    return _ts_generator(this, function(_state) {
+                                        throw new Error("getUploadPrice should not be called in this test");
+                                    });
+                                })();
+                            },
+                            upload: function(_file) {
+                                return _async_to_generator(function() {
+                                    return _ts_generator(this, function(_state) {
+                                        uploadCalls += 1;
+                                        return [
+                                            2,
+                                            "https://arweave.com/fresh-id"
+                                        ];
+                                    });
+                                })();
+                            }
+                        };
+                        driver = new CachedStorageDriver(storageDriver, {
+                            assetManifestPath: manifestPath
+                        });
+                        return [
+                            4,
+                            expect(driver.upload(file)).resolves.toBe("https://dappstorecontent.com/fresh-id")
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(uploadCalls).toBe(1);
+                        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");
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    test("normalizes inline metadata uploads without caching them", function() {
+        return _async_to_generator(function() {
+            var file, uploadCalls, storageDriver, driver;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        file = makeMetaplexFile("inline.json", Buffer.from("{}"));
+                        uploadCalls = 0;
+                        storageDriver = {
+                            getUploadPrice: function(_bytes) {
+                                return _async_to_generator(function() {
+                                    return _ts_generator(this, function(_state) {
+                                        throw new Error("getUploadPrice should not be called in this test");
+                                    });
+                                })();
+                            },
+                            upload: function(_file) {
+                                return _async_to_generator(function() {
+                                    return _ts_generator(this, function(_state) {
+                                        uploadCalls += 1;
+                                        return [
+                                            2,
+                                            "https://arweave.net/metadata-id"
+                                        ];
+                                    });
+                                })();
+                            }
+                        };
+                        driver = new CachedStorageDriver(storageDriver, {
+                            assetManifestPath: ".asset-manifest.json"
+                        });
+                        return [
+                            4,
+                            expect(driver.upload(file)).resolves.toBe("https://dappstorecontent.com/metadata-id")
+                        ];
+                    case 1:
+                        _state.sent();
+                        expect(uploadCalls).toBe(1);
+                        expect(fs.existsSync(path.join(tempDir, ".asset-manifest.json"))).toBe(false);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    test("returns a normalized cached URL even when manifest rewrite persistence fails", function() {
+        return _async_to_generator(function() {
+            var file, hash, manifestPath, writeFileSpy, warnSpy, storageDriver, driver;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        file = makeMetaplexFile("icon.png", Buffer.from("cached-asset"));
+                        hash = hashBuffer(file.buffer);
+                        manifestPath = ".asset-manifest.json";
+                        fs.writeFileSync(path.join(tempDir, manifestPath), JSON.stringify({
+                            assets: _define_property({}, file.fileName, {
+                                path: file.fileName,
+                                sha256: hash,
+                                uri: "https://arweave.net/rewrite-failure-id"
+                            })
+                        }, null, 2));
+                        writeFileSpy = jest.spyOn(fs.promises, "writeFile").mockRejectedValueOnce(new Error("disk full"));
+                        warnSpy = jest.spyOn(console, "warn").mockImplementation(function() {
+                            return undefined;
+                        });
+                        storageDriver = {
+                            getUploadPrice: function(_bytes) {
+                                return _async_to_generator(function() {
+                                    return _ts_generator(this, function(_state) {
+                                        throw new Error("getUploadPrice should not be called in this test");
+                                    });
+                                })();
+                            },
+                            upload: function(_file) {
+                                return _async_to_generator(function() {
+                                    return _ts_generator(this, function(_state) {
+                                        throw new Error("upload should not be called in this test");
+                                    });
+                                })();
+                            }
+                        };
+                        driver = new CachedStorageDriver(storageDriver, {
+                            assetManifestPath: manifestPath
+                        });
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            ,
+                            3,
+                            4
+                        ]);
+                        return [
+                            4,
+                            expect(driver.upload(file)).resolves.toBe("https://dappstorecontent.com/rewrite-failure-id")
+                        ];
+                    case 2:
+                        _state.sent();
+                        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to rewrite .asset-manifest.json; continuing with normalized URL"));
+                        return [
+                            3,
+                            4
+                        ];
+                    case 3:
+                        writeFileSpy.mockRestore();
+                        warnSpy.mockRestore();
+                        return [
+                            7
+                        ];
+                    case 4:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+});
+var makeMetaplexFile = function(fileName, buffer) {
+    return {
+        fileName: fileName,
+        buffer: buffer
+    };
+};
+var hashBuffer = function(buffer) {
+    return createHash("sha256").update(buffer).digest("base64");
+};

package/lib/upload/__tests__/TurboStorageDriver.test.js

@@ -0,0 +1,17 @@
+import { getTurboServiceConfig } from "../TurboStorageDriver";
+describe("TurboStorageDriver", function() {
+    test("uses the latest Turbo SDK service config shape for devnet", function() {
+        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", function() {
+        expect(getTurboServiceConfig("mainnet")).toEqual({});
+    });
+});

package/lib/upload/__tests__/contentGateway.test.js

@@ -0,0 +1,17 @@
+import { buildPublicContentUrl, normalizePublicContentUrl } from "../contentGateway";
+describe("contentGateway", function() {
+    test("builds a mainnet dappstorecontent URL from an upload id", function() {
+        expect(buildPublicContentUrl("abc123", "mainnet")).toBe("https://dappstorecontent.com/abc123");
+    });
+    test("builds a devnet Turbo raw URL from an upload id", function() {
+        expect(buildPublicContentUrl("abc123", "devnet")).toBe("https://turbo.ardrive.dev/raw/abc123");
+    });
+    test("normalizes arweave.net and arweave.com URLs to dappstorecontent", function() {
+        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", function() {
+        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/lib/upload/contentGateway.js

@@ -0,0 +1,23 @@
+var MAINNET_PUBLIC_CONTENT_GATEWAY = "https://dappstorecontent.com";
+var DEVNET_PUBLIC_CONTENT_GATEWAY = "https://turbo.ardrive.dev/raw";
+var LEGACY_MAINNET_CONTENT_HOSTS = new Set([
+    "arweave.net",
+    "www.arweave.net",
+    "arweave.com",
+    "www.arweave.com"
+]);
+export var buildPublicContentUrl = function(id, network) {
+    var gateway = network === "devnet" ? DEVNET_PUBLIC_CONTENT_GATEWAY : MAINNET_PUBLIC_CONTENT_GATEWAY;
+    return "".concat(gateway, "/").concat(id);
+};
+export var normalizePublicContentUrl = function(url) {
+    try {
+        var parsed = new URL(url);
+        if (!LEGACY_MAINNET_CONTENT_HOSTS.has(parsed.host.toLowerCase())) {
+            return url;
+        }
+        return "".concat(MAINNET_PUBLIC_CONTENT_GATEWAY).concat(parsed.pathname).concat(parsed.search).concat(parsed.hash);
+    } catch (e) {
+        return url;
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana-mobile/dapp-store-cli",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
@@ -44,10 +44,10 @@
     "ts-node": "^10.9.1"
   },
   "dependencies": {
-    "@ardrive/turbo-sdk": "^1.31.1",
+    "@ardrive/turbo-sdk": "^1.41.0",
     "@aws-sdk/client-s3": "^3.321.1",
     "@metaplex-foundation/js-plugin-aws": "^0.20.0",
-    "@solana-mobile/dapp-store-publishing-tools": "0.15.0",
+    "@solana-mobile/dapp-store-publishing-tools": "0.16.0",
     "@solana/web3.js": "1.92.1",
     "@types/semver": "^7.3.13",
     "ajv": "^8.11.0",

package/src/CliUtils.ts

@@ -17,7 +17,7 @@ import { awsStorage } from "@metaplex-foundation/js-plugin-aws";
 import { S3StorageManager } from "./config/index.js";
 
 export class Constants {
-  static CLI_VERSION = "0.15.0";
+  static CLI_VERSION = "0.16.0";
   static CONFIG_FILE_NAME = "config.yaml";
   static DEFAULT_RPC_DEVNET = "https://api.devnet.solana.com";
   static DEFAULT_PRIORITY_FEE = 500000;

package/src/upload/CachedStorageDriver.ts

@@ -2,6 +2,7 @@ import fs from "fs";
 import path from "path";
 import type { MetaplexFile, StorageDriver } from "@metaplex-foundation/js";
 import { createHash } from "crypto";
+import { normalizePublicContentUrl } from "./contentGateway.js";
 
 type URI = string;
 
@@ -44,11 +45,83 @@ export class CachedStorageDriver implements StorageDriver {
     return this.storageDriver.getUploadPrice(bytes);
   }
 
+  private resolveAssetManifestPath(filename = this.assetManifestPath): string {
+    return path.resolve(process.cwd(), filename);
+  }
+
+  private normalizeAsset(
+    filename: string,
+    asset: unknown
+  ): Asset | undefined {
+    if (!asset || typeof asset !== "object") return;
+
+    const candidate = asset as Partial<Asset>;
+    const pathValue =
+      typeof candidate.path === "string" ? candidate.path : filename;
+
+    if (
+      typeof candidate.sha256 !== "string" ||
+      typeof candidate.uri !== "string"
+    ) {
+      return;
+    }
+
+    return {
+      path: pathValue,
+      sha256: candidate.sha256,
+      uri: candidate.uri,
+    };
+  }
+
+  private normalizeAssetManifest(
+    assetManifest: Partial<AssetManifestSchema> | undefined
+  ): AssetManifestSchema | undefined {
+    if (!assetManifest || typeof assetManifest !== "object") return;
+
+    const assets: Record<string, Asset> = {};
+    const assetEntries =
+      assetManifest.assets && typeof assetManifest.assets === "object"
+        ? Object.entries(assetManifest.assets)
+        : [];
+
+    for (const [filename, asset] of assetEntries) {
+      const normalizedAsset = this.normalizeAsset(filename, asset);
+      if (normalizedAsset) {
+        assets[filename] = normalizedAsset;
+      }
+    }
+
+    return {
+      schema_version:
+        typeof assetManifest.schema_version === "string"
+          ? assetManifest.schema_version
+          : CachedStorageDriver.SCHEMA_VERSION,
+      assets,
+    };
+  }
+
+  private async writeAssetManifest(): Promise<void> {
+    const normalizedAssetManifest = this.normalizeAssetManifest(
+      this.assetManifest
+    );
+
+    if (!normalizedAssetManifest) {
+      throw new Error("Asset manifest is not serializable");
+    }
+
+    this.assetManifest = normalizedAssetManifest;
+    await fs.promises.writeFile(
+      this.resolveAssetManifestPath(),
+      JSON.stringify(this.assetManifest, null, 2),
+      "utf-8"
+    );
+  }
+
   loadAssetManifest(filename: string): AssetManifestSchema | undefined {
     try {
-      return JSON.parse(
-        fs.readFileSync(filename, "utf-8")
-      ) as AssetManifestSchema;
+      return this.normalizeAssetManifest(
+        JSON.parse(fs.readFileSync(this.resolveAssetManifestPath(filename), "utf-8"))
+      );
     } catch (error) {
       console.warn(`Failed opening ${filename}; initializing with a blank asset manifest`);
       return;
@@ -65,20 +138,32 @@ export class CachedStorageDriver implements StorageDriver {
   async upload(file: MetaplexFile): Promise<string> {
     // `inline.json` is the NFT-related metadata. This data is not stable so we'll skip the caching step
     if (file.fileName === "inline.json") {
-      return await this.storageDriver.upload(file);
+      return normalizePublicContentUrl(await this.storageDriver.upload(file));
     }
     const hash = createHash("sha256").update(file.buffer).digest("base64");
 
     const uploadedAsset = this.uploadedAsset(file.fileName, { sha256: hash });
     if (uploadedAsset) {
+      const normalizedUri = normalizePublicContentUrl(uploadedAsset.uri);
+      if (normalizedUri !== uploadedAsset.uri) {
+        uploadedAsset.uri = normalizedUri;
+        try {
+          await this.writeAssetManifest();
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          console.warn(
+            `Failed to rewrite ${this.assetManifestPath}; continuing with normalized URL: ${message}`
+          );
+        }
+      }
       console.log(
-        `Asset ${file.fileName} already uploaded at ${uploadedAsset.uri}`
+        `Asset ${file.fileName} already uploaded at ${normalizedUri}`
       );
-      return uploadedAsset.uri;
+      return normalizedUri;
     }
 
     console.log(`Uploading ${file.fileName}`);
-    const uri = await this.storageDriver.upload(file);
+    const uri = normalizePublicContentUrl(await this.storageDriver.upload(file));
 
     this.assetManifest.assets[file.fileName] = {
       path: file.fileName,
@@ -86,12 +171,7 @@ export class CachedStorageDriver implements StorageDriver {
       uri,
     };
 
-    await fs.promises.writeFile(
-      path.join(process.cwd(), this.assetManifestPath),
-      // Something is really weird, I can't seem to stringify `this.assetManifest` straight-up. Here be dragons
-      JSON.stringify({ assets: { ...this.assetManifest.assets } }, null, 2),
-      "utf-8"
-    );
+    await this.writeAssetManifest();
     console.log(`${file.fileName} uploaded at ${uri}`)
 
     return uri;