@parity/product-deploy 0.7.28-rc.0

package/dist/manifest/publish.js

@@ -0,0 +1,23 @@
+import {
+  publishManifest
+} from "../chunk-NF2FL4ZO.js";
+import "../chunk-RI3ZLNPN.js";
+import "../chunk-P6CHOMN3.js";
+import "../chunk-KHVTYIIX.js";
+import "../chunk-KOSF5FDO.js";
+import "../chunk-FZWJV5AD.js";
+import "../chunk-S7EM5VMW.js";
+import "../chunk-ADNBLFDP.js";
+import "../chunk-43HLT335.js";
+import "../chunk-QTZNULSH.js";
+import "../chunk-C2TS5MER.js";
+import "../chunk-DNXH4QTI.js";
+import "../chunk-QMYW3D6E.js";
+import "../chunk-MFTODIIT.js";
+import "../chunk-KJH2T5TQ.js";
+import "../chunk-OITUIM2E.js";
+import "../chunk-ZOC4GITL.js";
+import "../chunk-HOTQDYHD.js";
+export {
+  publishManifest
+};

package/dist/manifest/schema.d.ts

@@ -0,0 +1,29 @@
+import { ExecutableManifest, ProductConfig, RootManifest } from './types.js';
+
+/**
+ * Handwritten validators for product-manifest shapes.
+ *
+ * Domain validation is shape-only. It mirrors dotNS label rules without
+ * importing the chain-aware [`parseDomainName`](../dotns.ts) helper, so the
+ * module stays free of the polkadot-api dep. Authoritative ownership and
+ * eligibility checks happen at publish-time preflight in
+ * [`publish.ts`](./publish.ts).
+ */
+
+interface ValidationOk<T> {
+    ok: true;
+    value: T;
+}
+interface ValidationErr {
+    ok: false;
+    errors: string[];
+}
+type ValidationResult<T> = ValidationOk<T> | ValidationErr;
+/** Validate a `RootManifest` JSON value read from a dotNS `manifest` text record. */
+declare function validateRootManifest(input: unknown): ValidationResult<RootManifest>;
+/** Validate an `ExecutableManifest` JSON value (one of `app | widget | worker`). */
+declare function validateExecutableManifest(input: unknown): ValidationResult<ExecutableManifest>;
+/** Validate a `bulletin-deploy.config.ts` default export. */
+declare function validateProductConfig(input: unknown): ValidationResult<ProductConfig>;
+
+export { type ValidationErr, type ValidationOk, type ValidationResult, validateExecutableManifest, validateProductConfig, validateRootManifest };

package/dist/manifest/schema.js

@@ -0,0 +1,10 @@
+import {
+  validateExecutableManifest,
+  validateProductConfig,
+  validateRootManifest
+} from "../chunk-LZJMVPYW.js";
+export {
+  validateExecutableManifest,
+  validateProductConfig,
+  validateRootManifest
+};

