voltaire-effect 0.2.23 → 0.2.24

package/src/primitives/Signature/getR.ts

@@ -0,0 +1,24 @@
+/**
+ * @fileoverview Gets R component from Signature.
+ * @module Signature/getR
+ * @since 0.0.1
+ */
+import { Signature, type SignatureType } from "@tevm/voltaire/Signature";
+
+/**
+ * Gets the R component of a signature as a 32-byte Uint8Array.
+ *
+ * @param signature - The SignatureType to extract R from
+ * @returns 32-byte Uint8Array containing the R value
+ *
+ * @example
+ * ```typescript
+ * import * as Signature from 'voltaire-effect/primitives/Signature'
+ *
+ * const r = Signature.getR(sig)
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const getR = (signature: SignatureType): Uint8Array =>
+	Signature.getR(signature);

package/src/primitives/Signature/getS.ts

@@ -0,0 +1,24 @@
+/**
+ * @fileoverview Gets S component from Signature.
+ * @module Signature/getS
+ * @since 0.0.1
+ */
+import { Signature, type SignatureType } from "@tevm/voltaire/Signature";
+
+/**
+ * Gets the S component of a signature as a 32-byte Uint8Array.
+ *
+ * @param signature - The SignatureType to extract S from
+ * @returns 32-byte Uint8Array containing the S value
+ *
+ * @example
+ * ```typescript
+ * import * as Signature from 'voltaire-effect/primitives/Signature'
+ *
+ * const s = Signature.getS(sig)
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const getS = (signature: SignatureType): Uint8Array =>
+	Signature.getS(signature);

package/src/primitives/Signature/getV.ts

@@ -0,0 +1,24 @@
+/**
+ * @fileoverview Gets V component from Signature.
+ * @module Signature/getV
+ * @since 0.0.1
+ */
+import { Signature, type SignatureType } from "@tevm/voltaire/Signature";
+
+/**
+ * Gets the V (recovery) component of a signature.
+ *
+ * @param signature - The SignatureType to extract V from
+ * @returns Recovery value (27, 28, or chainId-derived) or undefined if not present
+ *
+ * @example
+ * ```typescript
+ * import * as Signature from 'voltaire-effect/primitives/Signature'
+ *
+ * const v = Signature.getV(sig) // 27, 28, or undefined
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const getV = (signature: SignatureType): number | undefined =>
+	Signature.getV(signature);

package/src/primitives/Signature/index.ts

@@ -48,43 +48,93 @@
  * Signature.isSignature(value) // alias for is
  * Signature.isCanonical(sig)   // boolean - check if s <= n/2
  * Signature.getAlgorithm(sig)  // 'secp256k1' | 'p256' | 'ed25519'
+ * Signature.getR(sig)          // Uint8Array - 32-byte R component
+ * Signature.getS(sig)          // Uint8Array - 32-byte S component
+ * Signature.getV(sig)          // number | undefined - recovery value
  * Signature.normalize(sig)     // SignatureType - normalize to canonical form
  * Signature.toBytes(sig)       // Uint8Array - raw bytes
  * Signature.toCompact(sig)     // Uint8Array - EIP-2098 compact
+ * Signature.toDER(sig)         // Uint8Array - DER encoding
  * Signature.toHex(sig)         // string - hex encoding
+ * Signature.toRpc(sig)         // { r, s, yParity, v } - RPC format
+ * Signature.toTuple(sig)       // [yParity, r, s] - tuple format
+ * Signature.verify(sig, hash, pubkey) // boolean - verify signature
  * ```
  *
- * ## Effect-wrapped Functions (fallible operations)
+ * ## Effect-wrapped Functions (fallible parsing)
  *
  * ```typescript
  * import * as Effect from 'effect/Effect'
  *
- * Signature.getR(sig)          // Effect<HashType, InvalidAlgorithmError>
- * Signature.getS(sig)          // Effect<HashType, InvalidAlgorithmError>
- * Signature.getV(sig)          // Effect<number | undefined, InvalidAlgorithmError>
- * Signature.verify(sig, hash, pubkey) // Effect<boolean, InvalidAlgorithmError>
+ * Signature.from(input)        // Effect<SignatureType, Error>
+ * Signature.fromHex(hex)       // Effect<SignatureType, Error>
+ * Signature.fromBytes(bytes)   // Effect<SignatureType, Error>
+ * Signature.fromCompact(bytes) // Effect<SignatureType, Error>
+ * Signature.fromDER(bytes)     // Effect<SignatureType, Error>
+ * Signature.fromRpc(rpc)       // Effect<SignatureType, Error>
+ * Signature.fromTuple(tuple)   // Effect<SignatureType, Error>
+ * ```
+ *
+ * ## Constructor Functions (pure, for known-valid inputs)
+ *
+ * ```typescript
+ * Signature.fromSecp256k1(r, s, v)  // SignatureType
+ * Signature.fromP256(r, s)          // SignatureType
+ * Signature.fromEd25519(bytes)      // SignatureType
  * ```
  *
  * @since 0.1.0
  */
 
