@pvium/p2id-core 0.1.0 → 0.1.1

package/README.md

@@ -21,7 +21,10 @@ Requires Node.js 20+ or a browser with Web Crypto support.
 ```ts
 import { p2idAddress, IdentityType } from '@pvium/p2id-core';
 
-const to = p2idAddress({ identityType: IdentityType.Email, identityValue: 'you@example.com' });
+const to = p2idAddress({
+  identityType: IdentityType.Email,
+  identityValue: 'you@example.com',
+});
 // Checksummed vault address for native coin or supported ERC-20 transfers.
 ```
 
@@ -31,8 +34,16 @@ Email addresses are case-insensitive: `You@Example.com` derives the same address
 Production is the default environment. Use `sandbox` on testnets or pass a custom factory address:
 
 ```ts
-p2idAddress({ identityType: IdentityType.X, identityValue: 'jack', environment: 'sandbox' });
-p2idAddress({ identityType: IdentityType.Github, identityValue: 'octocat', factory: '0xYourFactory…' });
+p2idAddress({
+  identityType: IdentityType.X,
+  identityValue: 'jack',
+  environment: 'sandbox',
+});
+p2idAddress({
+  identityType: IdentityType.Github,
+  identityValue: 'octocat',
+  factory: '0xYourFactory…',
+});
 ```
 
 Derivation requires a recorded factory for the selected environment or an explicit `factory`.