package/dist/manifest/types.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Product-manifest type definitions per RFC paritytech/triangle-js-sdks #0001.
+ *
+ * Two-level shape: a `RootManifest` written as the `manifest` text record on
+ * `<product_id>.dot`, plus one `ExecutableManifest` per modality written as
+ * the `executable` text record on `app|widget|worker.<product_id>.dot`.
+ *
+ * Unrelated to [src/manifest.ts](../manifest.ts), which models the embedded
+ * deploy manifest that ships inside each CAR.
+ */
+type IconFormat = "jpeg" | "png";
+type AppVersion = readonly [number, number, number] | readonly [number, number, number, string];
+interface Icon {
+    cid: string;
+    format: IconFormat;
+}
+interface RootManifest {
+    $v: 1;
+    displayName: string;
+    description: string;
+    icon: Icon;
+}
+interface CommonExecutableFields {
+    $v: 1;
+    appVersion: AppVersion;
+}
+interface AppManifest extends CommonExecutableFields {
+    kind: "app";
+}
+interface WidgetDimensions {
+    height: number[];
+    width?: number;
+}
+interface WidgetManifest extends CommonExecutableFields {
+    kind: "widget";
+    description?: string;
+    dimensions: WidgetDimensions;
+}
+interface WorkerIncludes {
+    chat: boolean;
+    pocket: boolean;
+}
+interface WorkerManifest extends CommonExecutableFields {
+    kind: "worker";
+    entrypoint: string;
+    includes: WorkerIncludes;
+}
+type ExecutableManifest = AppManifest | WidgetManifest | WorkerManifest;
+type ExecutableKind = ExecutableManifest["kind"];
+interface AppExecutableConfig {
+    kind: "app";
+    path: string;
+    appVersion: AppVersion;
+}
+interface WidgetExecutableConfig {
+    kind: "widget";
+    path: string;
+    appVersion: AppVersion;
+    description?: string;
+    dimensions: WidgetDimensions;
+}
+interface WorkerExecutableConfig {
+    kind: "worker";
+    path: string;
+    appVersion: AppVersion;
+    entrypoint: string;
+    includes: WorkerIncludes;
+}
+type ExecutableConfig = AppExecutableConfig | WidgetExecutableConfig | WorkerExecutableConfig;
+interface IconConfig {
+    path: string;
+    format: IconFormat;
+}
+interface ProductConfig {
+    domain: string;
+    displayName: string;
+    description: string;
+    icon: IconConfig;
+    executables: ExecutableConfig[];
+}
+/**
+ * Identity helper that lets `bulletin-deploy.config.ts` authors get IntelliSense on the discriminated `ExecutableConfig` union.
+ *
+ * @example
+ *   import { defineConfig } from "bulletin-deploy";
+ *   export default defineConfig({ domain: "hackm3.dot", ... });
+ */
+declare function defineConfig<T extends ProductConfig>(config: T): T;
+
+export { type AppExecutableConfig, type AppManifest, type AppVersion, type ExecutableConfig, type ExecutableKind, type ExecutableManifest, type Icon, type IconConfig, type IconFormat, type ProductConfig, type RootManifest, type WidgetDimensions, type WidgetExecutableConfig, type WidgetManifest, type WorkerExecutableConfig, type WorkerIncludes, type WorkerManifest, defineConfig };

package/dist/manifest/types.js

@@ -0,0 +1,6 @@
+import {
+  defineConfig
+} from "../chunk-GZD2UFLR.js";
+export {
+  defineConfig
+};

package/dist/manifest-embed.d.ts

@@ -0,0 +1,18 @@
+import { ManifestFileEntry, ManifestChunkEntry } from './manifest.js';
+
+interface PlaceholderInput {
+    version: number;
+    previousContenthash: string | null;
+    deployedAt: string;
+    framework: string | null;
+}
+interface FinaliseInput extends PlaceholderInput {
+    files: Record<string, ManifestFileEntry>;
+    stableBlockOrder: string[];
+    blocks: string[];
+    chunks: Record<string, ManifestChunkEntry>;
+}
+declare function writeEmbeddedManifestPlaceholder(buildDir: string, data: PlaceholderInput): void;
+declare function finaliseEmbeddedManifest(buildDir: string, data: FinaliseInput): void;
+
+export { finaliseEmbeddedManifest, writeEmbeddedManifestPlaceholder };

package/dist/manifest-embed.js

@@ -0,0 +1,9 @@
+import {
+  finaliseEmbeddedManifest,
+  writeEmbeddedManifestPlaceholder
+} from "./chunk-KOSF5FDO.js";
+import "./chunk-S7EM5VMW.js";
+export {
+  finaliseEmbeddedManifest,
+  writeEmbeddedManifestPlaceholder
+};

package/dist/manifest-fetch.d.ts

@@ -0,0 +1,32 @@
+import { EmbeddedManifest } from './manifest.js';
+
+declare const DEFAULT_TIMEOUT_MS = 30000;
+declare const SIDECAR_FILENAME = ".last_deploy_cid";
+type FetchOutcome = {
+    source: "embedded";
+    manifest: EmbeddedManifest;
+    attempts: number;
+    bytesDownloaded?: number;
+} | {
+    source: "heuristic_fallback";
+    reason: string;
+    attempts: number;
+    bytesDownloaded?: number;
+} | {
+    source: "none";
+};
+interface FetchOptions {
+    gateway?: string;
+    gateways?: string[];
+    timeoutMs?: number;
+    domain?: string;
+    buildDir?: string;
+}
+declare function getCacheDir(): string | null;
+declare function readPersistentLocalManifest(domain: string | undefined, prevContenthash: string): FetchOutcome | null;
+declare function writePersistentLocalManifest(domain: string, storageCid: string, manifestJson: string): void;
+declare function fetchPreviousManifest(prevContenthash: string | null, options?: FetchOptions): Promise<FetchOutcome>;
+declare function extractManifestFromCar(carBytes: Uint8Array): Promise<Uint8Array | null>;
+declare function walkDagToManifest(blocks: Map<string, Uint8Array>, rootCid: string): Promise<Uint8Array | null>;
+
+export { DEFAULT_TIMEOUT_MS, type FetchOptions, type FetchOutcome, SIDECAR_FILENAME, extractManifestFromCar, fetchPreviousManifest, getCacheDir, readPersistentLocalManifest, walkDagToManifest, writePersistentLocalManifest };

