@solana-mobile/dapp-store-publishing-tools 0.16.0 → 1.0.0

package/src/portal/workflow/state/bundle.ts

@@ -0,0 +1,193 @@
+import type {
+  PublicationBundle,
+  PublicationSession,
+  PublicationSigner,
+} from "../../types.js";
+import { inferFileNameFromUrl } from "../source/files.js";
+
+function normalizePublicationMetadata(
+  bundle: PublicationBundle
+): PublicationBundle["metadata"] {
+  if (bundle.metadata) {
+    return bundle.metadata;
+  }
+
+  return {
+    localizedName:
+      bundle.release.localizedName ??
+      bundle.release.releaseName ??
+      bundle.dapp.dappName,
+    shortDescription: bundle.dapp.subtitle ?? "",
+    longDescription: bundle.dapp.description ?? "",
+    newInVersion: bundle.release.newInVersion,
+    publisherWebsite: bundle.publisher.website,
+    supportEmail:
+      bundle.publisher.supportEmail ?? bundle.dapp.supportEmail ?? null,
+    website: bundle.dapp.website ?? bundle.dapp.appWebsite ?? null,
+    locales: bundle.dapp.languages ?? [],
+    legal: {
+      licenseUrl: bundle.dapp.licenseUrl ?? null,
+      copyrightUrl: bundle.dapp.copyrightUrl ?? null,
+      privacyPolicyUrl: bundle.dapp.privacyPolicyUrl ?? null,
+    },
+    media: [],
+    installFile: {
+      uri: bundle.installFile.uri,
+      mimeType: bundle.installFile.mimeType,
+      size: bundle.installFile.size,
+      sha256: bundle.installFile.sha256 ?? null,
+      fileName:
+        bundle.installFile.fileName ??
+        inferFileNameFromUrl(bundle.installFile.uri),
+      canonicalUrl: bundle.installFile.canonicalUrl ?? bundle.installFile.uri,
+      url: bundle.installFile.uri,
+      origin: "portal",
+    },
+    localizedStrings: [],
+    releaseMetadataUri:
+      bundle.release.releaseMetadataUri ??
+      bundle.release.nftMetadataUri ??
+      null,
+  };
+}
+
+function getReleaseMetadataUri(
+  bundle: PublicationBundle,
+  session?: PublicationSession
+): string | null {
+  return (
+    session?.metadataUri ??
+    bundle.release.releaseMetadataUri ??
+    bundle.release.nftMetadataUri ??
+    bundle.metadata?.releaseMetadataUri ??
+    null
+  );
+}
+
+export function normalizePublicationBundle(
+  bundle: PublicationBundle
+): PublicationBundle {
+  return {
+    ...bundle,
+    releaseId: bundle.releaseId || bundle.release.id || "",
+    metadata: normalizePublicationMetadata(bundle),
+  };
+}
+
+export function withPublicationBundleIdentifiers(
+  bundle: PublicationBundle,
+  identifiers: {
+    releaseId?: string | null;
+    publicationSessionId?: string | null;
+    ingestionSessionId?: string | null;
+  }
+): PublicationBundle {
+  return {
+    ...bundle,
+    releaseId:
+      bundle.releaseId || bundle.release.id || identifiers.releaseId || "",
+    publicationSessionId:
+      bundle.publicationSessionId || identifiers.publicationSessionId || "",
+    ingestionSessionId:
+      bundle.ingestionSessionId || identifiers.ingestionSessionId || "",
+  };
+}
+
+export function resolveReleaseMetadataUri(
+  bundle: PublicationBundle,
+  session?: PublicationSession
+): string {
+  const releaseMetadataUri = getReleaseMetadataUri(bundle, session);
+
+  if (!releaseMetadataUri) {
+    throw new Error(
+      "Publication bundle did not include a release metadata URI"
+    );
+  }
+
+  return releaseMetadataUri;
+}
+
+export function hasResolvableReleaseMetadataUri(
+  bundle: PublicationBundle,
+  session?: PublicationSession
+): boolean {
+  return Boolean(getReleaseMetadataUri(bundle, session));
+}
+
+export function resolvePublicationSignerAddress(
+  bundle: PublicationBundle
+): string {
+  return (
+    bundle.signerAuthority.dappWalletAddress ??
+    bundle.signerAuthority.requiredSigner ??
+    bundle.signerAuthority.collectionAuthority
+  );
+}
+
+export function resolveReleaseDisplayName(bundle: PublicationBundle): string {
+  return (
+    bundle.release.localizedName ??
+    bundle.release.releaseName ??
+    bundle.dapp.dappName
+  );
+}
+
+export function resolvePublicationFeePayer(
+  bundle: PublicationBundle,
+  signer: PublicationSigner
+): string {
+  return bundle.signerAuthority.feePayer ?? signer.publicKey;
+}
+
+export function validatePublicationBundle(bundle: PublicationBundle): void {
+  const normalizedBundle = normalizePublicationBundle(bundle);
+  const requiredFields: Array<[string, unknown]> = [
+    ["releaseId", normalizedBundle.releaseId],
+    ["publicationSessionId", normalizedBundle.publicationSessionId],
+    ["ingestionSessionId", normalizedBundle.ingestionSessionId],
+    ["androidPackage", normalizedBundle.release.androidPackage],
+    [
+      "release.localizedName",
+      normalizedBundle.release.localizedName ??
+        normalizedBundle.release.releaseName,
+    ],
+    ["versionName", normalizedBundle.release.versionName],
+    ["appMintAddress", normalizedBundle.signerAuthority.appMintAddress],
+    ["dappWalletAddress", normalizedBundle.signerAuthority.dappWalletAddress],
+    [
+      "collectionAuthority",
+      normalizedBundle.signerAuthority.collectionAuthority,
+    ],
+    [
+      "acceptedSignerRoles",
+      normalizedBundle.signerAuthority.acceptedSignerRoles,
+    ],
+    ["metadata.localizedName", normalizedBundle.metadata?.localizedName],
+    ["shortDescription", normalizedBundle.metadata?.shortDescription],
+    ["longDescription", normalizedBundle.metadata?.longDescription],
+    ["newInVersion", normalizedBundle.metadata?.newInVersion],
+    ["installFile.uri", normalizedBundle.installFile.uri],
+    ["installFile.mimeType", normalizedBundle.installFile.mimeType],
+  ];
+
+  const missing = requiredFields.filter(([, value]) => {
+    if (typeof value === "string") {
+      return value.trim().length === 0;
+    }
+
+    if (Array.isArray(value)) {
+      return value.length === 0;
+    }
+
+    return value === undefined || value === null;
+  });
+
+  if (missing.length > 0) {
+    throw new Error(
+      `Publication bundle is missing required fields: ${missing
+        .map(([field]) => field)
+        .join(", ")}`
+    );
+  }
+}

