@parity/product-deploy 0.7.28-rc.0

package/dist/dotns.d.ts

@@ -0,0 +1,506 @@
+import { BootstrapResult } from './personhood/bootstrap.js';
+import { PopSelfServeConfig } from './environments.js';
+import { PolkadotSigner } from 'polkadot-api';
+import './personhood/bind-personal-id.js';
+import './personhood/claim-pgas.js';
+import './personhood/bind-paid-alias.js';
+
+interface DotNSConnectOptions {
+    rpc?: string;
+    keyUri?: string;
+    mnemonic?: string;
+    derivationPath?: string;
+    signer?: PolkadotSigner;
+    signerAddress?: string; /**
+       * Optional override for the Asset Hub RPC failover list. When provided, the
+       * primary RPC (this.rpc) is followed by these endpoints for retries. When
+       * omitted, the legacy hardcoded RPC_ENDPOINTS list (paseo) is used —
+       * preserves backwards-compatibility for external library consumers. The
+       * bulletin-deploy CLI passes the list resolved from environments.json so
+       * `--env <id>` drives both bulletin and asset-hub endpoints.
+      */
+    assetHubEndpoints?: string[];
+    autoAccountMapping?: boolean;
+    nativeToEthRatio?: bigint;
+    contracts?: Record<string, string>;
+    /** Optional environment ID (e.g. "paseo-next-v2"). Used in shell command examples in error messages. */
+    environmentId?: string;
+    /** Optional PoP self-serve config resolved from environments.json. Gates state-aware and generic testnet guidance blocks. */
+    popSelfServe?: PopSelfServeConfig | null;
+    /** Optional override for the storage deposit required for a fresh TLD register(). Loaded from environments.json per-env. */
+    registerStorageDeposit?: bigint;
+}
+interface OwnershipResult {
+    owned: boolean;
+    owner: string | null;
+}
+declare const TX_KIND_HASH: "hash";
+declare const TX_KIND_NONCE_ADVANCED: "nonce-advanced";
+declare const ATTR_TX_RESOLUTION_KIND = "deploy.dotns.tx_resolution_kind";
+type TxResolution = {
+    kind: typeof TX_KIND_HASH;
+    hash: string;
+    block?: {
+        hash: string;
+        number: number;
+    };
+} | {
+    kind: typeof TX_KIND_NONCE_ADVANCED;
+    rpc: string;
+};
+interface PriceValidationResult {
+    priceWei: bigint;
+    requiredStatus: number;
+    userStatus: number;
+    message: string;
+}
+interface ParsedDomainName {
+    isSubdomain: boolean;
+    label: string;
+    sublabel: string | null;
+    parentLabel: string | null;
+    fullName: string;
+}
+interface DotnsPreflightResult {
+    label: string;
+    classification: {
+        status: number;
+        message: string;
+    };
+    userStatus: number;
+    trailingDigits: number;
+    baselength: number;
+    isAvailable: boolean;
+    existingOwner: string | null;
+    isBaseNameReserved: boolean;
+    reservationOwner: string | null;
+    isTestnet: boolean;
+    canProceed: boolean;
+    reason?: string;
+    plannedAction: "register" | "already-owned-by-us" | "abort";
+    needsPopUpgrade: boolean;
+    targetPopStatus?: number;
+    /** Free PAS balance of the DotNS signer at preflight time, in plancks (10 decimals). */
+    signerFreeBalance?: bigint;
+    /** Threshold the signer must clear; depends on plannedAction. */
+    feeFloor?: bigint;
+    /** Set when an auto-top-up was attempted on testnet; describes the source and amount. */
+    toppedUp?: {
+        source: "Alice" | "Bob";
+        transferred: bigint;
+    };
+}
+declare const MINIMUM_REGISTER_STORAGE_DEPOSIT = 2000000000000n;
+declare function fmtPas(plancks: bigint): string;
+type DotnsSuccessAction = Exclude<DotnsPreflightResult["plannedAction"], "abort">;
+declare function feeFloorFor(plannedAction: DotnsSuccessAction, storageDeposit?: bigint): bigint;
+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 CONNECTION_TIMEOUT_MS: number;
+declare const OPERATION_TIMEOUT_MS: number;
+declare const TX_TIMEOUT_MS: number;
+declare const TX_CHAIN_TIME_BUDGET_MS: number;
+declare const TX_WALL_CLOCK_CEILING_MS: number;
+declare const WS_HEARTBEAT_TIMEOUT_MS: number;
+declare const DOTNS_TX_MAX_ATTEMPTS: number;
+declare function classifyTxRetryDecision(err: unknown): "retry" | "abort";
+declare const DEFAULT_MNEMONIC: string;
+declare function fetchNonce(rpc: string | string[], ss58Address: string): Promise<number>;
+declare function verifyNonceAdvanced(endpoints: string[], ss58Address: string, originalNonce: number): Promise<{
+    advanced: true;
+    witnessRpc: string;
+} | {
+    advanced: false;
+}>;
+declare const ProofOfPersonhoodStatus: {
+    readonly NoStatus: 0;
+    readonly ProofOfPersonhoodLite: 1;
+    readonly ProofOfPersonhoodFull: 2;
+    readonly Reserved: 3;
+};
+declare const PUBLISHER_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly name: "label";
+        readonly type: "string";
+    }];
+    readonly name: "publish";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "label";
+        readonly type: "string";
+    }];
+    readonly name: "unpublish";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "labelhash";
+        readonly type: "bytes32";
+    }];
+    readonly name: "isPublished";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "EmptyLabel";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "NoPersonhood";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "nextAllowedAt";
+        readonly type: "uint64";
+    }];
+    readonly name: "CooldownActive";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "caller";
+        readonly type: "address";
+    }, {
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly name: "NotOwner";
+    readonly type: "error";
+}];
+declare class PublisherNotSupportedError extends Error {
+    constructor(envName: string);
+}
+declare class ContractDryRunRevertError extends Error {
+    revertData: `0x${string}`;
+    revertFlags: bigint;
+    constructor(message: string, revertData: `0x${string}`, revertFlags: bigint);
+}
+declare function decodePublisherRevert(source: {
+    revertData?: `0x${string}`;
+} | `0x${string}` | undefined | null): {
+    name: string;
+    args?: readonly unknown[];
+} | null;
+declare function convertToHexString(value: unknown): string;
+declare function formatContractDryRunFailure(gasEstimate: {
+    revertData?: string;
+    revertFlags?: bigint;
+    gasConsumed?: {
+        referenceTime: bigint;
+        proofSize: bigint;
+    };
+    gasRequired?: {
+        referenceTime: bigint;
+        proofSize: bigint;
+    };
+    storageDeposit?: bigint;
+}, context: {
+    contractAddress: string;
+    functionName?: string;
+    signerSubstrateAddress: string;
+    signerEvmAddress?: string;
+    value: bigint;
+    encodedData: string;
+    args?: unknown[];
+    contracts?: Record<string, string>;
+}): string;
+declare function __formatContractDryRunFailureForTest(gasEstimate: Parameters<typeof formatContractDryRunFailure>[0], context: Parameters<typeof formatContractDryRunFailure>[1]): string;
+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, opts?: {
+    checkReserved?: boolean;
+}): string;
+declare function isCommitmentMature(chainNowSeconds: number, commitTimestampSeconds: number, minimumAgeSeconds: number): boolean;
+declare function isCommitmentTimingBarerevert(msg: string): boolean;
+declare function classifyDotnsLabel(label: string): {
+    status: number;
+    message: string;
+};
+declare function canRegister(requiredStatus: number, userStatus: number, trailingDigits: number): boolean;
+declare function parseDomainName(input: string): ParsedDomainName;
+declare function parseProofOfPersonhoodStatus(status: string): number;
+declare function popStatusName(status: number): string;
+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, opts?: {
+        nonceFallback?: {
+            rpcs: string[];
+            senderSS58: string;
+            expectedNonce: number;
+        };
+        verifyEffect?: () => Promise<boolean>;
+    }): Promise<TxResolution>;
+    signAndSubmitWithRetry(buildExtrinsic: () => any, signer: PolkadotSigner, statusCallback: (status: string) => void, label: string, opts?: {
+        nonceFallback?: {
+            rpcs: string[];
+            senderSS58: string;
+            expectedNonce: number;
+        };
+        verifyEffect?: () => Promise<boolean>;
+    }): Promise<TxResolution>;
+    private dryRunReviveCall;
+    submitTransaction(contractAddress: string, value: bigint, encodedData: string, signerSubstrateAddress: string, signer: PolkadotSigner, statusCallback: (status: string) => void, { rpcs, useNoncePolling, functionName, args, contracts, verifyEffect }: {
+        rpcs: string[];
+        useNoncePolling?: boolean;
+        functionName?: string;
+        args?: unknown[];
+        contracts?: Record<string, string>;
+        verifyEffect?: () => Promise<boolean>;
+    }): Promise<TxResolution>;
+    submitBatchedTransactions(calls: {
+        contractAddress: string;
+        value: bigint;
+        encodedData: string;
+        functionName?: string;
+        args?: unknown[];
+    }[], signerSubstrateAddress: string, signer: PolkadotSigner, statusCallback: (status: string) => void): Promise<TxResolution>;
+}
+type AliasAccountState = "not-bound" | "bound-likely-stale" | "wrong-context" | "bound-fresh";
+interface AliasAccountClassification {
+    state: AliasAccountState;
+    storedContextHex?: string;
+    paid?: boolean;
+    revision?: number;
+}
+/**
+ * Format a user-facing remediation message for the "no personhood" preflight failure.
+ * Pure function — unit-testable without a chain connection.
+ *
+ * When popSelfServe.stateAwareGuidance is true, returns actionable advice based on alias state.
+ * Otherwise falls back to the generic "contact DotNS team" message.
+ *
+ * The environmentId parameter is forwarded for use in shell command examples (e.g.
+ * `--env paseo-next-v2`) so users can copy-paste the correct env id. It does NOT gate
+ * the state-aware branch — that is controlled by popSelfServe.stateAwareGuidance.
+ */
+declare function formatPersonhoodRemediation(state: AliasAccountClassification, popSelfServe: PopSelfServeConfig | null, environmentId: string | null): string;
+/**
+ * Build a complete user-facing PoP shortfall reason string.
+ * Pure function — unit-testable without a chain connection.
+ *
+ * Composes:
+ *   1. Lead-in from the caller (`${label}.dot requires X, but signer is Y.`)
+ *   2. State-tailored guidance (when isTestnet && popSelfServe.stateAwareGuidance === true)
+ *      — delegates to formatPersonhoodRemediation for state-specific text.
+ *      — When aliasState is null on a stateAwareGuidance env, treated as "not-bound".
+ *   3. When isTestnet && popSelfServe != null but stateAwareGuidance is false/absent:
+ *      the generic 3-step self-serve bootstrap block using the env's config URLs/label.
+ *   4. When isTestnet && popSelfServe == null: no testnet block (env opted out).
+ *   5. Always: the "Alternatives" block (NoStatus-compatible label + whitelist link).
+ */
+declare function formatPopShortfallReason(opts: {
+    label: string;
+    requiredName: string;
+    currentName: string;
+    isTestnet: boolean;
+    environmentId: string | null;
+    popSelfServe: PopSelfServeConfig | null;
+    aliasState: AliasAccountClassification | null;
+    exampleNoStatusLabel: string;
+}): string;
+declare class DotNS {
+    client: any | null;
+    clientWrapper: ReviveClientWrapper | null;
+    rpc: string | null;
+    substrateAddress: string | null;
+    evmAddress: string | null;
+    signer: PolkadotSigner | null;
+    connected: boolean;
+    assetHubEndpoints: string[];
+    private _usesExternalSigner;
+    private _localMnemonic;
+    private _contracts;
+    private _nativeToEthRatio;
+    private _environmentId;
+    private _popSelfServe;
+    private _registerStorageDeposit;
+    private _classifyOverrideForTest;
+    /** Test-only: inject a fixed classifyAliasAccountState return value for the next call. Consumed once. */
+    __setClassifyOverrideForTest(state: AliasAccountState): void;
+    private _userPopStatusOverrideForTest;
+    /** Test-only: inject a fixed getUserPopStatus return value for the next call. Consumed once. */
+    __setUserPopStatusForTest(status: number): void;
+    private _reproveFallbackForTest;
+    /** Test-only: register a fallback reprove result used only if the real reprove() throws "not strictly greater than stored". Consumed once. */
+    __setReproveFallbackForTest(result: {
+        oldRevision: number;
+        newRevision: number;
+        blockHash: string;
+    }): void;
+    constructor();
+    connect(options?: DotNSConnectOptions): Promise<this>;
+    ensureMappedAccountReady(autoAccountMapping?: boolean): Promise<void>;
+    ensureAutoMappedAccountReady(): Promise<void>;
+    ensureConnected(): void;
+    private _testnetCache;
+    isTestnet(): Promise<boolean>;
+    /**
+     * Classify the AliasAccounts state for a substrate address.
+     * Only called on paseo-next-v2 testnets inside the preflight's NoStatus branch.
+     * Returns "not-bound" if the chain is unreachable (safe fallback to generic advice).
+     */
+    private classifyAliasAccountState;
+    readFreeBalance(ss58: string): Promise<bigint>;
+    attemptTestnetTopUp(recipientSs58: string, targetAmount: bigint): Promise<{
+        source: "Alice" | "Bob";
+        transferred: bigint;
+    } | null>;
+    private submitTransfer;
+    contractCall(contractAddress: string, contractAbi: readonly any[], functionName: string, args?: any[]): Promise<any>;
+    /**
+     * Like contractCall, but returns null when the chain replies with empty data
+     * ("0x"). Use this for view functions where an unset storage slot is a
+     * meaningful answer (e.g. resolver(node) for a name with no resolver,
+     * text records, optional ownership lookups). Use the strict contractCall
+     * for read paths that must always return a value.
+     */
+    contractCallNullable(contractAddress: string, contractAbi: readonly any[], functionName: string, args?: any[]): Promise<any | null>;
+    contractTransaction(contractAddress: string, value: bigint, contractAbi: readonly any[], functionName: string, args?: any[], statusCallback?: (status: string) => void, { useNoncePolling, verifyEffect }?: {
+        useNoncePolling?: boolean;
+        verifyEffect?: () => Promise<boolean>;
+    }): Promise<TxResolution>;
+    checkOwnership(label: string, ownerAddress?: string | null): Promise<OwnershipResult>;
+    getUserPopStatus(ownerAddress?: string | null): Promise<number>;
+    checkSubdomainOwnership(sublabel: string, parentLabel: string): Promise<OwnershipResult>;
+    registerSubdomain(sublabel: string, parentLabel: string): Promise<{
+        sublabel: string;
+        parentLabel: string;
+        owner: string;
+    }>;
+    /**
+     * Submit multiple contract calls as a single atomic `Utility.batch_all`
+     * extrinsic.
+     *
+     * Each call is encoded as a `pallet-revive::call(...)` extrinsic and
+     * batched into one outer dispatch. The runtime executes them in
+     * sequence and rolls back the entire batch on any inner revert. Only
+     * the leading call is dry-run for gas — its weight is reused as the
+     * budget for every subsequent call, on the assumption sibling
+     * registry/resolver writes are similarly sized.
+     */
+    private submitBatchedContractCalls;
+    setContenthash(domainName: string, contenthashHex: string): Promise<{
+        node: string;
+    }>;
+    /**
+     * Point a node's registered resolver at `DOTNS_CONTENT_RESOLVER` (RFC §Step 3.2).
+     *
+     * Hosts read text records via `IDotnsRegistry.resolver(node)`, so the
+     * registered slot must point at the content resolver for manifest text
+     * records to be discoverable. The pre-read is best-effort: pallet-revive
+     * returns `isOk=true` with empty data when a selector isn't in the
+     * deployed bytecode, which makes viem's decoder throw. Any decode failure
+     * is treated as "unset" and the write fires unconditionally. `setResolver`
+     * is idempotent against the same target, so registries that pre-date the
+     * `resolver(bytes32)` getter just pay one extra extrinsic per publish.
+     */
+    ensureContentResolver(domainName: string): Promise<{
+        changed: boolean;
+    }>;
+    /** Read a text record off `DOTNS_CONTENT_RESOLVER`. Returns `""` when unset. */
+    getTextRecord(domainName: string, key: string): Promise<string>;
+    setTextRecord(domainName: string, key: string, value: string): Promise<{
+        value: string;
+        txHash: string;
+    }>;
+    setTextRecords(domainName: string, entries: {
+        key: string;
+        value: string;
+    }[]): Promise<{
+        txHash: string | null;
+        batched: boolean;
+    }>;
+    publishLabel(label: string): Promise<{
+        status: "published" | "already-published" | "cooldown-skipped";
+        txHash?: string;
+    }>;
+    unpublishLabel(label: string): Promise<{
+        status: "unpublished" | "already-unpublished";
+        txHash?: string;
+    }>;
+    getContenthash(domainName: string): Promise<string>;
+    classifyName(label: string): Promise<{
+        requiredStatus: number;
+        message: string;
+    }>;
+    ensureNotRegistered(label: string): Promise<void>;
+    generateCommitment(label: string, includeReverse?: boolean): Promise<{
+        commitment: any;
+        registration: any;
+    }>;
+    submitCommitment(commitment: any): Promise<void>;
+    waitForCommitmentAge(commitment: any): Promise<void>;
+    getPriceAndValidate(label: string): Promise<PriceValidationResult>;
+    finalizeRegistration(registration: any, priceWei: bigint): Promise<void>;
+    verifyOwnership(label: string): Promise<void>;
+    preflight(label: string): Promise<DotnsPreflightResult>;
+    private _preflightInternal;
+    private gateOnFeeBalance;
+    register(label: string, options?: DotNSConnectOptions & {
+        status?: string;
+        reverse?: boolean;
+    }): Promise<{
+        label: string;
+        owner: string;
+    }>;
+    /**
+     * Reprove a stale DotNS alias binding.
+     * Opens a People-chain client internally, builds the ring proof, and submits
+     * reprove_alias_account on AH. Use when the alias exists but the ring root
+     * has advanced past the stored revision.
+     *
+     * Requires a mnemonic — the DotNS instance must have been connected with one.
+     */
+    reprove(mnemonic: string): Promise<{
+        oldRevision: number;
+        newRevision: number;
+        blockHash: string;
+    }>;
+    /**
+     * Run the personhood bootstrap flow for this DotNS signer.
+     * Idempotent: each step is gated on chain state being "still needs doing".
+     * Does NOT auto-run from preflight — call explicitly.
+     *
+     * Throws RecognizeRequiredError if the account hasn't been recognized by the
+     * personhood faucet (https://sudo.personhood.dev/personhood-faucet).
+     */
+    bootstrap(mnemonic: string): Promise<BootstrapResult>;
+    disconnect(): void;
+}
+declare const dotns: DotNS;
+
+export { ATTR_TX_RESOLUTION_KIND, type AliasAccountClassification, type AliasAccountState, CONNECTION_TIMEOUT_MS, CONTRACTS, ContractDryRunRevertError, DECIMALS, DEFAULT_MNEMONIC, DOTNS_TX_MAX_ATTEMPTS, DOT_NODE, DotNS, type DotNSConnectOptions, type DotnsPreflightResult, type DotnsSuccessAction, MINIMUM_REGISTER_STORAGE_DEPOSIT, NATIVE_TO_ETH_RATIO, OPERATION_TIMEOUT_MS, type OwnershipResult, PUBLISHER_ABI, type ParsedDomainName, type PriceValidationResult, ProofOfPersonhoodStatus, PublisherNotSupportedError, RPC_ENDPOINTS, TX_CHAIN_TIME_BUDGET_MS, TX_KIND_HASH, TX_KIND_NONCE_ADVANCED, TX_TIMEOUT_MS, TX_WALL_CLOCK_CEILING_MS, type TxResolution, WS_HEARTBEAT_TIMEOUT_MS, __formatContractDryRunFailureForTest, canRegister, classifyDotnsLabel, classifyTxRetryDecision, computeDomainTokenId, convertToHexString, convertWeiToNative, countTrailingDigits, decodePublisherRevert, dotns, feeFloorFor, fetchNonce, fmtPas, formatPersonhoodRemediation, formatPopShortfallReason, isCommitmentMature, isCommitmentTimingBarerevert, parseDomainName, parseProofOfPersonhoodStatus, popStatusName, sanitizeDomainLabel, stripTrailingDigits, validateDomainLabel, verifyNonceAdvanced };