package/dist/manifest-fetch.js

@@ -0,0 +1,21 @@
+import {
+  DEFAULT_TIMEOUT_MS,
+  SIDECAR_FILENAME,
+  extractManifestFromCar,
+  fetchPreviousManifest,
+  getCacheDir,
+  readPersistentLocalManifest,
+  walkDagToManifest,
+  writePersistentLocalManifest
+} from "./chunk-FZWJV5AD.js";
+import "./chunk-S7EM5VMW.js";
+export {
+  DEFAULT_TIMEOUT_MS,
+  SIDECAR_FILENAME,
+  extractManifestFromCar,
+  fetchPreviousManifest,
+  getCacheDir,
+  readPersistentLocalManifest,
+  walkDagToManifest,
+  writePersistentLocalManifest
+};

package/dist/manifest-roundtrip.d.ts

@@ -0,0 +1,15 @@
+interface RoundtripOptions {
+    gateway: string;
+    budgetMs?: number;
+    pollIntervalMs?: number;
+    perRequestTimeoutMs?: number;
+}
+declare function fetchManifestRoundtrip(cid: string, options: RoundtripOptions): Promise<{
+    ok: true;
+    manifestBytes: Uint8Array;
+} | {
+    ok: false;
+    reason: string;
+}>;
+
+export { type RoundtripOptions, fetchManifestRoundtrip };

package/dist/manifest-roundtrip.js

@@ -0,0 +1,55 @@
+import {
+  extractManifestFromCar
+} from "./chunk-FZWJV5AD.js";
+import "./chunk-S7EM5VMW.js";
+
+// src/manifest-roundtrip.ts
+async function fetchManifestRoundtrip(cid, options) {
+  const gateway = options.gateway.replace(/\/$/, "");
+  const budget = options.budgetMs ?? 3e4;
+  const poll = options.pollIntervalMs ?? 2e3;
+  const perReq = options.perRequestTimeoutMs ?? 1e4;
+  const start = Date.now();
+  let lastReason = "no attempts";
+  while (Date.now() - start < budget) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), perReq);
+    let res;
+    try {
+      res = await fetch(`${gateway}/ipfs/${cid}`, { signal: ctrl.signal });
+    } catch (e) {
+      lastReason = `network: ${e?.message ?? e}`;
+      clearTimeout(timer);
+      await sleep(poll);
+      continue;
+    } finally {
+      clearTimeout(timer);
+    }
+    if (res.status === 404 || res.status === 504) {
+      lastReason = `gateway HTTP ${res.status}`;
+      await sleep(poll);
+      continue;
+    }
+    if (res.status !== 200) {
+      lastReason = `gateway HTTP ${res.status}`;
+      await sleep(poll);
+      continue;
+    }
+    const buf = await res.arrayBuffer();
+    const carBytes = new Uint8Array(buf);
+    const manifestBytes = await extractManifestFromCar(carBytes);
+    if (!manifestBytes) {
+      lastReason = "manifest not in deployed DAG";
+      await sleep(poll);
+      continue;
+    }
+    return { ok: true, manifestBytes };
+  }
+  return { ok: false, reason: `roundtrip budget exhausted: ${lastReason}` };
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+export {
+  fetchManifestRoundtrip
+};

package/dist/manifest.d.ts

