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

package/src/config/S3StorageManager.ts

@@ -1,47 +0,0 @@
-import { EnvVariables, S3Config } from "./EnvVariables.js";
-
-export class S3StorageManager {
-  private _config: S3Config | undefined = undefined
-
-  public get hasS3Config(): boolean {
-    return this._config != undefined;
-  }
-
-  public get s3Config(): S3Config {
-    return this._config as S3Config;
-  }
-
-  constructor(private envVars: EnvVariables) {
-    if (envVars.hasS3EnvArgs) {
-      this._config = {
-        accessKey: this.envVars.s3Config.accessKey,
-        secretKey: this.envVars.s3Config.secretKey,
-        bucketName: this.envVars.s3Config.bucketName,
-        regionName: this.envVars.s3Config.regionName
-      };
-    }
-  }
-
-  parseCmdArg(cmdArg: string) {
-    if (!cmdArg || cmdArg == "") return;
-
-    try {
-      //This will overwrite any existing parameters already obtained from the .env file
-      const parsedArray = JSON.parse(`${cmdArg}`);
-
-      if (parsedArray instanceof Array && parsedArray[0] == "s3") {
-        if (parsedArray.length != 5) throw new Error("Invalid parameters")
-
-        this._config = {
-          accessKey: parsedArray[1],
-          secretKey: parsedArray[2],
-          bucketName: parsedArray[3],
-          regionName: parsedArray[4]
-        };
-      }
-    } catch (e) {
-      throw new Error("There was an error parsing your s3 parameters from the CLI. Please ensure they are formatted correctly.");
-    }
-  }
-
-}

package/src/config/index.ts

@@ -1,2 +0,0 @@
-export * from "./EnvVariables.js";
-export * from "./S3StorageManager.js";

package/src/prebuild_schema/publishing_source.yaml

@@ -1,64 +0,0 @@
-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: ""
-  android_package: <<[REQUIRED] ANDROID_PACKAGE_NAME>>
-  urls:
-    license_url: <<[REQUIRED] URL For App's T&C. Don't put placeholder urls.>>
-    copyright_url: <<[REQUIRED] URL For App's Copyright. Don't put placeholder urls.>>
-    privacy_policy_url: <<[REQUIRED] URL For App's Privacy Policy. Don't put placeholder urls.>>
-    website: <<[REQUIRED] URL_OF_APP_WEBSITE>>
-  media:
-    - purpose: icon
-      uri: <<[REQUIRED] RELATIVE_PATH_TO_APP_ICON>>
-release:
-  address: ""
-  media:
-    - purpose: icon
-      uri: <<[REQUIRED] RELATIVE_PATH_TO_RELEASE_ICON>>
-    - purpose: banner
-      uri: <<[REQUIRED] RELATIVE_PATH_TO_BANNER>>
-    - purpose: featureGraphic
-      uri: <<[Optional] RELATIVE_PATH_TO_FEATURE_GRAPHIC>>
-    - purpose: screenshot
-      uri: <<[REQUIRED] RELATIVE_PATH_TO_SCREENSHOT1>>
-    - purpose: screenshot
-      uri: <<[REQUIRED] RELATIVE_PATH_TO_SCREENSHOT2>>
-    - purpose: screenshot
-      uri: <<[REQUIRED] RELATIVE_PATH_TO_SCREENSHOT3>>
-    - purpose: screenshot
-      uri: <<[REQUIRED] RELATIVE_PATH_TO_SCREENSHOT4>>
-    - purpose: video
-      uri: <<[Optional] RELATIVE_PATH_TO_VIDEO1>>
-  files:
-    - purpose: install
-      uri: <<[REQUIRED] RELATIVE_PATH_TO_APK>>
-  catalog:
-    en-US:
-      name: >-
-        <<[REQUIRED] APP_NAME>>
-      short_description: >-
-        <<[REQUIRED] SHORT_APP_DESCRIPTION>>
-      long_description: >-
-        <<[REQUIRED] LONG_APP_DESCRIPTION>>
-      new_in_version: >-
-        <<[REQUIRED] WHATS_NEW_IN_THIS_VERSION>>
-      saga_features: >-
-        <<[Optional.] ANY_FEATURES_ONLY_AVAILBLE_WHEN_RUNNING_ON_SAGA>>
-  android_details:
-    locales: 
-      - en-US
-      - <Add more supported locales>
-solana_mobile_dapp_publisher_portal:
-  google_store_package: <<[Optional] ANDROID_PACKAGE_NAME_OF_GOOGLE_PLAY_STORE_VERSION>>
-  testing_instructions: >-
-    <<[REQUIRED] TESTING_INSTRUCTIONS. Please provide any test account details if applicable>>
-  alpha_testers: 
-    - address: <<Optional. genesis token wallet address>>
-      comment: <<Optional. For internal use only>>
-    - address: <<Optional. genesis token wallet address>>
-      comment: <<Optional. For internal use only>>