@@ -45,15 +56,25 @@ Using [ethers](https://docs.ethers.org) v6:
 import { ethers } from 'ethers';
 import { p2idAddress, IdentityType } from '@pvium/p2id-core';
 
-const signer = new ethers.Wallet(process.env.PRIVATE_KEY!, new ethers.JsonRpcProvider(process.env.RPC_URL));
-const to = p2idAddress({ identityType: IdentityType.Telegram, identityValue: 'durov' });
+const signer = new ethers.Wallet(
+  process.env.PRIVATE_KEY!,
+  new ethers.JsonRpcProvider(process.env.RPC_URL),
+);
+const to = p2idAddress({
+  identityType: IdentityType.Telegram,
+  identityValue: 'durov',
+});
 
 // the native coin (BNB on BNB Chain, ETH on Base)
 await signer.sendTransaction({ to, value: ethers.parseEther('0.1') });
 
 // an ERC-20
 const USDC = '0x…'; // the token's contract address on the chain you are paying on
-const usdc = new ethers.Contract(USDC, ['function transfer(address to, uint256 amount) returns (bool)'], signer);
+const usdc = new ethers.Contract(
+  USDC,
+  ['function transfer(address to, uint256 amount) returns (bool)'],
+  signer,
+);
 await usdc.transfer(to, 25_000_000n); // 25 USDC (6 decimals)
 ```
 
@@ -69,39 +90,50 @@ deposit after that window elapses.
 import { ethers } from 'ethers';
 import { identityHash, p2idScheme, IdentityType } from '@pvium/p2id-core';
 
-const signer = new ethers.Wallet(process.env.PRIVATE_KEY!, new ethers.JsonRpcProvider(process.env.RPC_URL));
+const signer = new ethers.Wallet(
+  process.env.PRIVATE_KEY!,
+  new ethers.JsonRpcProvider(process.env.RPC_URL),
+);
 const factory = new ethers.Contract(
   p2idScheme().factories.production!, // or .sandbox on testnets
-  ['function fund(bytes32 identityHash, address token, uint256 amount, bytes32 constraint, uint64 refundWindow, bytes32 ref) payable returns (address vault, uint256 depositId)'],
+  [
+    'function fund(bytes32 identityHash, address token, uint256 amount, bytes32 constraint, uint64 refundWindow, bytes32 ref) payable returns (address vault, uint256 depositId)',
+  ],
   signer,
 );
 
 const id = identityHash(IdentityType.Email, 'you@example.com');
 const NO_CONSTRAINT = ethers.ZeroHash; // no additional claim requirement
-const WEEK = 7 * 24 * 3600;            // refund window in seconds
-const ref = ethers.id('invoice-42');  // application-defined bytes32; ethers.ZeroHash for none
+const WEEK = 7 * 24 * 3600; // refund window in seconds
+const ref = ethers.id('invoice-42'); // application-defined bytes32; ethers.ZeroHash for none
 
 // Native coin: use the zero address for `token` and send `amount` as transaction value.
 const amount = ethers.parseEther('0.1');
-await factory.fund(id, ethers.ZeroAddress, amount, NO_CONSTRAINT, WEEK, ref, { value: amount });
+await factory.fund(id, ethers.ZeroAddress, amount, NO_CONSTRAINT, WEEK, ref, {
+  value: amount,
+});
 
 // an ERC-20: approve the factory, then fund
 const USDC = '0x…'; // the token's contract address
-const usdc = new ethers.Contract(USDC, ['function approve(address spender, uint256 amount) returns (bool)'], signer);
+const usdc = new ethers.Contract(
+  USDC,
+  ['function approve(address spender, uint256 amount) returns (bool)'],
+  signer,
+);
 await usdc.approve(await factory.getAddress(), 25_000_000n);
 await factory.fund(id, USDC, 25_000_000n, NO_CONSTRAINT, WEEK, ref);
 ```
 
 `fund` accepts the same arguments for native coin and ERC-20 deposits:
 
-| Argument | Meaning |
-| --- | --- |
-| `identityHash` | Recipient commitment from `identityHash(type, value)` |
-| `token` | ERC-20 contract address, or the zero address for native coin |
-| `amount` | Amount in the asset's smallest unit |
-| `constraint` | A 32-byte commitment to an additional claim requirement; zero for none |
-| `refundWindow` | Seconds before an unclaimed deposit becomes refundable |
-| `ref` | Application-defined 32-byte reference, emitted in `Funded`; zero for none |
+| Argument       | Meaning                                                                   |
+| -------------- | ------------------------------------------------------------------------- |
+| `identityHash` | Recipient commitment from `identityHash(type, value)`                     |
+| `token`        | ERC-20 contract address, or the zero address for native coin              |
+| `amount`       | Amount in the asset's smallest unit                                       |
+| `constraint`   | A 32-byte commitment to an additional claim requirement; zero for none    |
+| `refundWindow` | Seconds before an unclaimed deposit becomes refundable                    |
+| `ref`          | Application-defined 32-byte reference, emitted in `Funded`; zero for none |
 
 The window must fall within the factory's configured limits. After it elapses, the funder calls
 `refund(depositId)` on the vault. Contract interfaces are included; see [Solidity](#solidity).
@@ -123,7 +155,11 @@ Read native coin and ERC-20 balances at the derived address:
 const provider = new ethers.JsonRpcProvider(process.env.RPC_URL);
 await provider.getBalance(to); // native coin
 
-const token = new ethers.Contract(USDC, ['function balanceOf(address) view returns (uint256)'], provider);
+const token = new ethers.Contract(
+  USDC,
+  ['function balanceOf(address) view returns (uint256)'],
+  provider,
+);
 await token.balanceOf(to); // ERC-20
 ```
 
@@ -136,21 +172,21 @@ identity provider: it does not accept provider-specific account types (e.g. Priv
 these to the numeric IDs used in identity hashes, and `identityTypeName` gives the P2ID name of an
 ID. The type table is append-only.
 
-| `IdentityType.` | Id | Value | Example | Lowercased |
-| --- | ---: | --- | --- | :---: |
-| `Email` | 0 | address | `you@example.com` | yes |
-| `Phone` | 1 | E.164 number | `+15551234567` | no |
-| `Google` | 2 | email | `you@gmail.com` | yes |
-| `X` (alias `Twitter`) | 3 | username, no `@` | `jack` | yes |
-| `Discord` | 4 | username | `wumpus` | yes |
-| `Github` | 5 | username | `octocat` | yes |
-| `Linkedin` | 6 | email | `you@example.com` | yes |
-| `Apple` | 7 | email | `you@icloud.com` | yes |
-| `Telegram` | 8 | username | `durov` | yes |
-| `Tiktok` | 9 | username | `charlidamelio` | yes |
-| `Instagram` | 10 | username | `instagram` | yes |
-| `Farcaster` | 11 | username | `dwr` | yes |
-| `Wallet` | 12 | address | `0xA01b…0f98` or base58 | only `0x…` |
+| `IdentityType.`       |  Id | Value            | Example                 | Lowercased |
+| --------------------- | --: | ---------------- | ----------------------- | :--------: |
+| `Email`               |   0 | address          | `you@example.com`       |    yes     |
+| `Phone`               |   1 | E.164 number     | `+15551234567`          |     no     |
+| `Google`              |   2 | email            | `you@gmail.com`         |    yes     |
+| `X` (alias `Twitter`) |   3 | username, no `@` | `jack`                  |    yes     |
+| `Discord`             |   4 | username         | `wumpus`                |    yes     |
+| `Github`              |   5 | username         | `octocat`               |    yes     |
+| `Linkedin`            |   6 | email            | `you@example.com`       |    yes     |
+| `Apple`               |   7 | email            | `you@icloud.com`        |    yes     |
+| `Telegram`            |   8 | username         | `durov`                 |    yes     |
+| `Tiktok`              |   9 | username         | `charlidamelio`         |    yes     |
+| `Instagram`           |  10 | username         | `instagram`             |    yes     |
+| `Farcaster`           |  11 | username         | `dwr`                   |    yes     |
+| `Wallet`              |  12 | address          | `0xA01b…0f98` or base58 | only `0x…` |
 
 The same email produces different addresses under `Email`, `Google`, `Linkedin` and `Apple`.
 Select the type the recipient will use to authenticate.
@@ -165,13 +201,19 @@ p2id         = keccak256( 0xff ‖ factory ‖ identityHash ‖ vaultInitCodeHas
 ```
 
 ```ts
-import { identityHash, p2idAddressForHash, p2idScheme, P2ID_SCHEME, IdentityType } from '@pvium/p2id-core';
+import {
+  identityHash,
+  p2idAddressForHash,
+  p2idScheme,
+  P2ID_SCHEME,
+  IdentityType,
+} from '@pvium/p2id-core';
 
 const hash = identityHash(IdentityType.Email, 'you@example.com'); // identity commitment and vault salt
-p2idAddressForHash(hash, { environment: 'sandbox' });        // same result as p2idAddress(...)
+p2idAddressForHash(hash, { environment: 'sandbox' }); // same result as p2idAddress(...)
 
-P2ID_SCHEME;   // 'pvium.vault.v1', the current address scheme
-p2idScheme();  // { identityDomain, vaultInitCodeHash, factories: { production, sandbox } }
+P2ID_SCHEME; // 'pvium.vault.v1', the current address scheme
+p2idScheme(); // { identityDomain, vaultInitCodeHash, factories: { production, sandbox } }
 ```
 
 The formula excludes the chain ID. Addresses match across chains with standard CREATE2 semantics
@@ -215,7 +257,9 @@ For a base64-encoded attestation proof:
 ```ts
 const hash = identityHash(IdentityType.Email, 'you@example.com');
 const proof = ethers.decodeBase64(attestation.proof);
-await payByEmail.pay(proof, publicInputFields, hash, attestation.wallet, { value });
+await payByEmail.pay(proof, publicInputFields, hash, attestation.wallet, {
+  value,
+});
 ```
 
 `verifyIdentity` checks the identity type, identity hash and wallet hash against the proof.
@@ -228,12 +272,12 @@ For a wallet on another chain, such as a base58 Solana address, pass
 
 ## Exports
 
-| Export | Purpose |
-| --- | --- |
-| `p2idAddress(input)` | Derive a vault address from `{ identityType, identityValue, environment?, scheme?, factory? }` |
-| `p2idAddressForHash(hash, opts?)` | Derive a vault address from an identity hash |
-| `identityHash(type, value, scheme?)` | Compute the identity commitment used as the vault salt |
-| `P2ID_SCHEME`, `P2ID_SCHEMES`, `p2idScheme(name?)` | Read address-scheme constants |
-| `IdentityType`, `IdentityTypeName`, `IDENTITY_TYPE_BY_NAME`, `resolveIdentityType` | Identity type IDs and name mappings |
-| `normalizeIdentityValue`, `isCaseInsensitive`, `HASH_PREFIX` | Identity normalisation rules and hash prefix |
-| `checksumAddress`, `toHex` | Address checksum and hexadecimal encoding |
+| Export                                                                             | Purpose                                                                                        |
+| ---------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
+| `p2idAddress(input)`                                                               | Derive a vault address from `{ identityType, identityValue, environment?, scheme?, factory? }` |
+| `p2idAddressForHash(hash, opts?)`                                                  | Derive a vault address from an identity hash                                                   |
+| `identityHash(type, value, scheme?)`                                               | Compute the identity commitment used as the vault salt                                         |
+| `P2ID_SCHEME`, `P2ID_SCHEMES`, `p2idScheme(name?)`                                 | Read address-scheme constants                                                                  |
+| `IdentityType`, `IdentityTypeName`, `IDENTITY_TYPE_BY_NAME`, `resolveIdentityType` | Identity type IDs and name mappings                                                            |
+| `normalizeIdentityValue`, `isCaseInsensitive`, `HASH_PREFIX`                       | Identity normalisation rules and hash prefix                                                   |
+| `checksumAddress`, `toHex`                                                         | Address checksum and hexadecimal encoding                                                      |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pvium/p2id-core",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "P2ID protocol core: identity types and hashing, chain-agnostic P2ID address derivation, and the Solidity sources",
   "license": "MIT",
   "type": "module",
@@ -41,4 +41,4 @@
   "engines": {
     "node": ">=20"
   }
-}
+}