@@ -0,0 +1,44 @@
+declare const MANIFEST_VERSION = 3;
+declare const MANIFEST_DIR = ".bulletin-deploy";
+declare const MANIFEST_FILENAME = "manifest.json";
+declare const MANIFEST_PATH = ".bulletin-deploy/manifest.json";
+type FileType = "stable" | "volatile";
+interface ManifestFileEntry {
+    cid: string;
+    type: FileType;
+    size?: number;
+}
+interface ManifestChunkEntry {
+    size: number;
+    deployed_at: string;
+    block?: number;
+    index?: number;
+}
+interface EmbeddedManifest {
+    version: number;
+    previous_contenthash: string | null;
+    deployed_at: string;
+    framework: string | null;
+    files: Record<string, ManifestFileEntry>;
+    stableBlockOrder: string[];
+    blocks: string[];
+    chunks: Record<string, ManifestChunkEntry>;
+}
+declare function isVolatilePath(p: string): boolean;
+type ClassifyContext = {
+    prevManifest?: EmbeddedManifest | null;
+    framework?: string | null;
+    fileCid?: string;
+};
+declare function classifyFileHeuristic(filePath: string, framework?: string | null): FileType;
+declare function classifyFile(filePath: string, ctx?: ClassifyContext): FileType;
+type ParseResult = {
+    ok: true;
+    manifest: EmbeddedManifest;
+} | {
+    ok: false;
+    error: string;
+};
+declare function parseManifest(raw: string): ParseResult;
+
+export { type ClassifyContext, type EmbeddedManifest, type FileType, MANIFEST_DIR, MANIFEST_FILENAME, MANIFEST_PATH, MANIFEST_VERSION, type ManifestChunkEntry, type ManifestFileEntry, type ParseResult, classifyFile, classifyFileHeuristic, isVolatilePath, parseManifest };

package/dist/manifest.js

@@ -0,0 +1,20 @@
+import {
+  MANIFEST_DIR,
+  MANIFEST_FILENAME,
+  MANIFEST_PATH,
+  MANIFEST_VERSION,
+  classifyFile,
+  classifyFileHeuristic,
+  isVolatilePath,
+  parseManifest
+} from "./chunk-S7EM5VMW.js";
+export {
+  MANIFEST_DIR,
+  MANIFEST_FILENAME,
+  MANIFEST_PATH,
+  MANIFEST_VERSION,
+  classifyFile,
+  classifyFileHeuristic,
+  isVolatilePath,
+  parseManifest
+};

package/dist/memory-report.d.ts

@@ -0,0 +1,95 @@
+import * as v8 from 'node:v8';
+
+declare function isBunRuntime(): boolean;
+declare const DEFAULT_THRESHOLD_MB = 800;
+interface MemorySampleMb {
+    rssMb: number;
+    heapUsedMb: number;
+    externalMb: number;
+    arrayBuffersMb: number;
+}
+interface DeployContextForReport {
+    /** Sanitized domain label (sanitizeBranch equivalent). No dots. */
+    domain?: string;
+    /** Sanitized repo slug. Matches what the deploy span already carries. */
+    repo?: string;
+    deployTag?: string;
+    deployMode?: "pool" | "direct" | "external";
+    jsMerkle?: boolean;
+    chunkCount?: number;
+    carBytes?: number;
+    reconnects?: number;
+    durationMs?: number;
+    sentryTraceId?: string;
+}
+interface MemoryReport {
+    schemaVersion: 1;
+    toolVersion: string;
+    generatedAt: string;
+    threshold: {
+        thresholdMb: number;
+        peakRssMb: number;
+    };
+    deploy: DeployContextForReport;
+    memory: {
+        peak: MemorySampleMb;
+        stages: Record<string, MemorySampleMb>;
+    };
+    v8: {
+        heapStatistics: ReturnType<typeof v8.getHeapStatistics> | undefined;
+        heapSpaceStatistics: ReturnType<typeof v8.getHeapSpaceStatistics> | undefined;
+    };
+    runtime: {
+        nodeVersion: string;
+        platform: string;
+        arch: string;
+        totalMemMb: number;
+        freeMemMb: number;
+        cpuCount: number;
+        activeHandlesByType: Record<string, number>;
+        activeRequestsByType: Record<string, number>;
+    };
+    polkadotApi?: {
+        version?: string;
+        clientsCreated?: number;
+    };
+}
+declare function safeHeap<T>(f: () => T): T | undefined;
+declare function buildMemoryReport(input: {
+    thresholdMb: number;
+    peak: MemorySampleMb;
+    stages: Record<string, MemorySampleMb>;
+    deploy: DeployContextForReport;
+}): MemoryReport;
+interface MaybeWriteMemoryReportInput {
+    peak: MemorySampleMb;
+    stages: Record<string, MemorySampleMb>;
+    deploy: DeployContextForReport;
+    /** Where to write the report file. Usually the build directory. */
+    outputDir?: string;
+    /** Override the default 1500 MB threshold (BULLETIN_DEPLOY_MEM_REPORT_THRESHOLD_MB). */
+    thresholdMbOverride?: number;
+    /** Hook for tests — defaults to isInternalContext(). */
+    isInternal?: () => boolean;
+    /** Hook for tests — defaults to real fs writes. */
+    writeFile?: (path: string, content: string) => void;
+    /** Hook for tests — receives the report when it would be attached to Sentry. */
+    onSentryAttach?: (report: MemoryReport) => void;
+}
+interface MemoryReportResult {
+    /** Why the report did/didn't fire. Useful for tests and CLI logging. */
+    status: "disabled" | "below-threshold" | "not-internal" | "written" | "unsupported-runtime";
+    thresholdMb: number;
+    peakRssMb: number;
+    path?: string;
+}
+declare function maybeWriteMemoryReport(input: MaybeWriteMemoryReportInput): MemoryReportResult;
+/** Convert a MemorySample with raw byte fields into the MB-shaped sample. */
+declare function sampleFromBytes(m: {
+    rss: number;
+    heapUsed: number;
+    external: number;
+    arrayBuffers: number;
+}): MemorySampleMb;
+
+export { DEFAULT_THRESHOLD_MB, type DeployContextForReport, type MaybeWriteMemoryReportInput, type MemoryReport, type MemoryReportResult, type MemorySampleMb, buildMemoryReport, isBunRuntime, maybeWriteMemoryReport, safeHeap, sampleFromBytes };

