bulletin-deploy 0.5.3-rc.1 → 0.5.3

package/dist/{chunk-HRMYZ3GK.js → chunk-JF2UR7FV.js}

@@ -3,7 +3,7 @@ import {
   DotNS,
   TX_TIMEOUT_MS,
   fetchNonce
-} from "./chunk-XD7NNFWX.js";
+} from "./chunk-W23LLCZF.js";
 import {
   derivePoolAccounts,
   ensureAuthorized,
@@ -239,7 +239,7 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
     const MAX_CHUNK_RETRIES = 3;
     console.log(`
    Submitting ${chunks.length} chunks in batches of ${BATCH_SIZE}...`);
-    const stored = [];
+    const stored = new Array(chunks.length).fill(null);
     for (let b = 0; b < chunks.length; b += BATCH_SIZE) {
       const batch = chunks.slice(b, b + BATCH_SIZE);
       const batchIndices = batch.map((_, j) => b + j);
@@ -250,9 +250,9 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
         return storeChunk(unsafeApi, signer, chunkData, nonce, ss58);
       });
       const results = await Promise.allSettled(batchPromises);
-      for (const r of results) {
-        if (r.status === "fulfilled") stored.push(r.value);
-      }
+      results.forEach((r, j) => {
+        if (r.status === "fulfilled") stored[batchIndices[j]] = r.value;
+      });
       const failures = results.map((r, j) => r.status === "rejected" ? { index: batchIndices[j], chunkData: batch[j], error: r.reason } : null).filter(Boolean);
       for (const fail of failures) {
         captureWarning("Chunk upload failed, retrying", { chunkIndex: fail.index + 1, maxRetries: MAX_CHUNK_RETRIES, error: fail.error?.message?.slice(0, 200) });
@@ -263,7 +263,7 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
           const freshNonce = await fetchNonce(BULLETIN_RPC, ss58);
           try {
             const result2 = await storeChunk(unsafeApi, signer, fail.chunkData, freshNonce, ss58);
-            stored.push(result2);
+            stored[fail.index] = result2;
             retried = true;
             break;
           } catch (e) {
@@ -279,9 +279,22 @@ async function storeChunkedContent(chunks, { client: existingClient, unsafeApi:
     setDeployAttribute("deploy.pool.account", ss58);
     console.log(`
    All ${chunks.length} chunks included in block`);
+    console.log(`   Verifying chunk integrity...`);
+    const missing = stored.map((c, i) => c === null ? i + 1 : null).filter(Boolean);
+    if (missing.length > 0) {
+      throw new Error(`Chunk verification failed: missing chunks at positions ${missing.join(", ")}`);
+    }
+    const verifiedStored = stored;
+    for (let i = 0; i < chunks.length; i++) {
+      const expectedCid = createCID(chunks[i], CID_CONFIG.codec, 18);
+      if (verifiedStored[i].cid.toString() !== expectedCid.toString()) {
+        throw new Error(`Chunk verification failed: chunk ${i + 1} CID mismatch (expected ${expectedCid}, got ${verifiedStored[i].cid})`);
+      }
+    }
+    console.log(`   All ${chunks.length} chunks verified \u2713`);
     console.log(`   Building DAG-PB...`);
-    const fileData = new UnixFS({ type: "file", blockSizes: stored.map((c) => BigInt(c.len)) });
-    const dagNode = dagPB.prepare({ Data: fileData.marshal(), Links: stored.map((c) => ({ Name: "", Tsize: c.len, Hash: c.cid })) });
+    const fileData = new UnixFS({ type: "file", blockSizes: verifiedStored.map((c) => BigInt(c.len)) });
+    const dagNode = dagPB.prepare({ Data: fileData.marshal(), Links: verifiedStored.map((c) => ({ Name: "", Tsize: c.len, Hash: c.cid })) });
     const dagBytes = dagPB.encode(dagNode);
     const hashCode = 18;
     const rootCid = createCID(dagBytes, 112, hashCode);

package/dist/{chunk-XD7NNFWX.js → chunk-W23LLCZF.js}

@@ -181,11 +181,19 @@ function countTrailingDigits(label) {
 function stripTrailingDigits(label) {
   return label.replace(/\d+$/, "").replace(/-$/, "");
 }
+function sanitizeDomainLabel(label) {
+  const trailingDigitCount = countTrailingDigits(label);
+  if (trailingDigitCount > 2) {
+    const sanitized = stripTrailingDigits(label) + label.slice(-2);
+    console.log(`   Domain label sanitized: "${label}" \u2192 "${sanitized}" (stripped excess trailing digits)`);
+    return sanitized;
+  }
+  return label;
+}
 function validateDomainLabel(label) {
   if (!/^[a-z0-9-]{3,}$/.test(label)) throw new Error("Invalid domain label: must contain only lowercase letters, digits, and hyphens, min 3 chars");
   if (label.startsWith("-") || label.endsWith("-")) throw new Error("Invalid domain label: cannot start or end with hyphen");
-  const trailingDigitCount = countTrailingDigits(label);
-  if (trailingDigitCount > 2) throw new Error(`Invalid domain label: max 2 trailing digits allowed, found ${trailingDigitCount}`);
+  return sanitizeDomainLabel(label);
 }
 function parseProofOfPersonhoodStatus(status) {
   const s = (status ?? "none").toLowerCase();
@@ -495,7 +503,7 @@ var DotNS = class {
     this.ensureConnected();
     console.log(`
    Generating commitment hash...`);
-    validateDomainLabel(label);
+    label = validateDomainLabel(label);
     const secret = `0x${crypto.randomBytes(32).toString("hex")}`;
     const registration = { label, owner: this.evmAddress, secret, reserved: includeReverse };
     const commitment = await withTimeout(this.contractCall(CONTRACTS.DOTNS_REGISTRAR_CONTROLLER, DOTNS_REGISTRAR_CONTROLLER_ABI, "makeCommitment", [registration]), 3e4, "Commitment generation");
@@ -526,7 +534,7 @@ var DotNS = class {
     this.ensureConnected();
     console.log(`
    Checking price and eligibility...`);
-    validateDomainLabel(label);
+    label = validateDomainLabel(label);
     const baseName = stripTrailingDigits(label);
     const reservationInfo = await withTimeout(this.contractCall(CONTRACTS.POP_RULES, POP_RULES_ABI, "isBaseNameReserved", [baseName]), 3e4, "isBaseNameReserved");
     const [isReserved, reservationOwner] = reservationInfo;
@@ -602,7 +610,7 @@ var DotNS = class {
       const status = parseProofOfPersonhoodStatus(options.status || process.env.DOTNS_STATUS);
       const reverse = options.reverse ?? (process.env.DOTNS_REVERSE ?? "false").toLowerCase() === "true";
       if (!this.connected) await this.connect(options);
-      validateDomainLabel(label);
+      label = validateDomainLabel(label);
       await Promise.all([
         this.classifyName(label),
         this.ensureNotRegistered(label),
@@ -645,6 +653,7 @@ export {
   computeDomainTokenId,
   countTrailingDigits,
   stripTrailingDigits,
+  sanitizeDomainLabel,
   validateDomainLabel,
   parseProofOfPersonhoodStatus,
   DotNS,

package/dist/deploy.d.ts

@@ -0,0 +1,33 @@
+import { CID } from 'multiformats/cid';
+import { PolkadotSigner } from 'polkadot-api';
+
+interface DeployResult {
+    domainName: string;
+    fullDomain: string;
+    cid: string;
+    ipfsCid?: string;
+}
+type DeployContent = string | Uint8Array | Uint8Array[];
+interface ExistingProvider {
+    client?: any;
+    unsafeApi?: any;
+    signer?: PolkadotSigner;
+    ss58?: string;
+}
+declare function createCID(data: Uint8Array, codec?: number, hashCode?: number): CID;
+declare function encodeContenthash(cidString: string): string;
+declare function storeFile(contentBytes: Uint8Array, { client: existingClient, unsafeApi: existingApi, signer: existingSigner }?: ExistingProvider): Promise<string>;
+declare function storeChunkedContent(chunks: Uint8Array[], { client: existingClient, unsafeApi: existingApi, signer: existingSigner, ss58: existingSS58 }?: ExistingProvider): Promise<string>;
+declare function chunk(data: Uint8Array, size?: number): Uint8Array[];
+declare function hasIPFS(): boolean;
+declare function merkleize(directoryPath: string, outputCarPath: string): Promise<{
+    carPath: string;
+    cid: string;
+}>;
+declare function storeDirectory(directoryPath: string): Promise<{
+    storageCid: string;
+    ipfsCid: string;
+}>;
+declare function deploy(content: DeployContent, domainName?: string | null): Promise<DeployResult>;
+
+export { type DeployContent, type DeployResult, chunk, createCID, deploy, encodeContenthash, hasIPFS, merkleize, storeChunkedContent, storeDirectory, storeFile };

package/dist/deploy.js

@@ -8,8 +8,8 @@ import {
   storeChunkedContent,
   storeDirectory,
   storeFile
-} from "./chunk-HRMYZ3GK.js";
-import "./chunk-XD7NNFWX.js";
+} from "./chunk-JF2UR7FV.js";
+import "./chunk-W23LLCZF.js";
 import "./chunk-RV7XBIIO.js";
 import "./chunk-2RURGSQW.js";
 import "./chunk-QGM4M3NI.js";

package/dist/dotns.d.ts

@@ -0,0 +1,116 @@
+import { PolkadotSigner } from 'polkadot-api';
+
+interface DotNSConnectOptions {
+    rpc?: string;
+    keyUri?: string;
+    mnemonic?: string;
+}
+interface OwnershipResult {
+    owned: boolean;
+    owner: string | null;
+}
+interface PriceValidationResult {
+    priceWei: bigint;
+    requiredStatus: number;
+    userStatus: number;
+    message: string;
+}
+declare const RPC_ENDPOINTS: string[];
+declare const CONTRACTS: {
+    readonly DOTNS_REGISTRAR: "0x329aAA5b6bEa94E750b2dacBa74Bf41291E6c2BD";
+    readonly DOTNS_REGISTRAR_CONTROLLER: "0xd09e0F1c1E6CE8Cf40df929ef4FC778629573651";
+    readonly DOTNS_REGISTRY: "0x4Da0d37aBe96C06ab19963F31ca2DC0412057a6f";
+    readonly DOTNS_RESOLVER: "0x95645C7fD0fF38790647FE13F87Eb11c1DCc8514";
+    readonly DOTNS_CONTENT_RESOLVER: "0x7756DF72CBc7f062e7403cD59e45fBc78bed1cD7";
+    readonly DOTNS_REVERSE_RESOLVER: "0x95D57363B491CF743970c640fe419541386ac8BF";
+    readonly STORE_FACTORY: "0x030296782F4d3046B080BcB017f01837561D9702";
+    readonly POP_RULES: "0x4e8920B1E69d0cEA9b23CBFC87A17Ee6fE02d2d3";
+};
+declare const DECIMALS: bigint;
+declare const NATIVE_TO_ETH_RATIO: bigint;
+declare const OPERATION_TIMEOUT_MS: number;
+declare const TX_TIMEOUT_MS: number;
+declare const DEFAULT_MNEMONIC: string;
+declare function fetchNonce(rpc: string, ss58Address: string): Promise<number>;
+declare const ProofOfPersonhoodStatus: {
+    readonly NoStatus: 0;
+    readonly ProofOfPersonhoodLite: 1;
+    readonly ProofOfPersonhoodFull: 2;
+    readonly Reserved: 3;
+};
+declare const DOT_NODE: `0x${string}`;
+declare function convertWeiToNative(weiValue: bigint): bigint;
+declare function computeDomainTokenId(label: string): bigint;
+declare function countTrailingDigits(label: string): number;
+declare function stripTrailingDigits(label: string): string;
+declare function sanitizeDomainLabel(label: string): string;
+declare function validateDomainLabel(label: string): string;
+declare function parseProofOfPersonhoodStatus(status: string): number;
+declare class ReviveClientWrapper {
+    static DRY_RUN_STORAGE_LIMIT: bigint;
+    static DRY_RUN_WEIGHT_LIMIT: {
+        ref_time: bigint;
+        proof_size: bigint;
+    };
+    client: any;
+    mappedAccounts: Set<string>;
+    constructor(client: any);
+    getEvmAddress(substrateAddress: string): Promise<string>;
+    performDryRunCall(originSubstrateAddress: string, contractAddress: string, value: bigint, encodedData: string): Promise<any>;
+    estimateGasForCall(originSubstrateAddress: string, contractAddress: string, value: bigint, encodedData: string): Promise<any>;
+    checkIfAccountMapped(substrateAddress: string): Promise<boolean>;
+    ensureAccountMapped(substrateAddress: string, signer: PolkadotSigner): Promise<void>;
+    signAndSubmitExtrinsic(extrinsic: any, signer: PolkadotSigner, statusCallback: (status: string) => void, { rpc, senderSS58, expectedNonce }?: {
+        rpc?: string;
+        senderSS58?: string;
+        expectedNonce?: number;
+    }): Promise<string>;
+    submitTransaction(contractAddress: string, value: bigint, encodedData: string, signerSubstrateAddress: string, signer: PolkadotSigner, statusCallback: (status: string) => void, { rpc }?: {
+        rpc?: string;
+    }): Promise<string>;
+}
+declare class DotNS {
+    client: any | null;
+    clientWrapper: ReviveClientWrapper | null;
+    rpc: string | null;
+    substrateAddress: string | null;
+    evmAddress: string | null;
+    signer: PolkadotSigner | null;
+    connected: boolean;
+    constructor();
+    connect(options?: DotNSConnectOptions): Promise<this>;
+    ensureConnected(): void;
+    contractCall(contractAddress: string, contractAbi: readonly any[], functionName: string, args?: any[]): Promise<any>;
+    contractTransaction(contractAddress: string, value: bigint, contractAbi: readonly any[], functionName: string, args?: any[], statusCallback?: (status: string) => void): Promise<string>;
+    checkOwnership(label: string, ownerAddress?: string | null): Promise<OwnershipResult>;
+    classifyName(label: string): Promise<{
+        requiredStatus: number;
+        message: string;
+    }>;
+    getUserPopStatus(ownerAddress?: string | null): Promise<number>;
+    setUserPopStatus(status: number): Promise<void>;
+    ensureNotRegistered(label: string): Promise<void>;
+    generateCommitment(label: string, includeReverse?: boolean): Promise<{
+        commitment: any;
+        registration: any;
+    }>;
+    submitCommitment(commitment: any): Promise<void>;
+    waitForCommitmentAge(): Promise<void>;
+    getPriceAndValidate(label: string): Promise<PriceValidationResult>;
+    finalizeRegistration(registration: any, priceWei: bigint): Promise<void>;
+    verifyOwnership(label: string): Promise<void>;
+    setContenthash(domainName: string, contenthashHex: string): Promise<{
+        node: string;
+    }>;
+    register(label: string, options?: DotNSConnectOptions & {
+        status?: string;
+        reverse?: boolean;
+    }): Promise<{
+        label: string;
+        owner: string;
+    }>;
+    disconnect(): void;
+}
+declare const dotns: DotNS;
+
+export { CONTRACTS, DECIMALS, DEFAULT_MNEMONIC, DOT_NODE, DotNS, type DotNSConnectOptions, NATIVE_TO_ETH_RATIO, OPERATION_TIMEOUT_MS, type OwnershipResult, type PriceValidationResult, ProofOfPersonhoodStatus, RPC_ENDPOINTS, TX_TIMEOUT_MS, computeDomainTokenId, convertWeiToNative, countTrailingDigits, dotns, fetchNonce, parseProofOfPersonhoodStatus, sanitizeDomainLabel, stripTrailingDigits, validateDomainLabel };

package/dist/dotns.js

@@ -15,9 +15,10 @@ import {
   dotns,
   fetchNonce,
   parseProofOfPersonhoodStatus,
+  sanitizeDomainLabel,
   stripTrailingDigits,
   validateDomainLabel
-} from "./chunk-XD7NNFWX.js";
+} from "./chunk-W23LLCZF.js";
 import "./chunk-2RURGSQW.js";
 import "./chunk-QGM4M3NI.js";
 export {
@@ -37,6 +38,7 @@ export {
   dotns,
   fetchNonce,
   parseProofOfPersonhoodStatus,
+  sanitizeDomainLabel,
   stripTrailingDigits,
   validateDomainLabel
 };

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { DeployContent, DeployResult, deploy } from './deploy.js';
+export { PoolAccount, PoolAuthorization, bootstrapPool, derivePoolAccounts, ensureAuthorized, fetchPoolAuthorizations, selectAccount } from './pool.js';
+export { DotNS, DotNSConnectOptions, OwnershipResult, PriceValidationResult } from './dotns.js';
+import 'multiformats/cid';
+import 'polkadot-api';

package/dist/index.js

@@ -1,9 +1,9 @@
 import {
   deploy
-} from "./chunk-HRMYZ3GK.js";
+} from "./chunk-JF2UR7FV.js";
 import {
   DotNS
-} from "./chunk-XD7NNFWX.js";
+} from "./chunk-W23LLCZF.js";
 import {
   bootstrapPool,
   derivePoolAccounts,

package/dist/pool.d.ts

@@ -0,0 +1,20 @@
+import { PolkadotSigner } from 'polkadot-api';
+
+interface PoolAccount {
+    index: number;
+    path: string;
+    publicKey: Uint8Array;
+    signer: PolkadotSigner;
+    address: string;
+}
+interface PoolAuthorization extends PoolAccount {
+    transactions: bigint;
+    bytes: bigint;
+}
+declare function derivePoolAccounts(poolSize?: number, mnemonic?: string): PoolAccount[];
+declare function selectAccount(authorizations: PoolAuthorization[]): PoolAuthorization | null;
+declare function fetchPoolAuthorizations(api: any, accounts: PoolAccount[]): Promise<PoolAuthorization[]>;
+declare function ensureAuthorized(api: any, poolAccount: PoolAccount, bulletinRpc: string): Promise<void>;
+declare function bootstrapPool(bulletinRpc: string, poolSize?: number, mnemonic?: string): Promise<void>;
+
+export { type PoolAccount, type PoolAuthorization, bootstrapPool, derivePoolAccounts, ensureAuthorized, fetchPoolAuthorizations, selectAccount };

package/dist/telemetry.d.ts

@@ -0,0 +1,9 @@
+declare function initTelemetry(): void;
+declare function resolveRepo(domain: string): string;
+declare function withSpan<T>(op: string, description: string, attributes: Record<string, string | number | boolean | undefined>, fn: () => T | Promise<T>): Promise<T>;
+declare function withDeploySpan<T>(domain: string, fn: () => T | Promise<T>): Promise<T>;
+declare function setDeployAttribute(key: string, value: string | number | boolean): void;
+declare function captureWarning(message: string, context?: Record<string, unknown>): void;
+declare function flush(): Promise<void>;
+
+export { captureWarning, flush, initTelemetry, resolveRepo, setDeployAttribute, withDeploySpan, withSpan };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulletin-deploy",
-  "version": "0.5.3-rc.1",
+  "version": "0.5.3",
   "private": false,
   "repository": {
     "type": "git",