package/dist/identity.d.ts

@@ -1,38 +0,0 @@
-/**
- * Identity types. The numeric value is the protocol's type id (it is what gets hashed), so it
- * must match circuit/src/identity.nr and never change.
- */
-export declare enum IdentityType {
-    Email = 0,
-    Phone = 1,
-    Google = 2,
-    Twitter = 3,
-    /** Alias of `Twitter`: the platform's current name. Same id, same addresses. */
-    X = 3,
-    Discord = 4,
-    Github = 5,
-    Linkedin = 6,
-    Apple = 7,
-    Telegram = 8,
-    Tiktok = 9,
-    Instagram = 10,
-    Farcaster = 11,
-    Wallet = 12
-}
-/** Domain-separation prefix baked into the circuit's identity hash. */
-export declare const HASH_PREFIX = "p2id.identity.v1";
-/** Types whose value is ASCII-lowercased before hashing: everything except phone numbers and
- *  wallet addresses (matches CASE_INSENSITIVE in circuit/src/identity.nr). */
-export declare function isCaseInsensitive(type: IdentityType): boolean;
-/**
- * Apply the circuit's normalisation to an identity value: ASCII-lowercase for case-insensitive
- * types and for EVM (`0x…`) wallet addresses; base58 (Solana) addresses are left untouched.
- */
-export declare function normalizeIdentityValue(type: IdentityType, value: string): string;
-/**
- * `sha256(HASH_PREFIX || type || normalize(value))`, exactly as the circuit computes it.
- * This is the routing salt a payer uses to address an identity, and the value a proof's
- * `identityHash` output is compared against.
- */
-export declare function identityHash(type: IdentityType, value: string, domain?: string): `0x${string}`;
-export declare function toHex(bytes: Uint8Array): `0x${string}`;