+// Schemas
 export { Bytes } from "./Bytes.js";
 export { Compact } from "./Compact.js";
 export { DER } from "./DER.js";
-export { getAlgorithm } from "./getAlgorithm.js";
 export { Hex } from "./Hex.js";
+export { Rpc } from "./Rpc.js";
+export { SignatureTypeSchema } from "./SignatureSchema.js";
+export { Tuple } from "./Tuple.js";
+
 // Pure functions (infallible)
+export { equals } from "./equals.js";
+export { getAlgorithm } from "./getAlgorithm.js";
+export { getR } from "./getR.js";
+export { getS } from "./getS.js";
+export { getV } from "./getV.js";
 export { is } from "./is.js";
 export { isCanonical } from "./isCanonical.js";
 export { isSignature } from "./isSignature.js";
 export { normalize } from "./normalize.js";
-export { Rpc } from "./Rpc.js";
-// Schemas
-export { SignatureTypeSchema } from "./SignatureSchema.js";
-export { Tuple } from "./Tuple.js";
+export { toBytes } from "./toBytes.js";
 export { toCompact } from "./toCompact.js";
+export { toDER } from "./toDER.js";
+export { toHex } from "./toHex.js";
+export { toRpc, type RpcSignature } from "./toRpc.js";
+export { toTuple, type SignatureTuple } from "./toTuple.js";
+export { verify } from "./verify.js";
+
+// Effect-wrapped functions (fallible parsing)
+export { from } from "./from.js";
+export { fromBytes } from "./fromBytes.js";
+export { fromCompact } from "./fromCompact.js";
+export { fromDER } from "./fromDER.js";
+export { fromHex } from "./fromHex.js";
+export { fromRpc } from "./fromRpc.js";
+export { fromTuple } from "./fromTuple.js";
 
