bulletin-deploy 0.7.21 → 0.7.22-rc.0

package/dist/bug-report.js

@@ -9,10 +9,10 @@ import {
   offerBugReport,
   scrubSecrets,
   setDeployContext
-} from "./chunk-SA37SLYF.js";
-import "./chunk-RJAFD4LO.js";
-import "./chunk-2VNGK2MU.js";
-import "./chunk-G2P5UIPX.js";
+} from "./chunk-TA3NCL6U.js";
+import "./chunk-SL7LV4DS.js";
+import "./chunk-3LGLMHQI.js";
+import "./chunk-LZO2QX4T.js";
 export {
   buildCliFlagsSummary,
   buildLabels,

package/dist/{chunk-2VNGK2MU.js → chunk-3LGLMHQI.js}

@@ -1,7 +1,7 @@
 import {
   package_default,
   writeRunState
-} from "./chunk-G2P5UIPX.js";
+} from "./chunk-LZO2QX4T.js";
 
 // src/memory-report.ts
 import * as fs2 from "fs";
@@ -246,13 +246,26 @@ function computeDeployOutcome(errorCategory, isSad, sadReason) {
   if (isSad) return `sad_${sadReason}`;
   return "clean";
 }
+function classifyErrorKind(msg) {
+  if (/Contract reverted|Contract execution would revert|revert(?:ed|ing)?\s*\(flags=[0-9]+\)/i.test(msg)) return "contract-revert";
+  if (/timed out after \d+s waiting for block|Transaction not included after \d+s|Transaction did not settle within/i.test(msg)) return "chain-timeout";
+  if (/\bstale\b.*nonce|nonce.*\bstale\b|"type"\s*:\s*"Future"|Invalid::Future|tx rejected by pool/i.test(msg)) return "nonce-stale";
+  if (/heartbeat timeout|WS halt|Unable to connect|ChainHead disjointed|websocket.*closed|socket closed|disconnect/i.test(msg)) return "connection";
+  return "unknown";
+}
+function sanitizeErrorMessage(msg) {
+  return scrubPaths(msg.slice(0, 500));
+}
 async function withSpan(op, description, attributes, fn) {
   if (!Sentry) return fn();
   return Sentry.startSpan({ op, name: description, attributes }, async (span) => {
     try {
       return await fn();
     } catch (error) {
-      span.setAttribute("error.message", error.message);
+      const msg = error.message ?? String(error);
+      span.setAttribute("error.message", msg);
+      span.setAttribute("deploy.error_kind", classifyErrorKind(msg));
+      span.setAttribute("deploy.error_message", sanitizeErrorMessage(msg));
       span.setStatus({ code: 2, message: "internal_error" });
       throw error;
     }
@@ -345,11 +358,13 @@ async function withDeploySpan(domain, fn) {
         span.setAttribute("deploy.status", "ok");
         return result;
       } catch (error) {
-        const msg = error.message;
+        const msg = error.message ?? String(error);
         span.setAttribute("deploy.status", "error");
         span.setAttribute("deploy.error", msg.slice(0, 500));
         const errorCategory = classifyDeployError(msg);
         span.setAttribute("deploy.error_category", errorCategory);
+        span.setAttribute("deploy.error_kind", classifyErrorKind(msg));
+        span.setAttribute("deploy.error_message", sanitizeErrorMessage(msg));
         currentErrorCategory = errorCategory;
         const isExpected = isExpectedError(msg);
         span.setAttribute("deploy.expected", isExpected ? "true" : "false");
@@ -429,6 +444,11 @@ function setDeployAttribute(key, value) {
 function __setDeployRootSpanForTest(span) {
   deployRootSpan = span;
 }
+function __setSentryForTest(stub) {
+  const prev = Sentry;
+  Sentry = stub;
+  return prev;
+}
 function getCurrentSentryTraceId() {
   if (!Sentry) return void 0;
   const span = Sentry.getActiveSpan();
@@ -603,12 +623,15 @@ export {
   classifyDeployError,
   classifySadReason,
   computeDeployOutcome,
+  classifyErrorKind,
+  sanitizeErrorMessage,
   withSpan,
   sampleMemory,
   withDeploySpan,
   setDeployReportContext,
   setDeployAttribute,
   __setDeployRootSpanForTest,
+  __setSentryForTest,
   getCurrentSentryTraceId,
   setDeploySentryTag,
   captureWarning,

package/dist/{chunk-VTTN4BX7.js → chunk-4YO5SOAY.js}

@@ -1,11 +1,11 @@
 import {
   isTestnetSpecName
-} from "./chunk-4TS6R26J.js";
+} from "./chunk-WVCIU6WM.js";
 import {
   captureWarning,
   setDeployAttribute,
   withSpan
-} from "./chunk-2VNGK2MU.js";
+} from "./chunk-3LGLMHQI.js";
 
 // src/dotns.ts
 import crypto from "crypto";
@@ -236,6 +236,7 @@ function formatWeight(weight) {
   if (!weight) return "unknown";
   return `ref_time=${weight.referenceTime.toString()} proof_size=${weight.proofSize.toString()}`;
 }
+var BARE_REVERT_DIAGNOSTIC_FUNCTIONS = /* @__PURE__ */ new Set(["register", "commit", "setContenthash", "setSubnodeOwner", "setResolver"]);
 function formatContractDryRunFailure(gasEstimate, context) {
   const functionName = context.functionName ?? "unknown";
   const contractName = dotnsContractName(context.contractAddress, context.contracts);
@@ -253,8 +254,23 @@ function formatContractDryRunFailure(gasEstimate, context) {
     lines.push(`  calldata: ${context.encodedData}`);
     if (context.args) lines.push(`  args: ${stringifyDebugValue(context.args)}`);
   }
+  const revertData = gasEstimate.revertData;
+  const isBareRevert = (revertData === void 0 || revertData.trim() === "0x") && gasEstimate.revertFlags === 1n;
+  if (isBareRevert && BARE_REVERT_DIAGNOSTIC_FUNCTIONS.has(functionName)) {
+    lines.push(
+      `  diagnostic: bare-revert (empty 0x). Most common causes:`,
+      `    1. Origin not actually mapped on-chain. Try BULLETIN_DEPLOY_DEBUG_DOTNS_TX=1 to log calldata, then run`,
+      `       \`node tools/dotns-dry-run.mjs <label>\` against the env's Asset Hub RPC to reproduce in isolation.`,
+      `    2. Contract precondition (e.g. commitment too new). dotns-dry-run.mjs will surface the contract-side state.`,
+      `  hint: prepend --fresh to dotns-dry-run.mjs to use a brand-new unmapped substrate origin \u2014`,
+      `        if the revert ONLY reproduces with --fresh, it's the account-mapping bug.`
+    );
+  }
   return lines.join("\n");
 }
+function __formatContractDryRunFailureForTest(gasEstimate, context) {
+  return formatContractDryRunFailure(gasEstimate, context);
+}
 function unwrapExecutionResult(rawResult) {
   if (!rawResult) return { ok: null, err: null, successFlag: null };
   if (typeof rawResult.success === "boolean") {
@@ -579,6 +595,17 @@ var ReviveClientWrapper = class _ReviveClientWrapper {
   async submitTransaction(contractAddress, value, encodedData, signerSubstrateAddress, signer, statusCallback, { rpcs, useNoncePolling, functionName, args, contracts }) {
     await this.ensureAccountMapped(signerSubstrateAddress, signer);
     const signerEvmAddress = await this.getEvmAddress(signerSubstrateAddress);
+    if (functionName === "register") {
+      try {
+        const stillMapped = await this.checkIfAccountMapped(signerSubstrateAddress);
+        if (!stillMapped) {
+          captureWarning("account mapping not confirmed on-chain immediately before register dry-run", {
+            signer: signerSubstrateAddress
+          });
+        }
+      } catch {
+      }
+    }
     const gasEstimate = await this.estimateGasForCall(signerSubstrateAddress, contractAddress, value, encodedData);
     if (!gasEstimate.success) {
       throw new Error(formatContractDryRunFailure(gasEstimate, {
@@ -608,6 +635,22 @@ var ReviveClientWrapper = class _ReviveClientWrapper {
     return await this.signAndSubmitWithRetry(buildExtrinsic, signer, statusCallback, "Revive.call", { nonceFallback });
   }
 };
+var DOTNS_CONTEXT_HEX_LOWER = "0x646f746e73000000000000000000000000000000000000000000000000000000";
+function formatPersonhoodRemediation(state, environmentId) {
+  if (environmentId !== "paseo-next-v2") {
+    return "Self-attestation is no longer available. Contact the DotNS team for whitelisting / Personhood status help.";
+  }
+  switch (state.state) {
+    case "not-bound":
+      return "Your account has no DotNS alias binding on paseo-next-v2. Visit https://sudo.personhood.dev/dotns-bootstrap to complete the recognition and binding steps, or run `tools/personhood-bootstrap.mjs --mnemonic <your-mnemonic>` once Stage 2 of the bootstrap tooling lands.";
+    case "bound-likely-stale":
+      return "Your alias binding exists but may have a stale ring revision. Run `node tools/reprove-alias.mjs --mnemonic <your-mnemonic> --env paseo-next-v2` to refresh the proof, then retry the registration.";
+    case "wrong-context":
+      return "Your alias binding exists but is for a different application context" + (state.storedContextHex ? ` (context: ${state.storedContextHex})` : "") + ". Re-bind under the 'dotns' context using the bootstrap flow: https://sudo.personhood.dev/dotns-bootstrap";
+    case "bound-fresh":
+      return "Self-attestation is no longer available. Contact the DotNS team for whitelisting / Personhood status help.";
+  }
+}
 var DotNS = class {
   client;
   clientWrapper;
@@ -623,6 +666,7 @@ var DotNS = class {
   _usesExternalSigner = false;
   _contracts = CONTRACTS;
   _nativeToEthRatio = NATIVE_TO_ETH_RATIO;
+  _environmentId = null;
   constructor() {
     this.client = null;
     this.clientWrapper = null;
@@ -640,6 +684,9 @@ var DotNS = class {
     if (options.contracts && Object.keys(options.contracts).length > 0) {
       this._contracts = { ...CONTRACTS, ...options.contracts };
     }
+    if (options.environmentId) {
+      this._environmentId = options.environmentId;
+    }
     const rpc = options.rpc || process.env.DOTNS_RPC || this.assetHubEndpoints[0];
     this.rpc = rpc;
     this._usesExternalSigner = Boolean(options.signer && options.signerAddress);
@@ -788,6 +835,31 @@ var DotNS = class {
     this._testnetCache = isTestnetSpecName(rpc) || rpc.includes("paseo") || rpc.includes("westend") || rpc.includes("rococo");
     return this._testnetCache;
   }
+  /**
+   * 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).
+   */
+  async classifyAliasAccountState(ss58) {
+    if (!this.clientWrapper) return { state: "not-bound" };
+    try {
+      const api = this.clientWrapper.client;
+      const row = await api.query.AliasAccounts.AccountToAlias.getValue(ss58, { at: "best" });
+      if (!row) return { state: "not-bound" };
+      const contextHex = typeof row.ca?.context === "string" ? row.ca.context.toLowerCase() : "";
+      const paid = Boolean(row.paid);
+      const revision = Number(row.revision ?? 0);
+      if (paid && contextHex === DOTNS_CONTEXT_HEX_LOWER) {
+        return { state: "bound-likely-stale", storedContextHex: contextHex, paid, revision };
+      }
+      if (!paid || contextHex !== DOTNS_CONTEXT_HEX_LOWER) {
+        return { state: "wrong-context", storedContextHex: contextHex, paid, revision };
+      }
+      return { state: "bound-fresh", storedContextHex: contextHex, paid, revision };
+    } catch {
+      return { state: "not-bound" };
+    }
+  }
   // Free PAS balance for a substrate address on the connected DotNS chain.
   // Used by preflight to gate the deploy on whether the signer can pay tx
   // fees before the chunk upload runs. Returns 0n if the account doesn't
@@ -1342,6 +1414,30 @@ var DotNS = class {
             signerFreeBalance
           };
         }
+        if (userStatus === ProofOfPersonhoodStatus.NoStatus && isTestnet && this._environmentId === "paseo-next-v2" && this.substrateAddress) {
+          const aliasState = await this.classifyAliasAccountState(this.substrateAddress);
+          const remediationMessage = formatPersonhoodRemediation(aliasState, this._environmentId);
+          const currentName2 = popStatusName(userStatus);
+          const requiredName2 = popStatusName(classification.status);
+          return {
+            label: validated,
+            classification,
+            userStatus,
+            trailingDigits,
+            baselength,
+            isAvailable: true,
+            existingOwner: null,
+            isBaseNameReserved: isReserved,
+            reservationOwner,
+            isTestnet,
+            canProceed: false,
+            reason: `${validated}.dot requires ${requiredName2}, but this signer is ${currentName2}. ${remediationMessage}`,
+            plannedAction: "abort",
+            needsPopUpgrade: false,
+            targetPopStatus,
+            signerFreeBalance
+          };
+        }
         const currentName = popStatusName(userStatus);
         const requiredName = popStatusName(classification.status);
         return {
@@ -1471,6 +1567,57 @@ var DotNS = class {
       return { label, owner: this.evmAddress };
     });
   }
+  /**
+   * 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.
+   */
+  async reprove(mnemonic) {
+    this.ensureConnected();
+    if (!this.substrateAddress || !this.signer) {
+      throw new Error("reprove: DotNS must be connected with a signer");
+    }
+    const envId = this._environmentId ?? "paseo-next-v2";
+    const { connectPeopleClient } = await import("./personhood/people-client.js");
+    const { reproveAliasToAccount } = await import("./personhood/reprove.js");
+    const { deriveMemberEntropy, deriveMemberKey } = await import("./personhood/member-key.js");
+    const verifiable = await import("verifiablejs/nodejs");
+    const memberEntropy = deriveMemberEntropy(mnemonic);
+    const memberKey = deriveMemberKey(mnemonic);
+    const peopleConn = await connectPeopleClient(envId);
+    try {
+      const result = await reproveAliasToAccount({
+        peopleUnsafeApi: peopleConn.unsafeApi,
+        ahUnsafeApi: this.clientWrapper.client,
+        account: this.substrateAddress,
+        memberKey,
+        signCall: this.signer,
+        buildRingProof: async ({ members, context, msg }) => {
+          const r = verifiable.one_shot(memberEntropy, members, context, msg);
+          return { proof: r.proof, alias: r.alias };
+        }
+      });
+      return result;
+    } finally {
+      peopleConn.disconnect();
+    }
+  }
+  /**
+   * 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).
+   */
+  async bootstrap(mnemonic) {
+    const { runBootstrap } = await import("./personhood/bootstrap.js");
+    const envId = this._environmentId ?? "paseo-next-v2";
+    return runBootstrap({ mnemonic, environmentId: envId });
+  }
   disconnect() {
     if (this.client) {
       this.client.destroy();
@@ -1503,6 +1650,7 @@ export {
   verifyNonceAdvanced,
   ProofOfPersonhoodStatus,
   convertToHexString,
+  __formatContractDryRunFailureForTest,
   DOT_NODE,
   convertWeiToNative,
   computeDomainTokenId,
@@ -1517,6 +1665,7 @@ export {
   parseDomainName,
   parseProofOfPersonhoodStatus,
   popStatusName,
+  formatPersonhoodRemediation,
   DotNS,
   dotns
 };

package/dist/chunk-74ETPOKH.js

@@ -0,0 +1,284 @@
+import {
+  buildImplicationMessage,
+  buildV5GeneralExtrinsic,
+  bytesToHex,
+  encodeMembers,
+  hexToBytes,
+  readExtensionOrder,
+  toHex
+} from "./chunk-ZYVGHDMU.js";
+import {
+  PEOPLE_MEMBER_IDENTIFIER_HEX,
+  PGAS_ASSET_ID,
+  PROOF_BYTES
+} from "./chunk-T7EEVWNU.js";
+
+// src/personhood/claim-pgas.ts
+import { Enum } from "polkadot-api";
+var PgasClaimError = class extends Error {
+  kind;
+  dispatchError;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "PgasClaimError";
+    this.kind = options.kind ?? "Unknown";
+    this.dispatchError = options.dispatchError;
+  }
+};
+var SECS_PER_DAY = 86400n;
+var IMPLICATION_EXCLUDE = /* @__PURE__ */ new Set([
+  "AuthorizeCall",
+  "AsPgas",
+  "StorageWeightReclaim"
+]);
+var PGAS_CONTEXT_PREFIX = new TextEncoder().encode("pop:gas:");
+function buildGasContext(day, slotIndex) {
+  const out = new Uint8Array(32);
+  out.set(PGAS_CONTEXT_PREFIX, 0);
+  const dv = new DataView(out.buffer);
+  dv.setUint32(8, day, true);
+  dv.setUint32(12, slotIndex, true);
+  return out;
+}
+function buildAsPgasClaimExtensionValue(proof, ringIndex, revision, day) {
+  return Enum("Claim", {
+    proof: bytesToHex(proof),
+    ring_index: ringIndex,
+    revision,
+    collection: Enum("People"),
+    day
+  });
+}
+var claimPgas = async ({
+  peopleUnsafeApi,
+  ahUnsafeApi,
+  ahClient,
+  target,
+  memberKey,
+  buildRingProof,
+  slotIndex = 0,
+  progress
+}) => {
+  const people = peopleUnsafeApi;
+  const ah = ahUnsafeApi;
+  if (memberKey.length !== 32) {
+    throw new PgasClaimError("memberKey must be 32 bytes", { kind: "ClientError" });
+  }
+  const asset = await ah.query.Assets.Asset.getValue(PGAS_ASSET_ID, { at: "best" });
+  if (!asset) {
+    throw new PgasClaimError(
+      "PGAS asset (id 2_000_000_000) does not exist on AH",
+      { kind: "PgasAssetNotCreated" }
+    );
+  }
+  const position = await people.query.Members.Members.getValue(
+    PEOPLE_MEMBER_IDENTIFIER_HEX,
+    bytesToHex(memberKey),
+    { at: "best" }
+  );
+  if (!position) {
+    throw new PgasClaimError(
+      "member key not present on People \u2014 recognize first",
+      { kind: "NotARecognizedPerson" }
+    );
+  }
+  if (position.type !== "Included") {
+    throw new PgasClaimError(
+      `member position is '${position.type}', expected 'Included'`,
+      { kind: "NotARecognizedPerson" }
+    );
+  }
+  const ringIndex = position.value.ring_index;
+  const allEntries = await people.query.Members.RingKeys.getEntries({ at: "best" });
+  const pages = [];
+  const identHex = PEOPLE_MEMBER_IDENTIFIER_HEX.toLowerCase();
+  for (const entry of allEntries) {
+    if (entry.keyArgs[0].toLowerCase() !== identHex) continue;
+    if (Number(entry.keyArgs[1]) !== ringIndex) continue;
+    pages.push([Number(entry.keyArgs[2]), [...entry.value]]);
+  }
+  pages.sort((a, b) => a[0] - b[0]);
+  const ringKeys = pages.flatMap(([, ks]) => ks);
+  if (ringKeys.length === 0) {
+    throw new PgasClaimError("ring has no members on People", {
+      kind: "ClientError"
+    });
+  }
+  const membersBytes = encodeMembers(ringKeys.map((k) => hexToBytes(k)));
+  const collectionId = await ah.constants.AliasAccounts.PeopleCollectionIdentifier();
+  const ringExp = await ah.constants.AliasAccounts.PeopleRingExponent();
+  const ringExponent = ringExp.type === "R2e9" ? 9 : ringExp.type === "R2e10" ? 10 : 14;
+  const ringRoots = await ah.query.MembersSubscriber.RingRoots.getValue(
+    collectionId,
+    ringIndex,
+    { at: "best" }
+  );
+  if (!ringRoots || ringRoots.length === 0) {
+    throw new PgasClaimError(
+      "AH has no RingRoots for this (collection, ring_index)",
+      { kind: "RingRootNotFound" }
+    );
+  }
+  const latest = ringRoots[ringRoots.length - 1];
+  const revision = latest.revision;
+  const nowRaw = await ah.query.Timestamp.Now.getValue({ at: "best" });
+  const nowSec = nowRaw > 10000000000n ? nowRaw / 1000n : nowRaw;
+  const day = Number(nowSec / SECS_PER_DAY);
+  const contextBytes = buildGasContext(day, slotIndex);
+  const innerTx = ah.tx.Pgas.claim_pgas({ slot_index: slotIndex, target });
+  const callBytes = await innerTx.getEncodedData();
+  const passEmpty = await capturePass(innerTx, void 0);
+  const msg = buildImplicationMessage(
+    callBytes,
+    passEmpty.extensions,
+    IMPLICATION_EXCLUDE
+  );
+  const { proof, alias } = await buildRingProof({
+    ringExponent,
+    members: membersBytes,
+    context: contextBytes,
+    msg
+  });
+  if (proof.length !== PROOF_BYTES) {
+    throw new PgasClaimError(
+      `ring proof must be ${PROOF_BYTES} bytes, got ${proof.length}`,
+      { kind: "ClientError" }
+    );
+  }
+  const asPgasValue = Enum("Claim", {
+    proof: bytesToHex(proof),
+    ring_index: ringIndex,
+    revision,
+    collection: Enum("People"),
+    day
+  });
+  const passProof = await capturePass(innerTx, asPgasValue);
+  const extrinsicBytes = buildV5GeneralExtrinsic(callBytes, passProof.extensions);
+  const extrinsicHex = toHex(extrinsicBytes);
+  const blockHash = await submitExtrinsic(ahClient, extrinsicHex, progress);
+  const amount = await ah.constants.Pgas.PgasClaimAmount();
+  return { blockHash, amount, alias };
+};
+var capturePass = async (innerTx, asPgasValue) => {
+  let captured = null;
+  const sentinel = new Error("__pgas_capture_sentinel__");
+  const signer = {
+    publicKey: new Uint8Array(32),
+    signTx: async (callData, signedExtensions, metadata) => {
+      const order = await readExtensionOrder(metadata);
+      const byIdentifier = {};
+      for (const id of order) {
+        const ext = signedExtensions[id];
+        byIdentifier[id] = {
+          value: ext.value,
+          additionalSigned: ext.additionalSigned
+        };
+      }
+      captured = { callData, extensions: { order, byIdentifier } };
+      throw sentinel;
+    },
+    signBytes: async () => new Uint8Array(64)
+  };
+  try {
+    await innerTx.sign(signer, {
+      mortality: { mortal: false },
+      customSignedExtensions: {
+        AsPgas: {
+          value: asPgasValue,
+          additionalSigned: new Uint8Array()
+        }
+      }
+    });
+  } catch (err) {
+    if (err !== sentinel) throw err;
+  }
+  if (captured === null) {
+    throw new PgasClaimError("extension capture failed", { kind: "ClientError" });
+  }
+  return captured;
+};
+var narrowDispatchError = (dispatchError) => {
+  if (typeof dispatchError === "object" && dispatchError !== null && "type" in dispatchError) {
+    const d = dispatchError;
+    if (d.type === "Invalid" && typeof d.value === "object" && d.value !== null) {
+      const v = d.value;
+      if (v.type === "BadProof") return "BadProof";
+      if (v.type === "Custom") {
+        switch (v.value) {
+          case 230:
+            return "InvalidClaimSlot";
+          case 231:
+            return "InvalidClaimDay";
+          case 232:
+            return "AlreadyClaimedToday";
+          case 233:
+            return "PgasAssetNotCreated";
+        }
+      }
+    }
+  }
+  return "DispatchError";
+};
+var submitExtrinsic = (client, extrinsicHex, progress) => {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const fail = (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err);
+    };
+    const succeed = (h) => {
+      if (settled) return;
+      settled = true;
+      resolve(h);
+    };
+    client.submitAndWatch(hexToBytes(extrinsicHex)).subscribe({
+      next: (event) => {
+        if (settled) return;
+        if (event.type === "broadcasted") {
+          progress?.onBroadcasted?.();
+          return;
+        }
+        if (event.type === "txBestBlocksState" && event.found) {
+          if (event.ok === false) {
+            fail(
+              new PgasClaimError("claim_pgas dispatched but failed in-block", {
+                kind: narrowDispatchError(event.dispatchError),
+                dispatchError: event.dispatchError
+              })
+            );
+            return;
+          }
+          progress?.onBestBlock?.(event.block.hash);
+          return;
+        }
+        if (event.type === "finalized") {
+          if (event.ok === false) {
+            fail(
+              new PgasClaimError("claim_pgas failed at finalization", {
+                kind: narrowDispatchError(event.dispatchError),
+                dispatchError: event.dispatchError
+              })
+            );
+            return;
+          }
+          succeed(event.block.hash);
+        }
+      },
+      error: (err) => {
+        fail(
+          err instanceof PgasClaimError ? err : new PgasClaimError(
+            err instanceof Error ? `RPC rejected extrinsic: ${err.message}` : "RPC error during submitAndWatch",
+            { cause: err, kind: "RpcError" }
+          )
+        );
+      }
+    });
+  });
+};
+
+export {
+  PgasClaimError,
+  buildAsPgasClaimExtensionValue,
+  claimPgas
+};