package/dist/identity.js

@@ -1,61 +0,0 @@
-import { sha256 } from '@noble/hashes/sha256';
-/**
- * Identity types. The numeric value is the protocol's type id (it is what gets hashed), so it
- * must match circuit/src/identity.nr and never change.
- */
-export var IdentityType;
-(function (IdentityType) {
-    IdentityType[IdentityType["Email"] = 0] = "Email";
-    IdentityType[IdentityType["Phone"] = 1] = "Phone";
-    IdentityType[IdentityType["Google"] = 2] = "Google";
-    IdentityType[IdentityType["Twitter"] = 3] = "Twitter";
-    /** Alias of `Twitter`: the platform's current name. Same id, same addresses. */
-    IdentityType[IdentityType["X"] = 3] = "X";
-    IdentityType[IdentityType["Discord"] = 4] = "Discord";
-    IdentityType[IdentityType["Github"] = 5] = "Github";
-    IdentityType[IdentityType["Linkedin"] = 6] = "Linkedin";
-    IdentityType[IdentityType["Apple"] = 7] = "Apple";
-    IdentityType[IdentityType["Telegram"] = 8] = "Telegram";
-    IdentityType[IdentityType["Tiktok"] = 9] = "Tiktok";
-    IdentityType[IdentityType["Instagram"] = 10] = "Instagram";
-    IdentityType[IdentityType["Farcaster"] = 11] = "Farcaster";
-    IdentityType[IdentityType["Wallet"] = 12] = "Wallet";
-})(IdentityType || (IdentityType = {}));
-/** Domain-separation prefix baked into the circuit's identity hash. */
-export const HASH_PREFIX = 'p2id.identity.v1';
-/** Types whose value is ASCII-lowercased before hashing: everything except phone numbers and
- *  wallet addresses (matches CASE_INSENSITIVE in circuit/src/identity.nr). */
-export function isCaseInsensitive(type) {
-    return type !== IdentityType.Wallet && type !== IdentityType.Phone;
-}
-/**
- * Apply the circuit's normalisation to an identity value: ASCII-lowercase for case-insensitive
- * types and for EVM (`0x…`) wallet addresses; base58 (Solana) addresses are left untouched.
- */
-export function normalizeIdentityValue(type, value) {
-    const lower = isCaseInsensitive(type) || (type === IdentityType.Wallet && value.startsWith('0x'));
-    return lower ? value.replace(/[A-Z]/g, (c) => c.toLowerCase()) : value;
-}
-/**
- * `sha256(HASH_PREFIX || type || normalize(value))`, exactly as the circuit computes it.
- * This is the routing salt a payer uses to address an identity, and the value a proof's
- * `identityHash` output is compared against.
- */
-export function identityHash(type, value, domain = HASH_PREFIX) {
-    const enc = new TextEncoder();
-    const prefix = enc.encode(domain);
-    const body = enc.encode(normalizeIdentityValue(type, value));
-    if (body.length < 1 || body.length > 128)
-        throw new Error('identity value must be 1..128 bytes');
-    const preimage = new Uint8Array(prefix.length + 1 + body.length);
-    preimage.set(prefix, 0);
-    preimage[prefix.length] = type;
-    preimage.set(body, prefix.length + 1);
-    return toHex(sha256(preimage));
-}
-export function toHex(bytes) {
-    let s = '';
-    for (const b of bytes)
-        s += b.toString(16).padStart(2, '0');
-    return `0x${s}`;
-}

