bulletin-deploy 0.7.21 → 0.7.22-rc.1

package/dist/index.js

@@ -5,12 +5,12 @@ import {
   deploy,
   merkleizeJS,
   merkleizeWithStableOrder
-} from "./chunk-BFXHVC23.js";
+} from "./chunk-SPWQNU3F.js";
 import {
   computeStats,
   renderSummary,
   telemetryAttributes
-} from "./chunk-MJTQOXBC.js";
+} from "./chunk-LEYQOOWC.js";
 import {
   finaliseEmbeddedManifest,
   writeEmbeddedManifestPlaceholder
@@ -27,24 +27,24 @@ import {
   isVolatilePath,
   parseManifest
 } from "./chunk-S7EM5VMW.js";
-import "./chunk-SA37SLYF.js";
-import "./chunk-RJAFD4LO.js";
+import "./chunk-V5NUBOEX.js";
+import "./chunk-FSSKFXTZ.js";
 import {
   probeChunks
-} from "./chunk-ZY6QLNKQ.js";
+} from "./chunk-KFHGT4A2.js";
 import "./chunk-C2TS5MER.js";
 import {
   DotNS,
   parseDomainName
-} from "./chunk-VTTN4BX7.js";
+} from "./chunk-CIXT75OF.js";
 import {
   bootstrapPool,
   derivePoolAccounts,
   ensureAuthorized,
   fetchPoolAuthorizations,
   selectAccount
-} from "./chunk-4TS6R26J.js";
-import "./chunk-2VNGK2MU.js";
+} from "./chunk-WVCIU6WM.js";
+import "./chunk-WNUWAA6F.js";
 import {
   VERSION,
   loadRunState,
@@ -54,7 +54,7 @@ import {
   shouldSkipStaleWarning,
   stateFilePath,
   writeRunState
-} from "./chunk-G2P5UIPX.js";
+} from "./chunk-XWA3NPMX.js";
 import {
   DEFAULT_ENV_ID,
   defaultBundledPath,

package/dist/memory-report.js

@@ -5,8 +5,8 @@ import {
   maybeWriteMemoryReport,
   safeHeap,
   sampleFromBytes
-} from "./chunk-2VNGK2MU.js";
-import "./chunk-G2P5UIPX.js";
+} from "./chunk-WNUWAA6F.js";
+import "./chunk-XWA3NPMX.js";
 export {
   DEFAULT_THRESHOLD_MB,
   buildMemoryReport,

package/dist/merkle.js

@@ -6,19 +6,19 @@ import {
   merkleizeKuboBackend,
   merkleizeWithStableOrder,
   rebuildOrderedCarFromBytes
-} from "./chunk-BFXHVC23.js";
-import "./chunk-MJTQOXBC.js";
+} from "./chunk-SPWQNU3F.js";
+import "./chunk-LEYQOOWC.js";
 import "./chunk-KOSF5FDO.js";
 import "./chunk-5MRZ3V4A.js";
 import "./chunk-S7EM5VMW.js";
-import "./chunk-SA37SLYF.js";
-import "./chunk-RJAFD4LO.js";
-import "./chunk-ZY6QLNKQ.js";
+import "./chunk-V5NUBOEX.js";
+import "./chunk-FSSKFXTZ.js";
+import "./chunk-KFHGT4A2.js";
 import "./chunk-C2TS5MER.js";
-import "./chunk-VTTN4BX7.js";
-import "./chunk-4TS6R26J.js";
-import "./chunk-2VNGK2MU.js";
-import "./chunk-G2P5UIPX.js";
+import "./chunk-CIXT75OF.js";
+import "./chunk-WVCIU6WM.js";
+import "./chunk-WNUWAA6F.js";
+import "./chunk-XWA3NPMX.js";
 import "./chunk-F36C363Y.js";
 import "./chunk-ZOC4GITL.js";
 import "./chunk-HOTQDYHD.js";

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-QHOZEY5X.js";
+import "../chunk-ZYVGHDMU.js";
+import "../chunk-T7EEVWNU.js";
+export {
+  PaidAliasBindingError,
+  bindPaidAliasToAccount
+};

package/dist/personhood/bind-personal-id.d.ts