package/src/portal/workflow/state/checkpoints.ts

@@ -0,0 +1,70 @@
+import type { PublicationCheckpoint, PublicationSession } from "../../types.js";
+
+const publicationCheckpointOrder: PublicationCheckpoint[] = [
+  "created",
+  "bundle-ready",
+  "mint-submitted",
+  "mint-saved",
+  "verification-submitted",
+  "verified",
+  "attested",
+  "submitted",
+  "completed",
+];
+
+export function checkpointAtLeast(
+  checkpoint: PublicationCheckpoint,
+  expected: PublicationCheckpoint
+): boolean {
+  return (
+    publicationCheckpointOrder.indexOf(checkpoint) >=
+    publicationCheckpointOrder.indexOf(expected)
+  );
+}
+
+export function publicationStageToCheckpoint(
+  stage: PublicationSession["stage"]
+): PublicationCheckpoint {
+  if (!stage) {
+    return "created";
+  }
+
+  switch (stage) {
+    case "PreparedForMint":
+      return "bundle-ready";
+    case "MintSubmitted":
+      return "mint-submitted";
+    case "MintSaved":
+      return "mint-saved";
+    case "VerificationSubmitted":
+      return "verification-submitted";
+    case "Verified":
+      return "verified";
+    case "Attested":
+      return "attested";
+    case "Submitted":
+      return "submitted";
+    case "Failed":
+    default:
+      return "created";
+  }
+}
+
+export function publicationStageToStatus(
+  stage: PublicationSession["stage"]
+): PublicationSession["status"] {
+  if (!stage) {
+    return "pending";
+  }
+
+  switch (stage) {
+    case "Submitted":
+      return "completed";
+    case "Failed":
+      return "failed";
+    case "PreparedForMint":
+      return "pending";
+    default:
+      return "running";
+  }
+}

package/src/portal/workflow/state/session.ts