package/dist/identityNames.d.ts

@@ -1,43 +0,0 @@
-import { IdentityType } from './identity.js';
-/** P2ID type names (the URI names in P2ID.md). */
-export declare const P2ID_TYPE_NAMES: {
-    readonly email: IdentityType.Email;
-    readonly phone: IdentityType.Phone;
-    readonly google: IdentityType.Google;
-    readonly x: IdentityType.Twitter;
-    readonly discord: IdentityType.Discord;
-    readonly github: IdentityType.Github;
-    readonly linkedin: IdentityType.Linkedin;
-    readonly apple: IdentityType.Apple;
-    readonly telegram: IdentityType.Telegram;
-    readonly tiktok: IdentityType.Tiktok;
-    readonly instagram: IdentityType.Instagram;
-    readonly farcaster: IdentityType.Farcaster;
-    readonly wallet: IdentityType.Wallet;
-};
-/**
- * Every accepted name: the canonical P2ID names plus `twitter` (an alias of `x`). P2ID core is
- * agnostic of any identity provider — it does not know Privy (or any other verifier's) account
- * types. Callers map their provider's account types to these names themselves.
- */
-export declare const IDENTITY_TYPE_BY_NAME: {
-    readonly twitter: IdentityType.Twitter;
-    readonly email: IdentityType.Email;
-    readonly phone: IdentityType.Phone;
-    readonly google: IdentityType.Google;
-    readonly x: IdentityType.Twitter;
-    readonly discord: IdentityType.Discord;
-    readonly github: IdentityType.Github;
-    readonly linkedin: IdentityType.Linkedin;
-    readonly apple: IdentityType.Apple;
-    readonly telegram: IdentityType.Telegram;
-    readonly tiktok: IdentityType.Tiktok;
-    readonly instagram: IdentityType.Instagram;
-    readonly farcaster: IdentityType.Farcaster;
-    readonly wallet: IdentityType.Wallet;
-};
-export type P2IDTypeName = keyof typeof P2ID_TYPE_NAMES;
-/** The P2ID name of a type, e.g. IdentityType.Twitter -> "x". */
-export declare function identityTypeName(type: IdentityType): P2IDTypeName;
-export type IdentityTypeName = keyof typeof IDENTITY_TYPE_BY_NAME;
-export declare function resolveIdentityType(t: IdentityType | IdentityTypeName): IdentityType;