package/dist/memory-report.js

@@ -0,0 +1,17 @@
+import {
+  DEFAULT_THRESHOLD_MB,
+  buildMemoryReport,
+  isBunRuntime,
+  maybeWriteMemoryReport,
+  safeHeap,
+  sampleFromBytes
+} from "./chunk-MFTODIIT.js";
+import "./chunk-KJH2T5TQ.js";
+export {
+  DEFAULT_THRESHOLD_MB,
+  buildMemoryReport,
+  isBunRuntime,
+  maybeWriteMemoryReport,
+  safeHeap,
+  sampleFromBytes
+};

package/dist/merkle.d.ts

@@ -0,0 +1,50 @@
+interface MerkleizeResult {
+    carBytes: Uint8Array;
+    cid: string;
+}
+interface MerkleizeStableResult extends MerkleizeResult {
+    blockOrder: string[];
+    stableOrder: string[];
+    chunks: Uint8Array[];
+    chunkCids: string[];
+    section1ChunkCids: string[];
+    sectionSizes: {
+        section0: number;
+        section1: number;
+        section2: number;
+    };
+    sectionChunkCounts: {
+        section0: number;
+        section1: number;
+        section2: number;
+    };
+    /** All DAG blocks from the merkleize backend: cid → block bytes. */
+    blocks: Map<string, Uint8Array>;
+    /** File path → user-facing CID (leaf for single-block, dag-pb root for multi-block). */
+    fileCids: Map<string, string>;
+}
+interface MerkleizeOutput {
+    rootCid: string;
+    blocks: Map<string, Uint8Array>;
+    fileBlocks: Map<string, string[]>;
+    fileCids: Map<string, string>;
+    rootBlockCids: string[];
+    subdirCids: string[];
+}
+declare function merkleizeJSBackend(directoryPath: string): Promise<MerkleizeOutput>;
+declare function merkleizeKuboBackend(directoryPath: string): Promise<MerkleizeOutput>;
+declare function merkleizeBackend(directoryPath: string, useKubo: boolean): Promise<MerkleizeOutput>;
+interface BuildOrderedCarOptions {
+    output: MerkleizeOutput;
+    classifyFn?: (filePath: string, fileCid?: string) => "stable" | "volatile";
+    prevStableOrder?: string[];
+}
+declare function buildOrderedCar(options: BuildOrderedCarOptions): Promise<MerkleizeStableResult>;
+declare function rebuildOrderedCarFromBytes(carBytes: Uint8Array, prevStableOrder?: string[]): Promise<MerkleizeStableResult>;
+declare function merkleizeWithStableOrder(directoryPath: string, prevStableOrder?: string[], options?: {
+    useKubo?: boolean;
+    classifyFn?: (filePath: string) => "stable" | "volatile";
+}): Promise<MerkleizeStableResult>;
+declare function merkleizeJS(directoryPath: string): Promise<MerkleizeResult>;
+
+export { type BuildOrderedCarOptions, type MerkleizeOutput, type MerkleizeResult, type MerkleizeStableResult, buildOrderedCar, merkleizeBackend, merkleizeJS, merkleizeJSBackend, merkleizeKuboBackend, merkleizeWithStableOrder, rebuildOrderedCarFromBytes };