@@ -0,0 +1,87 @@
+import type {
+  PublicationBundle,
+  PublicationSession,
+  PublicationSessionStage,
+} from "../../types.js";
+import {
+  publicationStageToCheckpoint,
+  publicationStageToStatus,
+} from "./checkpoints.js";
+
+export function normalizePublicationSession(
+  session: PublicationSession
+): PublicationSession {
+  const stage = resolvePublicationSessionStage(session);
+  const checkpoint = session.checkpoint ?? publicationStageToCheckpoint(stage);
+
+  return {
+    ...session,
+    stage,
+    checkpoint,
+    status: session.status ?? publicationStageToStatus(stage),
+    releaseMintAddress:
+      session.releaseMintAddress ?? session.expectedMintAddress ?? null,
+    verifyTransactionSignature:
+      session.verifyTransactionSignature ??
+      session.verificationTransactionSignature ??
+      null,
+  };
+}
+
+export function resolvePublicationSessionStage(
+  session: PublicationSession
+): PublicationSessionStage {
+  if (session.stage) {
+    return session.stage;
+  }
+
+  if (session.status === "failed") {
+    return "Failed";
+  }
+
+  if (session.status === "completed") {
+    return "Submitted";
+  }
+
+  if (
+    session.checkpoint === "submitted" ||
+    session.checkpoint === "completed"
+  ) {
+    return "Submitted";
+  }
+
+  if (session.checkpoint === "verified") {
+    return "Verified";
+  }
+
+  if (session.checkpoint === "attested") {
+    return "Attested";
+  }
+
+  if (session.checkpoint === "verification-submitted") {
+    return "VerificationSubmitted";
+  }
+
+  if (session.checkpoint === "mint-saved") {
+    return "MintSaved";
+  }
+
+  if (session.checkpoint === "mint-submitted") {
+    return "MintSubmitted";
+  }
+
+  return "PreparedForMint";
+}
+
+export function resolveReleaseMintAddress(
+  bundle: PublicationBundle,
+  publicationSession: PublicationSession
+): string | undefined {
+  return (
+    publicationSession.releaseMintAddress ??
+    publicationSession.expectedMintAddress ??
+    bundle.release.nftMintAddress ??
+    bundle.release.releaseMintAddress ??
+    undefined
+  );
+}

package/src/portal/workflow.ts

@@ -0,0 +1,9 @@
+export type {
+  PublicationResumeInput,
+  PublicationWorkflowClient,
+  PublicationWorkflowInput,
+  PublicationWorkflowOptions,
+  PublicationWorkflowPrepareReleaseTransactionInput,
+  PublicationWorkflowPrepareVerifyTransactionInput,
+} from "./workflow/contracts.js";
+export { createPublicationWorkflow } from "./workflow/lifecycle.js";

package/src/publish/PublishCoreAttestation.ts

@@ -1,31 +1,26 @@
-import { Connection } from "@solana/web3.js";
-import { SignWithPublisherKeypair } from "./types";
+import { Connection } from '@solana/web3.js';
 
-//
-// Construct and sign attestation payloads
-//
+import {
+  createAttestationPayload as createPortalAttestationPayload,
+  type PublicationAttestationResult,
+} from '../portal/attestation.js';
 