package/dist/identityNames.js

@@ -1,44 +0,0 @@
-import { IdentityType } from './identity.js';
-/** P2ID type names (the URI names in P2ID.md). */
-export const P2ID_TYPE_NAMES = {
-    email: IdentityType.Email,
-    phone: IdentityType.Phone,
-    google: IdentityType.Google,
-    x: IdentityType.X,
-    discord: IdentityType.Discord,
-    github: IdentityType.Github,
-    linkedin: IdentityType.Linkedin,
-    apple: IdentityType.Apple,
-    telegram: IdentityType.Telegram,
-    tiktok: IdentityType.Tiktok,
-    instagram: IdentityType.Instagram,
-    farcaster: IdentityType.Farcaster,
-    wallet: IdentityType.Wallet,
-};
-/**
- * Every accepted name: the canonical P2ID names plus `twitter` (an alias of `x`). P2ID core is
- * agnostic of any identity provider — it does not know Privy (or any other verifier's) account
- * types. Callers map their provider's account types to these names themselves.
- */
-export const IDENTITY_TYPE_BY_NAME = {
-    ...P2ID_TYPE_NAMES,
-    twitter: IdentityType.Twitter,
-};
-/** The P2ID name of a type, e.g. IdentityType.Twitter -> "x". */
-export function identityTypeName(type) {
-    const entry = Object.entries(P2ID_TYPE_NAMES).find(([, id]) => id === type);
-    if (!entry)
-        throw new Error(`unknown identity type id ${type}`);
-    return entry[0];
-}
-export function resolveIdentityType(t) {
-    if (typeof t === 'number') {
-        if (!Object.values(IDENTITY_TYPE_BY_NAME).includes(t))
-            throw new Error(`unknown identity type id ${t}`);
-        return t;
-    }
-    const id = IDENTITY_TYPE_BY_NAME[t];
-    if (id === undefined)
-        throw new Error(`unknown identity type "${t}"`);
-    return id;
-}

