bulletin-deploy 0.7.21 → 0.7.22-rc.1

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-V5NUBOEX.js";
+import "./chunk-FSSKFXTZ.js";
+import "./chunk-WNUWAA6F.js";
+import "./chunk-XWA3NPMX.js";
 export {
   buildCliFlagsSummary,
   buildLabels,

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
+};

package/dist/chunk-A5IQ5MKO.js

@@ -0,0 +1,207 @@
+import {
+  buildImplicationMessage,
+  buildV5GeneralExtrinsic,
+  bytesToHex,
+  hexToBytes,
+  readExtensionOrder,
+  toHex
+} from "./chunk-ZYVGHDMU.js";
+import {
+  BANDERSNATCH_SIGNATURE_BYTES
+} from "./chunk-T7EEVWNU.js";
+
+// src/personhood/bind-personal-id.ts
+import { Enum } from "polkadot-api";
+var AS_PERSON_IDENTIFIER = "AsPerson";
+var VERIFY_MULTI_SIGNATURE_IDENTIFIER = "VerifyMultiSignature";
+var IMPLICATION_EXCLUDE = /* @__PURE__ */ new Set([
+  "VerifyMultiSignature",
+  AS_PERSON_IDENTIFIER,
+  "AuthorizeCall",
+  "StorageWeightReclaim"
+]);
+var PersonalIdBindingError = class extends Error {
+  dispatchError;
+  kind;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "PersonalIdBindingError";
+    this.kind = options.kind ?? "unknown";
+    this.dispatchError = options.dispatchError;
+  }
+};
+function buildAsPersonExtensionValue(signature, personalId) {
+  return Enum("AsPersonalIdentityWithProof", [bytesToHex(signature), personalId]);
+}
+var bindPersonalIdToAccount = async ({
+  typedApi,
+  client,
+  personalId,
+  account,
+  signMember,
+  callValidAt,
+  progress
+}) => {
+  const api = typedApi;
+  if (typeof api.tx?.People?.set_personal_id_account !== "function") {
+    throw new PersonalIdBindingError(
+      "typedApi does not expose People.set_personal_id_account \u2014 wrong chain or stale descriptors",
+      { kind: "client_error" }
+    );
+  }
+  const block = callValidAt ?? await api.query.System.Number.getValue();
+  const innerTx = api.tx.People.set_personal_id_account({
+    account,
+    call_valid_at: block
+  });
+  const callBytes = await innerTx.getEncodedData();
+  const passEmpty = await capturePass({
+    innerTx,
+    asPersonValue: new Uint8Array()
+  });
+  const msgHash = buildImplicationMessage(
+    callBytes,
+    passEmpty.extensions,
+    IMPLICATION_EXCLUDE
+  );
+  const signature = await Promise.resolve(signMember(msgHash));
+  if (signature.length !== BANDERSNATCH_SIGNATURE_BYTES) {
+    throw new PersonalIdBindingError(
+      `Bandersnatch signature must be ${BANDERSNATCH_SIGNATURE_BYTES} bytes, got ${signature.length}`,
+      { kind: "client_error" }
+    );
+  }
+  const asPersonProof = Enum("AsPersonalIdentityWithProof", [bytesToHex(signature), personalId]);
+  const passProof = await capturePass({
+    innerTx,
+    asPersonValue: asPersonProof
+  });
+  const extrinsicBytes = buildV5GeneralExtrinsic(callBytes, passProof.extensions);
+  const extrinsicHex = toHex(extrinsicBytes);
+  const blockHash = await submitExtrinsic(client, extrinsicHex, progress);
+  return { extrinsicHex, blockHash };
+};
+var capturePass = async ({
+  innerTx,
+  asPersonValue
+}) => {
+  let captured = null;
+  const sentinel = new Error("__personhood_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];
+        if (!ext) {
+          throw new PersonalIdBindingError(
+            `papi did not produce signed extension '${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, {
+      customSignedExtensions: {
+        [AS_PERSON_IDENTIFIER]: {
+          value: asPersonValue,
+          additionalSigned: new Uint8Array()
+        },
+        [VERIFY_MULTI_SIGNATURE_IDENTIFIER]: {
+          value: Enum("Disabled")
+        },
+        RestrictOrigins: {
+          value: new Uint8Array([1]),
+          additionalSigned: new Uint8Array()
+        }
+      }
+    });
+  } catch (err) {
+    if (err !== sentinel) throw err;
+  }
+  if (!captured) {
+    throw new PersonalIdBindingError(
+      "extension capture failed \u2014 papi never invoked signTx",
+      { kind: "client_error" }
+    );
+  }
+  return captured;
+};
+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 = (blockHash) => {
+      if (settled) return;
+      settled = true;
+      resolve(blockHash);
+    };
+    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 PersonalIdBindingError(
+                "set_personal_id_account dispatched but failed in-block",
+                {
+                  kind: "dispatch_error",
+                  dispatchError: event.dispatchError
+                }
+              )
+            );
+            return;
+          }
+          progress?.onBestBlock?.(event.block.hash);
+          return;
+        }
+        if (event.type === "finalized") {
+          if (event.ok === false) {
+            fail(
+              new PersonalIdBindingError(
+                "set_personal_id_account dispatch failed at finalization",
+                {
+                  kind: "dispatch_error",
+                  dispatchError: event.dispatchError
+                }
+              )
+            );
+            return;
+          }
+          succeed(event.block.hash);
+        }
+      },
+      error: (err) => {
+        fail(
+          err instanceof PersonalIdBindingError ? err : new PersonalIdBindingError(
+            err instanceof Error ? `RPC rejected extrinsic: ${err.message}` : "RPC error during submitAndWatch",
+            { cause: err, kind: "rpc_error" }
+          )
+        );
+      }
+    });
+  });
+};
+
+export {
+  PersonalIdBindingError,
+  buildAsPersonExtensionValue,
+  bindPersonalIdToAccount
+};