@@ -0,0 +1,55 @@
+import { PolkadotClient, SS58String } from 'polkadot-api';
+
+type BindingErrorKind = "dispatch_error" | "rpc_error" | "client_error" | "unknown";
+declare class PersonalIdBindingError extends Error {
+    readonly dispatchError?: unknown;
+    readonly kind: BindingErrorKind;
+    constructor(message: string, options?: ErrorOptions & {
+        kind?: BindingErrorKind;
+        dispatchError?: unknown;
+    });
+}
+type SignMember = (message: Uint8Array) => Uint8Array | Promise<Uint8Array>;
+interface BindPersonalIdToAccountParams {
+    /** Untyped papi API for the People chain. */
+    typedApi: unknown;
+    /** Polkadot client used to submit the unsigned extrinsic. */
+    client: PolkadotClient;
+    /** Numeric PersonalId of the personhood being bound. */
+    personalId: bigint;
+    /** SS58 address to bind to the PersonalId. */
+    account: SS58String;
+    /**
+     * Signs `blake2_256(implication)` with the personhood bandersnatch member
+     * key. Must return a 96-byte signature.
+     */
+    signMember: SignMember;
+    /**
+     * Override the `call_valid_at` block number. Defaults to the current best
+     * block number queried from the chain.
+     */
+    callValidAt?: number;
+    progress?: BindingProgress;
+}
+interface BindPersonalIdToAccountResult {
+    extrinsicHex: `0x${string}`;
+    blockHash: string;
+}
+interface BindingProgress {
+    onBestBlock?: (blockHash: string) => void;
+    onBroadcasted?: () => void;
+}
+/**
+ * Build the AsPerson extension value for a `set_personal_id_account` General
+ * extrinsic. Exported so unit tests can assert that the Bandersnatch signature
+ * is encoded as a hex string (papi 2.x `SizedBytes(96)` contract).
+ *
+ * @test-only — production callers use `bindPersonalIdToAccount` directly.
+ */
+declare function buildAsPersonExtensionValue(signature: Uint8Array, personalId: bigint): {
+    type: string;
+    value: [string, bigint];
+};
+declare const bindPersonalIdToAccount: ({ typedApi, client, personalId, account, signMember, callValidAt, progress, }: BindPersonalIdToAccountParams) => Promise<BindPersonalIdToAccountResult>;
+
+export { type BindPersonalIdToAccountParams, type BindPersonalIdToAccountResult, type BindingErrorKind, type BindingProgress, PersonalIdBindingError, type SignMember, bindPersonalIdToAccount, buildAsPersonExtensionValue };

package/dist/personhood/bind-personal-id.js

@@ -0,0 +1,12 @@
+import {
+  PersonalIdBindingError,
+  bindPersonalIdToAccount,
+  buildAsPersonExtensionValue
+} from "../chunk-A5IQ5MKO.js";
+import "../chunk-ZYVGHDMU.js";
+import "../chunk-T7EEVWNU.js";
+export {
+  PersonalIdBindingError,
+  bindPersonalIdToAccount,
+  buildAsPersonExtensionValue
+};

package/dist/personhood/bootstrap.d.ts

