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

package/lib/upload/index.js

@@ -1 +1,2 @@
 export * from "./CachedStorageDriver.js";
+export * from "./TurboStorageDriver.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana-mobile/dapp-store-cli",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
@@ -44,13 +44,15 @@
     "ts-node": "^10.9.1"
   },
   "dependencies": {
+    "@ardrive/turbo-sdk": "^1.31.1",
     "@aws-sdk/client-s3": "^3.321.1",
     "@metaplex-foundation/js-plugin-aws": "^0.20.0",
-    "@solana-mobile/dapp-store-publishing-tools": "0.13.0",
+    "@solana-mobile/dapp-store-publishing-tools": "0.14.0",
     "@solana/web3.js": "1.92.1",
     "@types/semver": "^7.3.13",
     "ajv": "^8.11.0",
     "boxen": "^7.0.1",
+    "bs58": "^5.0.0",
     "chokidar": "^3.5.3",
     "commander": "^9.4.1",
     "debug": "^4.3.4",

package/src/CliSetup.ts

@@ -52,6 +52,7 @@ function latestReleaseMessage() {
   const messages = [
     `- Banner Graphic image of size 1200x600px is now manadatory for publishing updates.`,
     `- Feature Graphic image of size 1200x1200px is required to be featured in Editor's choice carousel. (optional)`,
+    `- Release metadata now publishes publisher.support_email when provided; otherwise we reuse publisher.email for end-user support.`,
   ].join('\n\n')
   showMessage(
     `Publishing Tools Version ${ Constants.CLI_VERSION }`,
@@ -91,6 +92,15 @@ export const createCliCmd = mainCli
   .command("create")
   .description("Create a `app`, or `release`")
 
+createCliCmd.addHelpText(
+  "after",
+  [
+    "",
+    "Release metadata notes:",
+    "  We include publisher.support_email when provided; if omitted we fall back to publisher.email.",
+  ].join("\n")
+);
+
 export const createAppCliCmd = createCliCmd
   .command("app")
   .description("Create a app")

package/src/CliUtils.ts

@@ -2,11 +2,7 @@ import fs from "fs";
 import type { Connection } from "@solana/web3.js";
 import { Keypair, PublicKey } from "@solana/web3.js";
 import debugModule from "debug";
-import {
-  IrysStorageDriver,
-  keypairIdentity,
-  Metaplex,
-} from "@metaplex-foundation/js";
+import { keypairIdentity, Metaplex, type MetaplexFile, type Amount, lamports } from "@metaplex-foundation/js";
 import updateNotifier from "update-notifier";
 import { readFile } from 'fs/promises';
 const cliPackage = JSON.parse((await readFile(new URL("./package.json", import.meta.url))).toString());
@@ -14,13 +10,14 @@ import boxen from "boxen";
 import ver from "semver";
 import path from "path";
 import { CachedStorageDriver } from "./upload/CachedStorageDriver.js";
+import { TurboStorageDriver } from "./upload/TurboStorageDriver.js";
 import { EnvVariables } from "./config/index.js";
 import { S3Client } from "@aws-sdk/client-s3";
 import { awsStorage } from "@metaplex-foundation/js-plugin-aws";
 import { S3StorageManager } from "./config/index.js";
 
 export class Constants {
-  static CLI_VERSION = "0.13.0";
+  static CLI_VERSION = "0.14.0";
   static CONFIG_FILE_NAME = "config.yaml";
   static DEFAULT_RPC_DEVNET = "https://api.devnet.solana.com";
   static DEFAULT_PRIORITY_FEE = 500000;
@@ -205,16 +202,23 @@ export const getMetaplexInstance = (
     const bucketPlugin = awsStorage(awsClient, s3Mgr.s3Config.bucketName);
     metaplex.use(bucketPlugin);
   } else {
-    const irysStorageDriver = isDevnet
-      ? new IrysStorageDriver(metaplex, {
-        address: "https://turbo.ardrive.dev",
-        providerUrl: Constants.DEFAULT_RPC_DEVNET,
-      })
-      : new IrysStorageDriver(metaplex, {
-        address: "https://turbo.ardrive.io",
-      });
-
-    metaplex.storage().setDriver(irysStorageDriver);
+    const turboDriver = new TurboStorageDriver(
+      keypair,
+      isDevnet ? "devnet" : "mainnet",
+      Number(process.env.TURBO_BUFFER_PERCENTAGE || 20)
+    );
+
+    const metaplexAdapter = {
+      async upload(file: MetaplexFile): Promise<string> {
+        return turboDriver.upload(file);
+      },
+      async getUploadPrice(bytes: number): Promise<Amount> {
+        const price = await turboDriver.getUploadPrice(bytes);
+        return lamports(price);
+      },
+    };
+
+    metaplex.storage().setDriver(metaplexAdapter);
   }
 
   metaplex.storage().setDriver(

package/src/__tests__/CliSetupTest.ts

@@ -24,11 +24,11 @@ describe("Cli Setup & Execution", () => {
       getErrHelpWidth(): number { return 250;},
 
       writeOut(str: string) {
-        otherOutput = str;
+        otherOutput += str;
       },
 
       writeErr(str: string) {
-        errorOutput = str;
+        errorOutput += str;
       }
     });
   });
@@ -136,7 +136,7 @@ Options:
 
   const keyPairArgHelp = "error: required option '-k, --keypair <path-to-keypair-file>' not specified"
 
-  const createHelp = `Usage: dapp-store create [options] [command]
+const createHelp = `Usage: dapp-store create [options] [command]
 
 Create a \`app\`, or \`release\`
 
@@ -147,6 +147,9 @@ Commands:
   app [options]      Create a app
   release [options]  Create a release
   help [command]     display help for command
+
+Release metadata notes:
+  We include publisher.support_email when provided; if omitted we fall back to publisher.email.
 `;
 
   const createAppHelp = `Usage: dapp-store create app [options]
@@ -177,4 +180,4 @@ Options:
   -h, --help                                           display help for command
 `;
 
-});
+});