-// Effect-wrapped functions (fallible operations on valid signatures)
+// Constructor functions (pure, for known-valid inputs)
+export { fromEd25519 } from "./fromEd25519.js";
+export { fromP256 } from "./fromP256.js";
+export { fromSecp256k1 } from "./fromSecp256k1.js";
+
+// Re-export errors from voltaire
+export {
+	InvalidAlgorithmError,
+	InvalidDERError,
+	InvalidSignatureFormatError,
+	InvalidSignatureLengthError,
+	NonCanonicalSignatureError,
+} from "@tevm/voltaire/Signature";
 
 // Re-export types from voltaire
 export type {

package/src/primitives/Signature/toDER.ts

@@ -0,0 +1,24 @@
+/**
+ * @fileoverview Converts Signature to DER format.
+ * @module Signature/toDER
+ * @since 0.0.1
+ */
+import { Signature, type SignatureType } from "@tevm/voltaire/Signature";
+
+/**
+ * Converts a Signature to DER-encoded bytes.
+ *
+ * @param signature - The SignatureType to convert
+ * @returns DER-encoded signature bytes
+ *
+ * @example
+ * ```typescript
+ * import * as Signature from 'voltaire-effect/primitives/Signature'
+ *
+ * const der = Signature.toDER(sig)
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const toDER = (signature: SignatureType): Uint8Array =>
+	Signature.toDER(signature);

package/src/primitives/Signature/toHex.ts

@@ -0,0 +1,24 @@
+/**
+ * @fileoverview Converts Signature to hex string.
+ * @module Signature/toHex
+ * @since 0.0.1
+ */
+import { Signature, type SignatureType } from "@tevm/voltaire/Signature";
+
+/**
+ * Converts a Signature to a hex string with 0x prefix.
+ *
+ * @param signature - The SignatureType to convert
+ * @returns Hex string (130 chars for secp256k1 with v, 128 chars otherwise)
+ *
+ * @example
+ * ```typescript
+ * import * as Signature from 'voltaire-effect/primitives/Signature'
+ *
+ * const hex = Signature.toHex(sig) // "0x..."
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const toHex = (signature: SignatureType): string =>
+	Signature.toHex(signature);

package/src/primitives/Signature/toRpc.ts

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview Converts Signature to RPC format.
+ * @module Signature/toRpc
+ * @since 0.0.1
+ */
+import { Signature, type SignatureType } from "@tevm/voltaire/Signature";
+
+/**
+ * RPC signature format with r, s, and optional yParity/v fields.
+ */
+export type RpcSignature = {
+	r: string;
+	s: string;
+	yParity?: string;
+	v?: string;
+};
+
+/**
+ * Converts a Signature to Ethereum RPC format.
+ *
+ * @param signature - The SignatureType to convert
+ * @returns RPC-formatted signature object with r, s, yParity, and v
+ *
+ * @example
+ * ```typescript
+ * import * as Signature from 'voltaire-effect/primitives/Signature'
+ *
+ * const rpc = Signature.toRpc(sig)
+ * // { r: "0x...", s: "0x...", yParity: "0x0", v: "0x1b" }
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const toRpc = (signature: SignatureType): RpcSignature =>
+	Signature.toRpc(signature);

package/src/primitives/Signature/toTuple.ts

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Converts Signature to tuple format.
+ * @module Signature/toTuple
+ * @since 0.0.1
+ */
+import { Signature, type SignatureType } from "@tevm/voltaire/Signature";
+
+/**
+ * Tuple signature format: [yParity, r, s].
+ */
+export type SignatureTuple = readonly [number, Uint8Array, Uint8Array];
+
+/**
+ * Converts a Signature to tuple format [yParity, r, s].
+ *
+ * @param signature - The SignatureType to convert
+ * @returns Tuple of [yParity (0 or 1), r (32 bytes), s (32 bytes)]
+ *
+ * @example
+ * ```typescript
+ * import * as Signature from 'voltaire-effect/primitives/Signature'
+ *
+ * const [yParity, r, s] = Signature.toTuple(sig)
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const toTuple = (signature: SignatureType): SignatureTuple =>
+	Signature.toTuple(signature);

package/src/primitives/Signature/verify.ts

@@ -0,0 +1,31 @@
+/**
+ * @fileoverview Verifies a Signature against a message hash and public key.
+ * @module Signature/verify
+ * @since 0.0.1
+ */
+import type { HashType } from "@tevm/voltaire/Hash";
+import type { PublicKeyType } from "@tevm/voltaire/PublicKey";
+import { Signature, type SignatureType } from "@tevm/voltaire/Signature";
+
+/**
+ * Verifies a signature against a message hash and public key.
+ *
+ * @param signature - The signature to verify
+ * @param messageHash - The 32-byte hash of the signed message
+ * @param publicKey - The public key to verify against
+ * @returns True if signature is valid, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import * as Signature from 'voltaire-effect/primitives/Signature'
+ *
+ * const isValid = Signature.verify(sig, messageHash, publicKey)
+ * ```
+ *
+ * @since 0.0.1
+ */
+export const verify = (
+	signature: SignatureType,
+	messageHash: HashType,
+	publicKey: PublicKeyType,
+): boolean => Signature.verify(signature, messageHash, publicKey);

package/src/primitives/Siwe/create.ts

@@ -0,0 +1,56 @@
+/**
+ * @module create
+ * @description Effect-wrapped SIWE constructors
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Siwe } from "@tevm/voltaire";
+import type { SiweMessageType } from "./String.js";
+import type { AddressType } from "@tevm/voltaire/Address";
+
+interface CreateParams<
+  TDomain extends string = string,
+  TAddress extends AddressType = AddressType,
+  TUri extends string = string,
+  TChainId extends number = number,
+> {
+  domain: TDomain;
+  address: TAddress | string;
+  uri: TUri;
+  chainId: TChainId;
+  statement?: string;
+  expirationTime?: string;
+  notBefore?: string;
+  requestId?: string;
+  resources?: string[];
+  nonce?: string;
+  issuedAt?: string;
+}
+
+/**
+ * Create SIWE message from parameters
+ *
+ * @param params - SIWE message parameters
+ * @returns Effect yielding SiweMessageType
+ * @example
+ * ```typescript
+ * const message = await Effect.runPromise(Siwe.create({
+ *   domain: 'example.com',
+ *   address: '0x...',
+ *   uri: 'https://example.com',
+ *   chainId: 1,
+ * }))
+ * ```
+ */
+export const create = <
+  TDomain extends string = string,
+  TAddress extends AddressType = AddressType,
+  TUri extends string = string,
+  TChainId extends number = number,
+>(
+  params: CreateParams<TDomain, TAddress, TUri, TChainId>,
+): Effect.Effect<SiweMessageType, Error> =>
+  Effect.try({
+    try: () => Siwe.create(params as Parameters<typeof Siwe.create>[0]),
+    catch: (e) => e as Error,
+  });

package/src/primitives/Siwe/hash.ts

@@ -0,0 +1,27 @@
+/**
+ * @module hash
+ * @description Effect-wrapped SIWE hash operations
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Siwe } from "@tevm/voltaire";
+import type { SiweMessageType } from "./String.js";
+
+/**
+ * Get message hash for signing
+ *
+ * @param message - SIWE message to hash
+ * @returns Effect yielding 32-byte hash
+ * @example
+ * ```typescript
+ * const hash = await Effect.runPromise(Siwe.getMessageHash(message))
+ * ```
+ */
+export const getMessageHash = (message: SiweMessageType): Effect.Effect<Uint8Array, Error> =>
+  Effect.try({
+    try: () => Siwe.getMessageHash(message),
+    catch: (e) => e as Error,
+  });
+
+// Re-export factory for advanced usage
+export { GetMessageHash, Verify, VerifyMessage } from "@tevm/voltaire/Siwe";

package/src/primitives/Siwe/index.ts

@@ -1,6 +1,6 @@
 /**
  * @module Siwe
- * @description Effect Schemas for Sign-In with Ethereum (SIWE) messages (EIP-4361).
+ * @description Effect Schemas and functions for Sign-In with Ethereum (SIWE) messages (EIP-4361).
  *
  * ## Type Declarations
  *
@@ -19,37 +19,73 @@
  * | `Siwe.String` | SIWE message string | SiweMessageType |
  * | `Siwe.MessageStruct` | SIWE message object | validated object |
  *
- * ## Usage
+ * ## Constructors (Effect-wrapped)
  *
  * ```typescript
- * import * as Siwe from 'voltaire-effect/primitives/Siwe'
- * import * as S from 'effect/Schema'
+ * Siwe.create(params) // Effect<SiweMessageType, Error>
+ * Siwe.parse(text)    // Effect<SiweMessageType, Error>
+ * ```
  *
- * // Parse from string
- * const message = S.decodeSync(Siwe.String)(`example.com wants you to sign in...`)
+ * ## Verification (Effect-wrapped)
  *
- * // Format to string
- * const text = S.encodeSync(Siwe.String)(message)
+ * ```typescript
+ * Siwe.verify(message, signature)       // Effect<boolean, Error>
+ * Siwe.verifyMessage(msg, sig, opts)    // Effect<ValidationResult, Error>
+ * Siwe.getMessageHash(message)          // Effect<Uint8Array, Error>
  * ```
  *
  * ## Pure Functions
  *
  * ```typescript
- * Siwe.format(message)  // string
- * Siwe.validate(message, { now })  // ValidationResult
- * Siwe.generateNonce(length)  // string
+ * Siwe.format(message)            // string
+ * Siwe.validate(message, opts)    // ValidationResult
+ * Siwe.generateNonce(length)      // string
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import * as Siwe from 'voltaire-effect/primitives/Siwe'
+ * import { Effect } from 'effect'
+ *
+ * const program = Effect.gen(function* () {
+ *   const message = yield* Siwe.create({
+ *     domain: 'example.com',
+ *     address: '0x...',
+ *     uri: 'https://example.com',
+ *     chainId: 1,
+ *   })
+ *   const text = Siwe.format(message)
+ *   const hash = yield* Siwe.getMessageHash(message)
+ *   return { message, text, hash }
+ * })
  * ```
  *
  * @since 0.1.0
  */
+
+// Types
+export type { SiweMessageType, ValidationResult } from "./String.js";
+export type { Signature } from "@tevm/voltaire/Siwe";
+
+// Errors (re-export from voltaire)
 export {
-	format,
-	generateNonce,
-	MessageStruct,
-	Schema,
-	SiweMessageSchema,
-	type SiweMessageType,
-	String,
-	type ValidationResult,
-	validate,
-} from "./String.js";
+  InvalidFieldError,
+  InvalidNonceLengthError,
+  InvalidSiweMessageError,
+  MissingFieldError,
+  SiweParseError,
+} from "@tevm/voltaire/Siwe";
+
+// Schemas
+export { MessageStruct, Schema, SiweMessageSchema, String } from "./String.js";
+
+// Constructors (Effect-wrapped)
+export { create } from "./create.js";
+export { parse } from "./parse.js";
+
+// Verification (Effect-wrapped)
+export { verify, verifyMessage } from "./verify.js";
+export { getMessageHash, GetMessageHash, Verify, VerifyMessage } from "./hash.js";
+
+// Pure Functions (re-export)
+export { format, generateNonce, validate } from "./String.js";