@@ -0,0 +1,85 @@
+import { SS58String } from 'polkadot-api';
+import { bindPersonalIdToAccount } from './bind-personal-id.js';
+import { claimPgas } from './claim-pgas.js';
+import { bindPaidAliasToAccount } from './bind-paid-alias.js';
+
+interface BootstrapState {
+    recognized: boolean;
+    personalIdBound: boolean;
+    pgasBalance: bigint;
+    paidAliasFee: bigint;
+    aliasBound: {
+        paid: boolean;
+        contextHex: string;
+        revision: number;
+    } | null;
+    reviveMapped: boolean;
+}
+interface BootstrapResult {
+    initialState: BootstrapState;
+    actionsExecuted: Array<"bind-personal-id" | "claim-pgas" | "bind-paid-alias" | "map-account">;
+    finalState: BootstrapState;
+}
+declare class RecognizeRequiredError extends Error {
+    constructor();
+}
+/**
+ * Probe the current bootstrap state from chain for a given account.
+ * All reads are at "best" block — suitable for sequential flow decisions.
+ */
+declare function probeBootstrapState({ peopleUnsafeApi, ahUnsafeApi, memberKey, account, }: {
+    peopleUnsafeApi: unknown;
+    ahUnsafeApi: unknown;
+    memberKey: Uint8Array;
+    account: SS58String;
+}): Promise<BootstrapState>;
+/**
+ * Determine the next action needed given the current bootstrap state.
+ * Returns null when the flow is complete.
+ */
+declare function nextBootstrapAction(state: BootstrapState): "bind-personal-id" | "claim-pgas" | "bind-paid-alias" | null;
+/**
+ * Test-only injection seam for `runBootstrap`. When provided, the real WS
+ * connections and environment lookup are bypassed entirely.
+ *
+ * @internal — not part of the public API.
+ */
+interface RunBootstrapTestApis {
+    /** Pre-built AH unsafe API (replaces `ahClient.getUnsafeApi()`). */
+    ahUnsafeApi: unknown;
+    /** Pre-built People unsafe API (replaces `peopleClient.getUnsafeApi()`). */
+    peopleUnsafeApi: unknown;
+    /**
+     * Mock AH client. Only `destroy` and `submitAndWatch` are used by bootstrap;
+     * a no-op `destroy` is sufficient when the test step doesn't submit.
+     */
+    ahClient: {
+        destroy: () => void;
+        submitAndWatch?: unknown;
+    };
+    /**
+     * Mock People client. Only `destroy` and `submitAndWatch` are used.
+     */
+    peopleClient: {
+        destroy: () => void;
+        submitAndWatch?: unknown;
+    };
+    /** Override `bindPersonalIdToAccount` (defaults to the real import). */
+    bindPersonalIdToAccount?: typeof bindPersonalIdToAccount;
+    /** Override `claimPgas` (defaults to the real import). */
+    claimPgas?: typeof claimPgas;
+    /** Override `bindPaidAliasToAccount` (defaults to the real import). */
+    bindPaidAliasToAccount?: typeof bindPaidAliasToAccount;
+}
+declare function runBootstrap({ mnemonic, environmentId, requireRecognized, _testApis, }: {
+    mnemonic: string;
+    environmentId: string;
+    requireRecognized?: boolean;
+    /**
+     * Test-only: inject pre-built API objects and function overrides.
+     * When set the real WS connections and environment lookup are skipped.
+     */
+    _testApis?: RunBootstrapTestApis;
+}): Promise<BootstrapResult>;
+
+export { type BootstrapResult, type BootstrapState, RecognizeRequiredError, type RunBootstrapTestApis, nextBootstrapAction, probeBootstrapState, runBootstrap };

package/dist/personhood/bootstrap.js