package/src/prebuild_schema/schemagen.js

@@ -1,31 +0,0 @@
-import fs, { read } from "fs";
-import yaml from "js-yaml";
-import generateSchema from "generate-schema";
-
-try {
-  const yamlSrc = fs.readFileSync('./src/prebuild_schema/publishing_source.yaml', 'utf8')
-  const convertedYaml = yaml.load(yamlSrc);
-  fs.writeFileSync('./src/generated/config_obj.json', Buffer.from(JSON.stringify(convertedYaml)), 'utf-8');
-
-  const schema = generateSchema.json('result', convertedYaml);
-  // CLI 0.3.0: Adding requirement for `short_description` so validation will catch
-  schema["properties"]
-    ["release"]
-    ["properties"]
-    ["catalog"]
-    ["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;
-
-  const toWrite = Buffer.from(JSON.stringify(schema));
-  fs.writeFileSync('./src/generated/config_schema.json', toWrite, 'utf-8');
-} catch (e) {
-  console.log(":: Schema generation step failed ::");
-}

package/src/upload/CachedStorageDriver.ts

@@ -1,99 +0,0 @@
-import fs from "fs";
-import path from "path";
-import type { MetaplexFile, StorageDriver } from "@metaplex-foundation/js";
-import { createHash } from "crypto";
-
-type URI = string;
-
-type Asset = {
-  path: string;
-  sha256: string;
-  uri: URI;
-};
-
-export type AssetManifestSchema = {
-  schema_version: string;
-  assets: {
-    [path: string]: Asset;
-  };
-};
-
-// TODO(jon): We need to manage the removal / replacement of assets in the manifest
-export class CachedStorageDriver implements StorageDriver {
-  // NOTE: this schema version is independent of the publishing JSON schema. It should be updated
-  // when the AssetManifestSchema or Asset types are updated.
-  static readonly SCHEMA_VERSION = "0.1";
-
-  assetManifest: AssetManifestSchema;
-  assetManifestPath: string;
-  storageDriver: StorageDriver;
-
-  constructor(
-    storageDriver: StorageDriver,
-    { assetManifestPath }: { assetManifestPath: string }
-  ) {
-    this.assetManifestPath = assetManifestPath;
-    this.assetManifest = this.loadAssetManifest(assetManifestPath) ?? {
-      schema_version: CachedStorageDriver.SCHEMA_VERSION,
-      assets: {},
-    };
-    this.storageDriver = storageDriver;
-  }
-
-  async getUploadPrice(bytes: number) {
-    return this.storageDriver.getUploadPrice(bytes);
-  }
-
-  loadAssetManifest(filename: string): AssetManifestSchema | undefined {
-    try {
-      return JSON.parse(
-        fs.readFileSync(filename, "utf-8")
-      ) as AssetManifestSchema;
-    } catch (error) {
-      console.warn(`Failed opening ${filename}; initializing with a blank asset manifest`);
-      return;
-    }
-  }
-
-  uploadedAsset(filename: string, { sha256 }: { sha256: string }) {
-    if (this.assetManifest.assets[filename]?.sha256 === sha256) {
-      return this.assetManifest.assets[filename];
-    }
-    return null;
-  }
-
-  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);
-    }
-    const hash = createHash("sha256").update(file.buffer).digest("base64");
-
-    const uploadedAsset = this.uploadedAsset(file.fileName, { sha256: hash });
-    if (uploadedAsset) {
-      console.log(
-        `Asset ${file.fileName} already uploaded at ${uploadedAsset.uri}`
-      );
-      return uploadedAsset.uri;
-    }
-
-    console.log(`Uploading ${file.fileName}`);
-    const uri = await this.storageDriver.upload(file);
-
-    this.assetManifest.assets[file.fileName] = {
-      path: file.fileName,
-      sha256: hash,
-      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"
-    );
-    console.log(`${file.fileName} uploaded at ${uri}`)
-
-    return uri;
-  }
-}

package/src/upload/TurboStorageDriver.ts

@@ -1,277 +0,0 @@
-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 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,
-  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",
-  },
-} 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> {
-    if (wincAmount === 0n) {
-      debug("No Winston Credits requested; skipping top-up.");
-      return;
-    }
-
-    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));
-        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 at least ${wincAmount} Winston Credits (~${solAmount.toFixed(9)} SOL / ${lamportsToUse} lamports)`
-        );
-
-        await this.turbo.topUpWithTokens?.({
-          tokenAmount: String(
-            lamportToTokenAmount(lamportsToUse.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,2 +0,0 @@
-export * from "./CachedStorageDriver.js";
-export * from "./TurboStorageDriver.js";