package/src/primitives/Siwe/parse.ts

@@ -0,0 +1,24 @@
+/**
+ * @module parse
+ * @description Effect-wrapped SIWE parsing
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Siwe } from "@tevm/voltaire";
+import type { SiweMessageType } from "./String.js";
+
+/**
+ * Parse SIWE message from formatted string
+ *
+ * @param text - Formatted SIWE message string
+ * @returns Effect yielding SiweMessageType
+ * @example
+ * ```typescript
+ * const message = await Effect.runPromise(Siwe.parse(`example.com wants you to sign in...`))
+ * ```
+ */
+export const parse = (text: string): Effect.Effect<SiweMessageType, Error> =>
+  Effect.try({
+    try: () => Siwe.parse(text),
+    catch: (e) => e as Error,
+  });

package/src/primitives/Siwe/verify.ts

@@ -0,0 +1,47 @@
+/**
+ * @module verify
+ * @description Effect-wrapped SIWE verification
+ * @since 0.1.0
+ */
+import { Effect } from "effect";
+import { Siwe } from "@tevm/voltaire";
+import type { SiweMessageType } from "./String.js";
+import type { Signature as SiweSignature } from "@tevm/voltaire/Siwe";
+
+/**
+ * Verify SIWE message signature
+ *
+ * @param message - SIWE message to verify
+ * @param signature - Signature to verify against (65 bytes: r(32) + s(32) + v(1))
+ * @returns Effect yielding boolean
+ * @example
+ * ```typescript
+ * const isValid = await Effect.runPromise(Siwe.verify(message, signature))
+ * ```
+ */
+export const verify = (
+  message: SiweMessageType,
+  signature: SiweSignature,
+): Effect.Effect<boolean, Error> =>
+  Effect.try({
+    try: () => Siwe.verify(message, signature),
+    catch: (e) => e as Error,
+  });
+
+/**
+ * Verify SIWE message with full validation
+ *
+ * @param message - SIWE message to verify
+ * @param signature - Signature to verify against
+ * @param options - Verification options
+ * @returns Effect yielding ValidationResult
+ */
+export const verifyMessage = (
+  message: SiweMessageType,
+  signature: SiweSignature,
+  options?: { now?: Date },
+): Effect.Effect<ReturnType<typeof Siwe.verifyMessage>, Error> =>
+  Effect.try({
+    try: () => Siwe.verifyMessage(message, signature, options),
+    catch: (e) => e as Error,
+  });