@@ -0,0 +1,245 @@
+import {
+  claimPgas
+} from "../chunk-74ETPOKH.js";
+import {
+  deriveMemberEntropy,
+  deriveMemberKey
+} from "../chunk-EJ5TNGAY.js";
+import "../chunk-UPWEOGLQ.js";
+import {
+  bindPaidAliasToAccount
+} from "../chunk-QHOZEY5X.js";
+import {
+  bindPersonalIdToAccount
+} from "../chunk-A5IQ5MKO.js";
+import {
+  bytesToHex
+} from "../chunk-ZYVGHDMU.js";
+import {
+  DOTNS_CONTEXT_BYTES,
+  PGAS_ASSET_ID
+} from "../chunk-T7EEVWNU.js";
+import {
+  WS_HEARTBEAT_TIMEOUT_MS
+} from "../chunk-CIXT75OF.js";
+import "../chunk-WVCIU6WM.js";
+import "../chunk-WNUWAA6F.js";
+import "../chunk-XWA3NPMX.js";
+import {
+  loadEnvironments
+} from "../chunk-F36C363Y.js";
+import "../chunk-ZOC4GITL.js";
+
+// src/personhood/bootstrap.ts
+import { createClient } from "polkadot-api";
+import { getPolkadotSigner } from "polkadot-api/signer";
+import { getWsProvider } from "polkadot-api/ws";
+import { Keyring } from "@polkadot/keyring";
+import { cryptoWaitReady } from "@polkadot/util-crypto";
+import * as verifiable from "verifiablejs/nodejs";
+var RecognizeRequiredError = class extends Error {
+  constructor() {
+    super(
+      "This account has not been recognised by the personhood faucet. Visit https://sudo.personhood.dev/personhood-faucet to request recognition, then re-run the bootstrap."
+    );
+    this.name = "RecognizeRequiredError";
+  }
+};
+async function probeBootstrapState({
+  peopleUnsafeApi,
+  ahUnsafeApi,
+  memberKey,
+  account
+}) {
+  const { PEOPLE_MEMBER_IDENTIFIER_HEX } = await import("./constants.js");
+  const people = peopleUnsafeApi;
+  const ah = ahUnsafeApi;
+  const [memberPosition, pgasAcct, feeRaw, aliasRow] = await Promise.all([
+    people.query.Members.Members.getValue(PEOPLE_MEMBER_IDENTIFIER_HEX, bytesToHex(memberKey), { at: "best" }),
+    ah.query.Assets.Account.getValue(PGAS_ASSET_ID, account, { at: "best" }),
+    ah.query.AliasAccounts.PaidAliasFee.getValue({ at: "best" }),
+    ah.query.AliasAccounts.AccountToAlias.getValue(account, { at: "best" })
+  ]);
+  const recognized = memberPosition?.type === "Included";
+  let personalIdBound = false;
+  const peoplePersonal = people.query.People;
+  if (peoplePersonal?.AccountToPersonalId) {
+    const personalId = await peoplePersonal.AccountToPersonalId.getValue(account, { at: "best" });
+    personalIdBound = personalId !== void 0;
+  }
+  const pgasBalance = pgasAcct?.balance ?? 0n;
+  const paidAliasFee = feeRaw ?? 0n;
+  const aliasBound = aliasRow ? {
+    paid: aliasRow.paid,
+    contextHex: aliasRow.ca.context,
+    revision: aliasRow.revision
+  } : null;
+  const reviveMapped = aliasRow !== void 0 && aliasRow !== null;
+  return {
+    recognized,
+    personalIdBound,
+    pgasBalance,
+    paidAliasFee,
+    aliasBound,
+    reviveMapped
+  };
+}
+function nextBootstrapAction(state) {
+  if (!state.personalIdBound) return "bind-personal-id";
+  if (state.pgasBalance < state.paidAliasFee) return "claim-pgas";
+  if (!state.aliasBound?.paid) return "bind-paid-alias";
+  return null;
+}
+async function runBootstrap({
+  mnemonic,
+  environmentId,
+  requireRecognized = true,
+  _testApis
+}) {
+  await cryptoWaitReady();
+  let ahClient;
+  let peopleClient;
+  let ahUnsafeApiResolved;
+  let peopleUnsafeApiResolved;
+  if (_testApis) {
+    ahClient = _testApis.ahClient;
+    peopleClient = _testApis.peopleClient;
+    ahUnsafeApiResolved = _testApis.ahUnsafeApi;
+    peopleUnsafeApiResolved = _testApis.peopleUnsafeApi;
+  } else {
+    const { doc } = await loadEnvironments();
+    const ahChain = doc.chains.find((c) => c.id === "asset-hub");
+    const peopleChain = doc.chains.find((c) => c.id === "people");
+    if (!ahChain || !peopleChain) {
+      throw new Error("environments.json missing asset-hub or people chain");
+    }
+    const ahEntry = ahChain.endpoints[environmentId];
+    const peopleEntry = peopleChain.endpoints[environmentId];
+    if (!ahEntry || !peopleEntry) {
+      throw new Error(
+        `No endpoints for environment '${environmentId}'. Bootstrap is only available on paseo-next-v2.`
+      );
+    }
+    const ahWss = Array.isArray(ahEntry.wss) ? ahEntry.wss[0] : ahEntry.wss;
+    const peopleWss = Array.isArray(peopleEntry.wss) ? peopleEntry.wss[0] : peopleEntry.wss;
+    const realAhClient = createClient(
+      getWsProvider(ahWss, { heartbeatTimeout: WS_HEARTBEAT_TIMEOUT_MS })
+    );
+    const realPeopleClient = createClient(
+      getWsProvider(peopleWss, { heartbeatTimeout: WS_HEARTBEAT_TIMEOUT_MS })
+    );
+    ahClient = realAhClient;
+    peopleClient = realPeopleClient;
+    ahUnsafeApiResolved = realAhClient.getUnsafeApi();
+    peopleUnsafeApiResolved = realPeopleClient.getUnsafeApi();
+  }
+  try {
+    const keyring = new Keyring({ type: "sr25519" });
+    const account = keyring.addFromMnemonic(mnemonic);
+    const ss58 = account.address;
+    const signer = getPolkadotSigner(
+      account.publicKey,
+      "Sr25519",
+      async (input) => account.sign(input)
+    );
+    const memberKey = deriveMemberKey(mnemonic);
+    const memberEntropy = deriveMemberEntropy(mnemonic);
+    const ahUnsafeApi = ahUnsafeApiResolved;
+    const peopleUnsafeApi = peopleUnsafeApiResolved;
+    const initialState = await probeBootstrapState({
+      peopleUnsafeApi,
+      ahUnsafeApi,
+      memberKey,
+      account: ss58
+    });
+    if (requireRecognized && !initialState.recognized) {
+      throw new RecognizeRequiredError();
+    }
+    const actionsExecuted = [];
+    let currentState = { ...initialState };
+    if (!currentState.personalIdBound) {
+      const memberKeyHex = "0x" + Array.from(memberKey, (b) => b.toString(16).padStart(2, "0")).join("");
+      const peoplePeopleStore = peopleUnsafeApi.query.People;
+      const personalId = await peoplePeopleStore?.Keys?.getValue(memberKeyHex, { at: "best" });
+      if (personalId === void 0 || personalId === null) {
+        throw new Error(
+          `cannot bind personal id: People.Keys[${memberKeyHex}] is not set on this chain. Visit the personhood faucet first.`
+        );
+      }
+      const _bindPersonalId = _testApis?.bindPersonalIdToAccount ?? bindPersonalIdToAccount;
+      await _bindPersonalId({
+        typedApi: peopleUnsafeApi,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        client: peopleClient,
+        personalId,
+        account: ss58,
+        signMember: (msg) => verifiable.sign(memberEntropy, msg)
+      });
+      actionsExecuted.push("bind-personal-id");
+      currentState = await probeBootstrapState({
+        peopleUnsafeApi,
+        ahUnsafeApi,
+        memberKey,
+        account: ss58
+      });
+    }
+    const buildRingProof = async ({ members, context, msg }) => {
+      const result = verifiable.one_shot(memberEntropy, members, context, msg);
+      return { proof: result.proof, alias: result.alias };
+    };
+    if (currentState.pgasBalance < currentState.paidAliasFee) {
+      const _claimPgas = _testApis?.claimPgas ?? claimPgas;
+      await _claimPgas({
+        peopleUnsafeApi,
+        ahUnsafeApi,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ahClient,
+        target: ss58,
+        memberKey,
+        buildRingProof
+      });
+      actionsExecuted.push("claim-pgas");
+      currentState = await probeBootstrapState({
+        peopleUnsafeApi,
+        ahUnsafeApi,
+        memberKey,
+        account: ss58
+      });
+    }
+    if (!currentState.aliasBound?.paid) {
+      const _bindPaidAlias = _testApis?.bindPaidAliasToAccount ?? bindPaidAliasToAccount;
+      await _bindPaidAlias({
+        peopleUnsafeApi,
+        ahUnsafeApi,
+        account: ss58,
+        memberKey,
+        contextBytes: DOTNS_CONTEXT_BYTES,
+        signCall: signer,
+        buildRingProof
+      });
+      actionsExecuted.push("bind-paid-alias");
+      currentState = await probeBootstrapState({
+        peopleUnsafeApi,
+        ahUnsafeApi,
+        memberKey,
+        account: ss58
+      });
+    }
+    return { initialState, actionsExecuted, finalState: currentState };
+  } finally {
+    try {
+      ahClient.destroy();
+    } catch {
+    }
+    try {
+      peopleClient.destroy();
+    } catch {
+    }
+  }
+}
+export {
+  RecognizeRequiredError,
+  nextBootstrapAction,
+  probeBootstrapState,
+  runBootstrap
+};