package/src/commands/create/index.ts

@@ -15,7 +15,7 @@ export * from "./CreateCliRelease.js";
 // Publisher
 // Public key attached to a publisher must also verify applications and releases
 // Most information here can be be edited after the fact
-// Only required fields are name, address, publisher website, and contact
+// Only required fields are name, address, publisher website, and contact email
 // Optional fields are: description, image_url (need dimensions!)
 
 // App

package/src/prebuild_schema/publishing_source.yaml

@@ -2,6 +2,7 @@ publisher:
   name: <<[REQUIRED] YOUR_PUBLISHER_NAME>>
   website: <<[REQUIRED] URL_OF_PUBLISHER_WEBSITE>>
   email: <<[REQUIRED] EMAIL_ADDRESS_TO_CONTACT_PUBLISHER>>
+  support_email: <<[Optional] SUPPORT_EMAIL_ADDRESS_FOR_END_USERS>>
 app:
   name: <<[REQUIRED] APP_NAME>>
   address: ""

package/src/prebuild_schema/schemagen.js

@@ -16,6 +16,10 @@ try {
     ["properties"]
     ["en-US"].required = ["short_description"];
 
+  schema["properties"]
+    ["publisher"]
+    .required = ["name", "website", "email"];
+
   // Generator adds some keys/values we don't need & mess up validation
   delete schema.$schema;
   delete schema.title;

package/src/upload/TurboStorageDriver.ts

@@ -0,0 +1,248 @@
+import type { Keypair } from "@solana/web3.js";
+import type { MetaplexFile } from "@metaplex-foundation/js";
+import { TurboFactory, lamportToTokenAmount } from "@ardrive/turbo-sdk";
+import bs58 from "bs58";
+import debugModule from "debug";
+
+const debug = debugModule("cli:turbo-storage");
+
+interface TurboClient {
+  getUploadCosts(args: {
+    bytes: number[];
+  }): Promise<Array<{ winc: string | number | bigint }>>;
+  getBalance(): Promise<{ winc: string | number | bigint }>;
+  getWincForToken?(args: {
+    tokenAmount: number;
+  }): Promise<{ winc: string | number | bigint }>;
+  topUpWithTokens?(args: { tokenAmount: string | number }): Promise<unknown>;
+  uploadFile(args: {
+    fileStreamFactory: () => Buffer;
+    fileSizeFactory: () => number;
+    dataItemOpts?: { tags?: Array<{ name: string; value: string }> };
+  }): Promise<{ id: string }>;
+}
+
+const CONSTANTS = {
+  FREE_UPLOAD_LIMIT: 97_280, // 95 KiB
+  UPLOAD_DELAY_MS: 2000,
+  MAX_RETRIES: 5,
+  SOL_IN_LAMPORTS: 1_000_000_000,
+  BACKOFF: {
+    BASE_MS: 500,
+    MAX_MS: 8000,
+  },
+  GATEWAYS: {
+    devnet: "https://turbo.ardrive.dev/raw",
+    mainnet: "https://arweave.net",
+  },
+} as const;
+
+const delay = (ms: number): Promise<void> =>
+  new Promise((resolve) => setTimeout(resolve, ms));
+
+export class TurboStorageDriver {
+  private turbo: TurboClient;
+  private bufferPercentage: number;
+  private network: "devnet" | "mainnet";
+
+  private uploadQueue: Array<{
+    file: MetaplexFile;
+    resolve: (url: string) => void;
+    reject: (error: Error) => void;
+  }> = [];
+  private isProcessingQueue = false;
+
+  constructor(
+    keypair: Keypair,
+    network: "devnet" | "mainnet" = "mainnet",
+    bufferPercentage = 20
+  ) {
+    this.network = network;
+    this.bufferPercentage = bufferPercentage;
+
+    this.turbo = TurboFactory.authenticated({
+      privateKey: bs58.encode(keypair.secretKey),
+      token: "solana",
+      ...this.getServiceUrls(network === "devnet"),
+    }) 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);
+
+    const [cost] = await this.turbo.getUploadCosts({ bytes: [bytes] });
+    const base = BigInt(String(cost.winc));
+    return (base * BigInt(100 + this.bufferPercentage)) / BigInt(100);
+  }
+
+  private async withRetry<T>(
+    operation: () => Promise<T>,
+    isRetriable: (error: string) => boolean = (msg) =>
+      msg.includes("429") || msg.includes("Too Many Requests")
+  ): Promise<T> {
+    for (let retry = 0; retry <= CONSTANTS.MAX_RETRIES; retry++) {
+      try {
+        return await operation();
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+
+        if (retry < CONSTANTS.MAX_RETRIES && isRetriable(errorMessage)) {
+          const delayMs = Math.min(
+            CONSTANTS.BACKOFF.BASE_MS * Math.pow(2, retry),
+            CONSTANTS.BACKOFF.MAX_MS
+          );
+          console.log(
+            `Rate limited, retrying after ${delayMs}ms (attempt ${retry + 1}/${
+              CONSTANTS.MAX_RETRIES
+            })...`
+          );
+          await delay(delayMs);
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw new Error("Max retries exceeded");
+  }
+
+  private formatInsufficientFundsError(errorMessage: string): void {
+    const match = errorMessage.match(/insufficient lamports (\d+), need (\d+)/);
+    if (!match) return;
+
+    const [current, needed] = [BigInt(match[1]), BigInt(match[2])];
+    const [currentSOL, neededSOL] = [
+      Number(current) / 1e9,
+      Number(needed) / 1e9,
+    ];
+
+    console.error(`\nInsufficient SOL balance for top-up:`);
+    console.error(`  Current: ${currentSOL.toFixed(9)} SOL`);
+    console.error(`  Required: ${neededSOL.toFixed(9)} SOL`);
+    console.error(`  Shortfall: ${(neededSOL - currentSOL).toFixed(9)} SOL\n`);
+  }
+
+  private async topUpCredits(wincAmount: bigint): Promise<void> {
+    try {
+      await this.withRetry(async () => {
+        const exchangeRate = await this.turbo.getWincForToken?.({
+          tokenAmount: CONSTANTS.SOL_IN_LAMPORTS,
+        });
+
+        if (!exchangeRate) {
+          throw new Error("Unable to get Winston Credits exchange rate");
+        }
+
+        const wincPerSol = BigInt(String(exchangeRate.winc));
+        const lamportsNeeded =
+          (wincAmount * BigInt(CONSTANTS.SOL_IN_LAMPORTS)) / wincPerSol;
+
+        debug(
+          `Buying ${wincAmount} Winston Credits for ~${
+            Number(lamportsNeeded) / 1e9
+          } SOL`
+        );
+
+        await this.turbo.topUpWithTokens?.({
+          tokenAmount: String(lamportToTokenAmount(lamportsNeeded.toString())),
+        });
+
+        debug(`Top-up initiated for ${wincAmount} Winston Credits`);
+      });
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      debug("Top-up failed:", error);
+
+      if (errorMessage.includes("insufficient lamports")) {
+        this.formatInsufficientFundsError(errorMessage);
+      }
+
+      throw new Error(
+        `Failed to top up ${wincAmount} Winston Credits: ${errorMessage}`
+      );
+    }
+  }
+
+  private async checkBalanceAndTopUp(requiredWinc: bigint): Promise<void> {
+    if (requiredWinc === BigInt(0)) return;
+
+    const current = BigInt(String((await this.turbo.getBalance()).winc));
+
+    if (current >= requiredWinc) {
+      debug(
+        `Sufficient balance: ${current} Winston Credits (required: ${requiredWinc})`
+      );
+      return;
+    }
+
+    const deficit = requiredWinc - current;
+    debug(
+      `Current: ${current}, Required: ${requiredWinc}, Topping up: ${deficit}`
+    );
+    await this.topUpCredits(deficit);
+  }
+
+  private async processQueue(): Promise<void> {
+    if (this.isProcessingQueue || !this.uploadQueue.length) return;
+
+    this.isProcessingQueue = true;
+
+    while (this.uploadQueue.length > 0) {
+      const item = this.uploadQueue.shift();
+      if (!item) continue;
+
+      try {
+        debug(
+          `Processing upload for ${item.file.fileName} (${item.file.buffer.length} bytes)`
+        );
+
+        const estimated = await this.getUploadPrice(item.file.buffer.length);
+        await this.checkBalanceAndTopUp(estimated);
+
+        const tags = [...(item.file.tags ?? [])];
+        if (item.file.contentType) {
+          tags.push({ name: "Content-Type", value: item.file.contentType });
+        }
+
+        const uploadResult = await this.turbo.uploadFile({
+          fileStreamFactory: () => item.file.buffer,
+          fileSizeFactory: () => item.file.buffer.byteLength,
+          dataItemOpts: { tags },
+        });
+
+        const gateway = CONSTANTS.GATEWAYS[this.network];
+        const url = `${gateway}/${uploadResult.id}`;
+        debug(`Upload complete: ${url}`);
+        item.resolve(url);
+
+        if (this.uploadQueue.length > 0) {
+          debug(`Waiting ${CONSTANTS.UPLOAD_DELAY_MS}ms before next upload...`);
+          await delay(CONSTANTS.UPLOAD_DELAY_MS);
+        }
+      } catch (error) {
+        item.reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+
+    this.isProcessingQueue = false;
+  }
+
+  async upload(file: MetaplexFile): Promise<string> {
+    return new Promise((resolve, reject) => {
+      debug(
+        `Queueing upload for ${file.fileName} (${file.buffer.length} bytes)`
+      );
+      this.uploadQueue.push({ file, resolve, reject });
+      this.processQueue().catch(reject);
+    });
+  }
+}

package/src/upload/index.ts

@@ -1 +1,2 @@
 export * from "./CachedStorageDriver.js";
+export * from "./TurboStorageDriver.js";