package/dist/index.d.ts

@@ -1,5 +0,0 @@
-export { IdentityType, HASH_PREFIX, isCaseInsensitive, normalizeIdentityValue, toHex } from './identity.js';
-export { IDENTITY_TYPE_BY_NAME, P2ID_TYPE_NAMES, identityTypeName, resolveIdentityType } from './identityNames.js';
-export type { IdentityTypeName, P2IDTypeName } from './identityNames.js';
-export { identityHash, p2idAddress, p2idAddressForHash, p2idScheme, checksumAddress, P2ID_SCHEME, P2ID_SCHEMES } from './p2id.js';
-export type { P2IDAddressInput, P2IDEnvironment, P2IDScheme, P2IDSchemeName } from './p2id.js';

package/dist/index.js

@@ -1,5 +0,0 @@
-// P2ID protocol core: no proof verification here, and no heavy dependencies, so it is safe in
-// browsers. Verifying attestations lives in @pvium/p2id-verifier.
-export { IdentityType, HASH_PREFIX, isCaseInsensitive, normalizeIdentityValue, toHex } from './identity.js';
-export { IDENTITY_TYPE_BY_NAME, P2ID_TYPE_NAMES, identityTypeName, resolveIdentityType } from './identityNames.js';
-export { identityHash, p2idAddress, p2idAddressForHash, p2idScheme, checksumAddress, P2ID_SCHEME, P2ID_SCHEMES } from './p2id.js';

package/dist/p2id.d.ts

@@ -1,54 +0,0 @@
-import { IdentityType } from './identity.js';
-import { type IdentityTypeName } from './identityNames.js';
-import { P2ID_SCHEME, P2ID_SCHEMES, type P2IDScheme, type P2IDSchemeName } from './p2idConstants.js';
-export { P2ID_SCHEME, P2ID_SCHEMES };
-export type { P2IDScheme, P2IDSchemeName };
-/** A Pvium environment: `production` (mainnets) or `sandbox` (testnets). Each has its own factory. */
-export type P2IDEnvironment = 'production' | 'sandbox';
-/**
- * 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 declare function p2idScheme(name?: P2IDSchemeName | string): P2IDScheme;
-/** The identity commitment: the CREATE2 salt of the identity's vault and the value proofs bind. */
-export declare function identityHash(type: IdentityType | IdentityTypeName, value: string, scheme?: P2IDSchemeName | string): `0x${string}`;
-export interface P2IDAddressInput {
-    identityType: IdentityType | IdentityTypeName;
-    /** The identity as the user linked it, e.g. "you@example.com". Case does not matter. */
-    identityValue: string;
-    /** Address scheme; defaults to the current one (`P2ID_SCHEME`). Pass an older one to find an address issued under it. */
-    scheme?: P2IDSchemeName | string;
-    /** Pvium environment; defaults to `production`. Use `sandbox` on testnets. */
-    environment?: P2IDEnvironment;
-    /** Derive against another factory than the scheme's (e.g. a test deployment). */
-    factory?: `0x${string}`;
-}
-/** The P2ID address for an identity: where to pay it, on any EVM chain, deployed or not. Checksummed. */
-export declare function p2idAddress(input: P2IDAddressInput): `0x${string}`;
-/** Same, from an identity hash you already have (e.g. from an attestation's claim). */
-export declare function p2idAddressForHash(identityHash: `0x${string}`, opts?: {
-    scheme?: P2IDSchemeName | string;
-    environment?: P2IDEnvironment;
-    factory?: `0x${string}`;
-}): `0x${string}`;
-/** EIP-55 checksum. */
-export declare function checksumAddress(address: `0x${string}`): `0x${string}`;

package/dist/p2id.js

@@ -1,82 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,21 +0,0 @@
-/** 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';