package/dist/personhood/claim-pgas.d.ts

@@ -0,0 +1,61 @@
+import { PolkadotClient, SS58String } from 'polkadot-api';
+
+type PgasClaimErrorKind = "PgasAssetNotCreated" | "AlreadyClaimedToday" | "InvalidClaimSlot" | "InvalidClaimDay" | "BadProof" | "RingRootNotFound" | "NotARecognizedPerson" | "DispatchError" | "RpcError" | "ClientError" | "Unknown";
+declare class PgasClaimError extends Error {
+    readonly kind: PgasClaimErrorKind;
+    readonly dispatchError?: unknown;
+    constructor(message: string, options?: ErrorOptions & {
+        kind?: PgasClaimErrorKind;
+        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 PgasClaimProgress {
+    onBroadcasted?: () => void;
+    onBestBlock?: (blockHash: string) => void;
+}
+interface ClaimPgasParams {
+    peopleUnsafeApi: unknown;
+    ahUnsafeApi: unknown;
+    ahClient: PolkadotClient;
+    target: SS58String;
+    memberKey: Uint8Array;
+    buildRingProof: BuildRingProof;
+    slotIndex?: number;
+    progress?: PgasClaimProgress;
+}
+interface ClaimPgasResult {
+    blockHash: string;
+    amount: bigint;
+    alias: Uint8Array;
+}
+/**
+ * Build the AsPgas::Claim extension value for a `claim_pgas` General extrinsic.
+ * Exported so unit tests can assert that the ring-VRF proof is encoded as a hex
+ * string (papi 2.x `FixedSizeBinary<788>` / SizedBytes contract).
+ *
+ * @test-only — production callers use `claimPgas` directly.
+ */
+declare function buildAsPgasClaimExtensionValue(proof: Uint8Array, ringIndex: number, revision: number, day: number): {
+    type: string;
+    value: {
+        proof: string;
+        ring_index: number;
+        revision: number;
+        collection: unknown;
+        day: number;
+    };
+};
+declare const claimPgas: ({ peopleUnsafeApi, ahUnsafeApi, ahClient, target, memberKey, buildRingProof, slotIndex, progress, }: ClaimPgasParams) => Promise<ClaimPgasResult>;
+
+export { type BuildRingProof, type BuildRingProofInput, type ClaimPgasParams, type ClaimPgasResult, PgasClaimError, type PgasClaimErrorKind, type PgasClaimProgress, type RingExponent, buildAsPgasClaimExtensionValue, claimPgas };

package/dist/personhood/claim-pgas.js

@@ -0,0 +1,12 @@
+import {
+  PgasClaimError,
+  buildAsPgasClaimExtensionValue,
+  claimPgas
+} from "../chunk-74ETPOKH.js";
+import "../chunk-ZYVGHDMU.js";
+import "../chunk-T7EEVWNU.js";
+export {
+  PgasClaimError,
+  buildAsPgasClaimExtensionValue,
+  claimPgas
+};

package/dist/personhood/constants.d.ts

@@ -0,0 +1,23 @@
+declare const DOTNS_CONTEXT_HEX = "0x646f746e73000000000000000000000000000000000000000000000000000000";
+declare const DOTNS_CONTEXT_BYTES: Uint8Array;
+declare const PGAS_ASSET_ID = 2000000000;
+declare const PGAS_ASSET_LOCATION: {
+    parents: 0;
+    interior: {
+        type: "X2";
+        value: readonly [{
+            readonly type: "PalletInstance";
+            readonly value: 50;
+        }, {
+            readonly type: "GeneralIndex";
+            readonly value: bigint;
+        }];
+    };
+};
+declare const PROOF_BYTES = 788;
+declare const BANDERSNATCH_SIGNATURE_BYTES = 96;
+declare const PEOPLE_MEMBER_IDENTIFIER_HEX = "0x70656f706c652020202020202020202020202020202020202020202020202020";
+declare const MEMBER_ENTROPY_KEY: Uint8Array<ArrayBuffer>;
+declare const PAID_PROOF_TAG: Uint8Array<ArrayBuffer>;
+
+export { BANDERSNATCH_SIGNATURE_BYTES, DOTNS_CONTEXT_BYTES, DOTNS_CONTEXT_HEX, MEMBER_ENTROPY_KEY, PAID_PROOF_TAG, PEOPLE_MEMBER_IDENTIFIER_HEX, PGAS_ASSET_ID, PGAS_ASSET_LOCATION, PROOF_BYTES };

package/dist/personhood/constants.js

@@ -0,0 +1,22 @@
+import {
+  BANDERSNATCH_SIGNATURE_BYTES,
+  DOTNS_CONTEXT_BYTES,
+  DOTNS_CONTEXT_HEX,
+  MEMBER_ENTROPY_KEY,
+  PAID_PROOF_TAG,
+  PEOPLE_MEMBER_IDENTIFIER_HEX,
+  PGAS_ASSET_ID,
+  PGAS_ASSET_LOCATION,
+  PROOF_BYTES
+} from "../chunk-T7EEVWNU.js";
+export {
+  BANDERSNATCH_SIGNATURE_BYTES,
+  DOTNS_CONTEXT_BYTES,
+  DOTNS_CONTEXT_HEX,
+  MEMBER_ENTROPY_KEY,
+  PAID_PROOF_TAG,
+  PEOPLE_MEMBER_IDENTIFIER_HEX,
+  PGAS_ASSET_ID,
+  PGAS_ASSET_LOCATION,
+  PROOF_BYTES
+};