@pvium/p2id-core 0.1.0

package/dist/p2id.js

@@ -0,0 +1,82 @@
+import { keccak_256 } from '@noble/hashes/sha3';
+import { identityHash as hashIdentity, toHex } from './identity.js';
+import { resolveIdentityType } from './identityNames.js';
+import { P2ID_SCHEME, P2ID_SCHEMES } from './p2idConstants.js';
+export { P2ID_SCHEME, P2ID_SCHEMES };
+/**
+ * P2ID address derivation.
+ *
+ *   identityHash = sha256(identityDomain ‖ byte(typeId) ‖ normalize(value))
+ *   p2id         = keccak256(0xff ‖ factory ‖ identityHash ‖ vaultInitCodeHash)[12..]
+ *
+ * `normalize` ASCII-lowercases every type except phone and wallet, and lowercases `0x…` wallet
+ * addresses. A *scheme* (`p2id.vault.vN`) fixes the three constants: the identity domain, the
+ * vault creation-code hash and the factory. The factory is deployed through the deterministic
+ * deployment proxy, so it is at the same address on every EVM chain: a P2ID address is
+ * chain-agnostic, like any wallet address. (The vault contract still has to be deployed on each
+ * chain where it is claimed; anyone can do that, and funds sent before then are claimable once
+ * it is.)
+ *
+ * Each Pvium environment is its own stack: `production` (mainnets, the production Privy app) and
+ * `sandbox` (testnets, the sandbox Privy app) have different factories, so the same identity has
+ * a different address in each. Production is the default.
+ *
+ * Schemes are history. A change to the vault bytecode moves every address, so it ships as the
+ * next scheme and becomes `P2ID_SCHEME`; earlier schemes stay in `P2ID_SCHEMES` so addresses
+ * people were already given can be derived, and claimed, forever.
+ */
+/** Constants of a scheme; defaults to the current one. */
+export function p2idScheme(name = P2ID_SCHEME) {
+    const s = P2ID_SCHEMES[name];
+    if (!s)
+        throw new Error(`unknown P2ID scheme "${name}" (known: ${Object.keys(P2ID_SCHEMES).join(', ')})`);
+    return s;
+}
+/** The identity commitment: the CREATE2 salt of the identity's vault and the value proofs bind. */
+export function identityHash(type, value, scheme = P2ID_SCHEME) {
+    return hashIdentity(resolveIdentityType(type), value, p2idScheme(scheme).identityDomain);
+}
+/** The P2ID address for an identity: where to pay it, on any EVM chain, deployed or not. Checksummed. */
+export function p2idAddress(input) {
+    const salt = identityHash(input.identityType, input.identityValue, input.scheme);
+    return p2idAddressForHash(salt, { scheme: input.scheme, environment: input.environment, factory: input.factory });
+}
+/** Same, from an identity hash you already have (e.g. from an attestation's claim). */
+export function p2idAddressForHash(identityHash, opts = {}) {
+    const scheme = p2idScheme(opts.scheme);
+    const environment = opts.environment ?? 'production';
+    if (environment !== 'production' && environment !== 'sandbox')
+        throw new Error(`unknown environment "${environment}"`);
+    const factory = opts.factory ?? scheme.factories[environment];
+    if (!factory) {
+        throw new Error(`scheme ${opts.scheme ?? P2ID_SCHEME} has no ${environment} factory address in this release yet; pass \`factory\` explicitly`);
+    }
+    if (!/^0x[0-9a-fA-F]{40}$/.test(factory))
+        throw new Error(`bad factory address ${factory}`);
+    const preimage = new Uint8Array(1 + 20 + 32 + 32);
+    preimage[0] = 0xff;
+    preimage.set(hexToBytes(factory, 20), 1);
+    preimage.set(hexToBytes(identityHash, 32), 21);
+    preimage.set(hexToBytes(scheme.vaultInitCodeHash, 32), 53);
+    return checksumAddress(toHex(keccak_256(preimage).subarray(12)));
+}
+/** EIP-55 checksum. */
+export function checksumAddress(address) {
+    const lower = address.slice(2).toLowerCase();
+    const hash = keccak_256(new TextEncoder().encode(lower));
+    let out = '0x';
+    for (let i = 0; i < 40; i++) {
+        const nibble = (hash[i >> 1] >> (i % 2 === 0 ? 4 : 0)) & 0xf;
+        out += nibble >= 8 ? lower[i].toUpperCase() : lower[i];
+    }
+    return out;
+}
+function hexToBytes(hex, length) {
+    const h = hex.startsWith('0x') ? hex.slice(2) : hex;
+    if (h.length !== length * 2 || !/^[0-9a-fA-F]*$/.test(h))
+        throw new Error(`expected ${length}-byte hex, got ${hex}`);
+    const out = new Uint8Array(length);
+    for (let i = 0; i < length; i++)
+        out[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
+    return out;
+}

package/dist/p2idConstants.d.ts

@@ -0,0 +1,38 @@
+export interface P2IDScheme {
+    /** Domain prefix of the identity hash this scheme salts vaults with, e.g. "p2id.identity.v1". */
+    identityDomain: string;
+    /** keccak256 of the P2IDVault creation code; with the factory address it fixes every vault address. */
+    vaultInitCodeHash: `0x${string}`;
+    /**
+     * The PviumP2IdVaultFactory per Pvium environment. Deployed through the deterministic deployment
+     * proxy, so within an environment it has one address on every EVM chain. "production" is the
+     * mainnet stack, "sandbox" the testnet stack (a different Privy app and key set). Null until
+     * that environment's first deployment is recorded.
+     */
+    factories: {
+        production: `0x${string}` | null;
+        sandbox: `0x${string}` | null;
+    };
+}
+/** Every P2ID address scheme this release can derive, keyed by domain. Older schemes stay forever. */
+export declare const P2ID_SCHEMES: {
+    readonly "p2id.vault.v1": {
+        readonly identityDomain: "p2id.identity.v1";
+        readonly vaultInitCodeHash: "0xe6b8d636ef647cfda0770fa7f2a8c93b886399c3d9405ffcb35ef946083a0802";
+        readonly factories: {
+            readonly production: null;
+            readonly sandbox: "0x21859137b4979B101079742942c741224529eE6D";
+        };
+    };
+    readonly "p2id.vault.v2": {
+        readonly identityDomain: "p2id.identity.v1";
+        readonly vaultInitCodeHash: "0xd98f76cb96350f1064d0358ba2d449e80533e26ba3900b7fba5d7570888f3699";
+        readonly factories: {
+            readonly production: null;
+            readonly sandbox: "0x85463cD0FC3CcB9d0891E2ac3124322349A23a86";
+        };
+    };
+};
+export type P2IDSchemeName = keyof typeof P2ID_SCHEMES;
+/** The scheme new payments should use. */
+export declare const P2ID_SCHEME: "p2id.vault.v2";

package/dist/p2idConstants.js

@@ -0,0 +1,21 @@
+/** Every P2ID address scheme this release can derive, keyed by domain. Older schemes stay forever. */
+export const P2ID_SCHEMES = {
+    "p2id.vault.v1": {
+        "identityDomain": "p2id.identity.v1",
+        "vaultInitCodeHash": "0xe6b8d636ef647cfda0770fa7f2a8c93b886399c3d9405ffcb35ef946083a0802",
+        "factories": {
+            "production": null,
+            "sandbox": "0x21859137b4979B101079742942c741224529eE6D"
+        }
+    },
+    "p2id.vault.v2": {
+        "identityDomain": "p2id.identity.v1",
+        "vaultInitCodeHash": "0xd98f76cb96350f1064d0358ba2d449e80533e26ba3900b7fba5d7570888f3699",
+        "factories": {
+            "production": null,
+            "sandbox": "0x85463cD0FC3CcB9d0891E2ac3124322349A23a86"
+        }
+    }
+};
+/** The scheme new payments should use. */
+export const P2ID_SCHEME = 'p2id.vault.v2';

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@pvium/p2id-core",
+  "version": "0.1.0",
+  "description": "P2ID protocol core: identity types and hashing, chain-agnostic P2ID address derivation, and the Solidity sources",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/esm/index.js"
+    },
+    "./contracts/*": "./contracts/*"
+  },
+  "files": [
+    "dist",
+    "contracts",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pvium/zkid.git"
+  },
+  "scripts": {
+    "build": "sh scripts/sync-contracts.sh && node scripts/embed-p2id.mjs && tsc -p tsconfig.esm.json && tsc -p tsconfig.cjs.json && node scripts/finalize-dist.mjs",
+    "test": "yarn build && node --test --import tsx test/*.test.ts",
+    "prepublishOnly": "yarn test"
+  },
+  "dependencies": {
+    "@noble/hashes": "^1.5.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}