package/dist/dotns.js

@@ -0,0 +1,101 @@
+import {
+  ATTR_TX_RESOLUTION_KIND,
+  CONNECTION_TIMEOUT_MS,
+  CONTRACTS,
+  ContractDryRunRevertError,
+  DECIMALS,
+  DEFAULT_MNEMONIC,
+  DOTNS_TX_MAX_ATTEMPTS,
+  DOT_NODE,
+  DotNS,
+  MINIMUM_REGISTER_STORAGE_DEPOSIT,
+  NATIVE_TO_ETH_RATIO,
+  OPERATION_TIMEOUT_MS,
+  PUBLISHER_ABI,
+  ProofOfPersonhoodStatus,
+  PublisherNotSupportedError,
+  RPC_ENDPOINTS,
+  TX_CHAIN_TIME_BUDGET_MS,
+  TX_KIND_HASH,
+  TX_KIND_NONCE_ADVANCED,
+  TX_TIMEOUT_MS,
+  TX_WALL_CLOCK_CEILING_MS,
+  WS_HEARTBEAT_TIMEOUT_MS,
+  __formatContractDryRunFailureForTest,
+  canRegister,
+  classifyDotnsLabel,
+  classifyTxRetryDecision,
+  computeDomainTokenId,
+  convertToHexString,
+  convertWeiToNative,
+  countTrailingDigits,
+  decodePublisherRevert,
+  dotns,
+  feeFloorFor,
+  fetchNonce,
+  fmtPas,
+  formatPersonhoodRemediation,
+  formatPopShortfallReason,
+  isCommitmentMature,
+  isCommitmentTimingBarerevert,
+  parseDomainName,
+  parseProofOfPersonhoodStatus,
+  popStatusName,
+  sanitizeDomainLabel,
+  stripTrailingDigits,
+  validateDomainLabel,
+  verifyNonceAdvanced
+} from "./chunk-DNXH4QTI.js";
+import "./chunk-QMYW3D6E.js";
+import "./chunk-MFTODIIT.js";
+import "./chunk-KJH2T5TQ.js";
+import "./chunk-OITUIM2E.js";
+import "./chunk-ZOC4GITL.js";
+export {
+  ATTR_TX_RESOLUTION_KIND,
+  CONNECTION_TIMEOUT_MS,
+  CONTRACTS,
+  ContractDryRunRevertError,
+  DECIMALS,
+  DEFAULT_MNEMONIC,
+  DOTNS_TX_MAX_ATTEMPTS,
+  DOT_NODE,
+  DotNS,
+  MINIMUM_REGISTER_STORAGE_DEPOSIT,
+  NATIVE_TO_ETH_RATIO,
+  OPERATION_TIMEOUT_MS,
+  PUBLISHER_ABI,
+  ProofOfPersonhoodStatus,
+  PublisherNotSupportedError,
+  RPC_ENDPOINTS,
+  TX_CHAIN_TIME_BUDGET_MS,
+  TX_KIND_HASH,
+  TX_KIND_NONCE_ADVANCED,
+  TX_TIMEOUT_MS,
+  TX_WALL_CLOCK_CEILING_MS,
+  WS_HEARTBEAT_TIMEOUT_MS,
+  __formatContractDryRunFailureForTest,
+  canRegister,
+  classifyDotnsLabel,
+  classifyTxRetryDecision,
+  computeDomainTokenId,
+  convertToHexString,
+  convertWeiToNative,
+  countTrailingDigits,
+  decodePublisherRevert,
+  dotns,
+  feeFloorFor,
+  fetchNonce,
+  fmtPas,
+  formatPersonhoodRemediation,
+  formatPopShortfallReason,
+  isCommitmentMature,
+  isCommitmentTimingBarerevert,
+  parseDomainName,
+  parseProofOfPersonhoodStatus,
+  popStatusName,
+  sanitizeDomainLabel,
+  stripTrailingDigits,
+  validateDomainLabel,
+  verifyNonceAdvanced
+};