-type Attestation = {
-  slot_number: number;
-  blockhash: string;
-  request_unique_id: string;
-};
-
-export const createAttestationPayload = async (connection: Connection, sign: SignWithPublisherKeypair) => {
-  const REQUEST_UNIQUE_ID_LEN = 32;
-  const REQUEST_UNIQUE_ID_CHAR_SET = "0123456789";
-  const requestUniqueId = Array(REQUEST_UNIQUE_ID_LEN).fill(undefined).map((_) =>
-    REQUEST_UNIQUE_ID_CHAR_SET.charAt(Math.floor(Math.random() * REQUEST_UNIQUE_ID_CHAR_SET.length))
-  ).join("")
-
-  const blockhash = await connection.getLatestBlockhashAndContext("finalized");
+export type SignWithPublisherKeypair = (buf: Buffer) => Buffer;
 
-  const attestation: Attestation = {
-    slot_number: blockhash.context.slot,
-    blockhash: blockhash.value.blockhash,
-    request_unique_id: requestUniqueId
-  };
-  const signedAttestation = sign(Buffer.from(JSON.stringify(attestation)));
+type Attestation = PublicationAttestationResult;
 
-  return { attestationPayload: Buffer.from(signedAttestation.buffer).toString("base64"), requestUniqueId };
+export const createAttestationPayload = async (
+  connection: Connection,
+  sign: SignWithPublisherKeypair,
+): Promise<Attestation> => {
+  const blockhash = await connection.getLatestBlockhashAndContext('finalized');
+  return createPortalAttestationPayload(
+    {
+      slot: blockhash.context.slot,
+      blockhash: blockhash.value.blockhash,
+    },
+    {
+      signMessage: async (message: Uint8Array) => sign(Buffer.from(message)),
+    },
+  );
 };

package/src/publish/PublishCoreRemove.ts

@@ -1,119 +1,23 @@
-import { Connection } from "@solana/web3.js";
-import type { Publisher } from "../types.js";
-import { createAttestationPayload } from "./PublishCoreAttestation.js";
-import {
-  CONTACT_OBJECT_ID,
-  CONTACT_PROPERTY_COMPANY,
-  CONTACT_PROPERTY_EMAIL,
-  CONTACT_PROPERTY_WEBSITE,
-  submitRequestToSolanaDappPublisherPortal,
-  TICKET_OBJECT_ID,
-  TICKET_PROPERTY_ATTESTATION_PAYLOAD,
-  TICKET_PROPERTY_AUTHORIZED_REQUEST,
-  TICKET_PROPERTY_CRITICAL_UPDATE,
-  TICKET_PROPERTY_DAPP_COLLECTION_ACCOUNT_ADDRESS,
-  TICKET_PROPERTY_DAPP_RELEASE_ACCOUNT_ADDRESS,
-  TICKET_PROPERTY_REQUEST_UNIQUE_ID,
-  URL_FORM_REMOVE
-} from "./dapp_publisher_portal.js";
-import { PublishSolanaNetworkInput, SignWithPublisherKeypair } from "./types.js";
-
-const createRemoveRequest = async (
-  connection: Connection,
-  sign: SignWithPublisherKeypair,
-  appMintAddress: string,
-  releaseMintAddress: string,
-  publisherDetails: Publisher,
-  requestorIsAuthorized: boolean,
-  criticalUpdate: boolean
-) => {
-  const { attestationPayload, requestUniqueId } = await createAttestationPayload(connection, sign);
-
-  const request = {
-    fields: [
-      {
-        objectTypeId: CONTACT_OBJECT_ID,
-        name: CONTACT_PROPERTY_COMPANY,
-        value: publisherDetails.name
-      },
-      {
-        objectTypeId: CONTACT_OBJECT_ID,
-        name: CONTACT_PROPERTY_EMAIL,
-        value: publisherDetails.email
-      },
-      {
-        objectTypeId: CONTACT_OBJECT_ID,
-        name: CONTACT_PROPERTY_WEBSITE,
-        value: publisherDetails.website
-      },
-      {
-        objectTypeId: TICKET_OBJECT_ID,
-        name: TICKET_PROPERTY_ATTESTATION_PAYLOAD,
-        value: attestationPayload
-      },
-      {
-        objectTypeId: TICKET_OBJECT_ID,
-        name: TICKET_PROPERTY_DAPP_COLLECTION_ACCOUNT_ADDRESS,
-        value: appMintAddress
-      },
-      {
-        objectTypeId: TICKET_OBJECT_ID,
-        name: TICKET_PROPERTY_DAPP_RELEASE_ACCOUNT_ADDRESS,
-        value: releaseMintAddress
-      },
-      {
-        objectTypeId: TICKET_OBJECT_ID,
-        name: TICKET_PROPERTY_REQUEST_UNIQUE_ID,
-        value: requestUniqueId
-      },
-      {
-        objectTypeId: TICKET_OBJECT_ID,
-        name: TICKET_PROPERTY_AUTHORIZED_REQUEST,
-        value: requestorIsAuthorized
-      },
-    ]
-  };
-
-  if (criticalUpdate) {
-    request.fields.push(
-      {
-        objectTypeId: TICKET_OBJECT_ID,
-        name: TICKET_PROPERTY_CRITICAL_UPDATE,
-        value: criticalUpdate
-      }
-    );
-  }
-
-  return request;
-};
+import { deprecateLegacyPublishSurface } from '../portal/compat.js';
+import type { PublishSolanaNetworkInput } from './types.js';
 
 export type PublishRemoveInput = {
   appMintAddress: string;
   releaseMintAddress: string;
-  publisherDetails: Publisher;
+  publisherDetails: {
+    name: string;
+    website: string;
+    email: string;
+  };
   requestorIsAuthorized: boolean;
   criticalUpdate: boolean;
 };
 
 export const publishRemove = async (
-  publishSolanaNetworkInput: PublishSolanaNetworkInput,
-  {
-    appMintAddress,
-    releaseMintAddress,
-    publisherDetails,
-    requestorIsAuthorized,
-    criticalUpdate,
-  } : PublishRemoveInput,
-  dryRun: boolean,
-) => {
-  const removeRequest = await createRemoveRequest(
-    publishSolanaNetworkInput.connection,
-    publishSolanaNetworkInput.sign,
-    appMintAddress,
-    releaseMintAddress,
-    publisherDetails,
-    requestorIsAuthorized,
-    criticalUpdate);
-
-  return submitRequestToSolanaDappPublisherPortal(removeRequest, URL_FORM_REMOVE, dryRun);
+  _publishSolanaNetworkInput: PublishSolanaNetworkInput,
+  _input: PublishRemoveInput,
+  _dryRun: boolean,
+): Promise<never> => {
+  deprecateLegacyPublishSurface('publishRemove');
+  return undefined as never;
 };