package/dist/merkle.js

@@ -0,0 +1,33 @@
+import {
+  buildOrderedCar,
+  merkleizeBackend,
+  merkleizeJS,
+  merkleizeJSBackend,
+  merkleizeKuboBackend,
+  merkleizeWithStableOrder,
+  rebuildOrderedCarFromBytes
+} from "./chunk-P6CHOMN3.js";
+import "./chunk-KHVTYIIX.js";
+import "./chunk-KOSF5FDO.js";
+import "./chunk-FZWJV5AD.js";
+import "./chunk-S7EM5VMW.js";
+import "./chunk-ADNBLFDP.js";
+import "./chunk-43HLT335.js";
+import "./chunk-QTZNULSH.js";
+import "./chunk-C2TS5MER.js";
+import "./chunk-DNXH4QTI.js";
+import "./chunk-QMYW3D6E.js";
+import "./chunk-MFTODIIT.js";
+import "./chunk-KJH2T5TQ.js";
+import "./chunk-OITUIM2E.js";
+import "./chunk-ZOC4GITL.js";
+import "./chunk-HOTQDYHD.js";
+export {
+  buildOrderedCar,
+  merkleizeBackend,
+  merkleizeJS,
+  merkleizeJSBackend,
+  merkleizeKuboBackend,
+  merkleizeWithStableOrder,
+  rebuildOrderedCarFromBytes
+};

package/dist/personhood/bind-paid-alias.d.ts

@@ -0,0 +1,43 @@
+import { SS58String, PolkadotSigner } from 'polkadot-api';
+
+type PaidAliasBindingErrorKind = "NotARecognizedPerson" | "RingRootNotFound" | "PaidAliasFeeUnset" | "InsufficientPgas" | "BadProof" | "DispatchError" | "RpcError" | "ClientError" | "Unknown";
+declare class PaidAliasBindingError extends Error {
+    readonly kind: PaidAliasBindingErrorKind;
+    readonly dispatchError?: unknown;
+    constructor(message: string, options?: ErrorOptions & {
+        kind?: PaidAliasBindingErrorKind;
+        dispatchError?: unknown;
+    });
+}
+type RingExponent = 9 | 10 | 14;
+interface BuildRingProofInput {
+    ringExponent: RingExponent;
+    members: Uint8Array;
+    context: Uint8Array;
+    msg: Uint8Array;
+}
+type BuildRingProof = (input: BuildRingProofInput) => Promise<{
+    proof: Uint8Array;
+    alias: Uint8Array;
+}>;
+interface PaidAliasBindingProgress {
+    onBroadcasted?: () => void;
+    onBestBlock?: (blockHash: string) => void;
+}
+interface BindPaidAliasParams {
+    peopleUnsafeApi: unknown;
+    ahUnsafeApi: unknown;
+    account: SS58String;
+    memberKey: Uint8Array;
+    contextBytes: Uint8Array;
+    signCall: PolkadotSigner;
+    buildRingProof: BuildRingProof;
+    progress?: PaidAliasBindingProgress;
+}
+interface BindPaidAliasResult {
+    blockHash: string;
+    alias: Uint8Array;
+}
+declare const bindPaidAliasToAccount: ({ peopleUnsafeApi, ahUnsafeApi, account, memberKey, contextBytes, signCall, buildRingProof, progress, }: BindPaidAliasParams) => Promise<BindPaidAliasResult>;
+
+export { type BindPaidAliasParams, type BindPaidAliasResult, type BuildRingProof, type BuildRingProofInput, PaidAliasBindingError, type PaidAliasBindingErrorKind, type PaidAliasBindingProgress, type RingExponent, bindPaidAliasToAccount };

package/dist/personhood/bind-paid-alias.js

@@ -0,0 +1,10 @@
+import {
+  PaidAliasBindingError,
+  bindPaidAliasToAccount
+} from "../chunk-5VZQ2KSU.js";
+import "../chunk-T7EEVWNU.js";
+import "../chunk-ZYVGHDMU.js";
+export {
+  PaidAliasBindingError,
+  bindPaidAliasToAccount
+};