@hardkas/l2 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Javier Rodriguez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,177 @@
+import { IgraTxPlanArtifact } from '@hardkas/artifacts';
+
+type L2NetworkType = "evm-based-rollup";
+type L2BridgePhase = "pre-zk" | "mpc" | "zk" | "unknown";
+type L2RiskProfile = "high" | "medium" | "low" | "unknown";
+interface L2SecurityAssumptions {
+    readonly bridgePhase: L2BridgePhase;
+    readonly trustlessExit: boolean;
+    readonly custodyModel: string;
+    readonly riskProfile: L2RiskProfile;
+    readonly notes: readonly string[];
+}
+interface L2NetworkProfile {
+    readonly schema: "hardkas.l2Profile.v1";
+    readonly hardkasVersion: string;
+    readonly name: string;
+    readonly displayName: string;
+    readonly type: L2NetworkType;
+    readonly settlementLayer: "kaspa";
+    readonly executionLayer: "evm";
+    readonly gasToken: string;
+    readonly nativeTokenDecimals?: number;
+    readonly chainId?: number;
+    readonly rpcUrl?: string;
+    readonly explorerUrl?: string;
+    readonly security: L2SecurityAssumptions;
+}
+declare const BUILTIN_L2_PROFILES: readonly L2NetworkProfile[];
+
+declare function getBuiltInL2Profiles(): readonly L2NetworkProfile[];
+declare function listL2Profiles(): readonly L2NetworkProfile[];
+declare function getL2Profile(name: string): L2NetworkProfile | null;
+declare function validateL2Profile(profile: any): {
+    ok: boolean;
+    errors: string[];
+};
+declare function assertValidL2Profile(profile: any): L2NetworkProfile;
+
+interface EvmJsonRpcClientOptions {
+    readonly url: string;
+    readonly timeoutMs?: number;
+    readonly fetcher?: typeof fetch;
+}
+interface EvmCallRequest {
+    readonly from?: string;
+    readonly to?: string;
+    readonly gas?: string;
+    readonly gasPrice?: string;
+    readonly value?: string;
+    readonly data?: string;
+}
+declare class EvmJsonRpcClient {
+    private readonly url;
+    private readonly timeoutMs;
+    private readonly fetcher;
+    constructor(options: EvmJsonRpcClientOptions);
+    callRpc<T>(method: string, params?: unknown[]): Promise<T>;
+    getChainId(): Promise<number>;
+    getBlockNumber(): Promise<bigint>;
+    getGasPriceWei(): Promise<bigint>;
+    getBalanceWei(address: string, blockTag?: "latest" | "pending"): Promise<bigint>;
+    getTransactionCount(address: string, blockTag?: "latest" | "pending"): Promise<bigint>;
+    call(request: EvmCallRequest, blockTag?: "latest" | "pending"): Promise<string>;
+    estimateGas(request: EvmCallRequest, blockTag?: "latest" | "pending"): Promise<bigint>;
+    sendRawTransaction(rawTransaction: string): Promise<string>;
+    getTransactionReceipt(txHash: string): Promise<any | null>;
+    private validateTxHash;
+    private validateCallRequest;
+    private validateAddress;
+    private validateHexData;
+    private validateHexQuantity;
+}
+
+interface EvmRpcHealthResult {
+    readonly url: string;
+    readonly ready: boolean;
+    readonly checkedAt: string;
+    readonly latencyMs?: number;
+    readonly chainId?: number;
+    readonly blockNumber?: bigint;
+    readonly gasPriceWei?: bigint;
+    readonly error?: string;
+}
+declare function checkEvmRpcHealth(options: EvmJsonRpcClientOptions): Promise<EvmRpcHealthResult>;
+declare function waitForEvmRpcReady(options: EvmJsonRpcClientOptions & {
+    readonly intervalMs?: number;
+    readonly maxWaitMs?: number;
+}): Promise<EvmRpcHealthResult>;
+
+declare function formatWeiAsEtherLike(valueWei: bigint, symbol: string, decimals?: number): string;
+declare function toHexQuantity(value: bigint | string | number): string;
+
+interface IgraTxSigningInput {
+    readonly plan: IgraTxPlanArtifact;
+    readonly account?: {
+        readonly name?: string;
+        readonly address: string;
+        readonly privateKey?: string;
+    };
+}
+interface IgraTxSigningResult {
+    readonly rawTransaction: string;
+    readonly txHash?: string;
+}
+interface IgraTxSigner {
+    sign(input: IgraTxSigningInput): Promise<IgraTxSigningResult>;
+}
+declare class UnsupportedIgraTxSigner implements IgraTxSigner {
+    sign(): Promise<IgraTxSigningResult>;
+}
+
+interface ViemIgraTxSignerOptions {
+    /**
+     * Optional custom loader for viem main package.
+     * Useful for testing without real viem dependency.
+     */
+    readonly viemLoader?: () => Promise<any>;
+    /**
+     * Optional custom loader for viem/accounts package.
+     */
+    readonly accountsLoader?: () => Promise<any>;
+}
+/**
+ * Real EVM-compatible signer adapter for Igra L2 transactions using viem.
+ */
+declare class ViemIgraTxSigner implements IgraTxSigner {
+    private readonly viemLoader;
+    private readonly accountsLoader;
+    constructor(options?: ViemIgraTxSignerOptions);
+    getAddress(): Promise<string>;
+    sign(input: IgraTxSigningInput): Promise<IgraTxSigningResult>;
+}
+
+interface EvmTransactionReceiptSummary {
+    txHash: string;
+    blockHash?: string;
+    blockNumber?: bigint | undefined;
+    from?: string;
+    to?: string | null | undefined;
+    gasUsed?: bigint | undefined;
+    effectiveGasPrice?: bigint | undefined;
+    status?: "success" | "reverted" | "unknown";
+    raw: any;
+}
+declare function normalizeEvmTransactionReceipt(raw: any): EvmTransactionReceiptSummary | null;
+
+interface L2BridgeAssumptions {
+    readonly schema: "hardkas.l2BridgeAssumptions.v1";
+    readonly hardkasVersion: string;
+    readonly l2Network: string;
+    readonly bridgePhase: L2BridgePhase;
+    readonly trustlessExit: boolean;
+    readonly custodyModel: string;
+    readonly validatorModel?: string;
+    readonly exitModel: string;
+    readonly riskProfile: L2RiskProfile;
+    readonly notes: readonly string[];
+    readonly updatedAt: string;
+}
+declare function getL2BridgeAssumptions(network: string): L2BridgeAssumptions | null;
+declare function listL2BridgeAssumptions(): readonly L2BridgeAssumptions[];
+declare function validateL2BridgeAssumptions(input: unknown): {
+    ok: boolean;
+    errors: string[];
+};
+declare function assertValidL2BridgeAssumptions(input: unknown): L2BridgeAssumptions;
+
+/**
+ * Encodes deployment bytecode and constructor arguments using viem.
+ *
+ * @param bytecode 0x-prefixed hex string
+ * @param constructorSignature e.g. "constructor(address,uint256)"
+ * @param args Array of argument strings from CLI
+ */
+declare function encodeConstructorArgs(bytecode: string, constructorSignature: string, args: string[]): string;
+
+export { BUILTIN_L2_PROFILES, type EvmCallRequest, EvmJsonRpcClient, type EvmJsonRpcClientOptions, type EvmRpcHealthResult, type EvmTransactionReceiptSummary, type IgraTxSigner, type IgraTxSigningInput, type IgraTxSigningResult, type L2BridgeAssumptions, type L2BridgePhase, type L2NetworkProfile, type L2NetworkType, type L2RiskProfile, type L2SecurityAssumptions, UnsupportedIgraTxSigner, ViemIgraTxSigner, type ViemIgraTxSignerOptions, assertValidL2BridgeAssumptions, assertValidL2Profile, checkEvmRpcHealth, encodeConstructorArgs, formatWeiAsEtherLike, getBuiltInL2Profiles, getL2BridgeAssumptions, getL2Profile, listL2BridgeAssumptions, listL2Profiles, normalizeEvmTransactionReceipt, toHexQuantity, validateL2BridgeAssumptions, validateL2Profile, waitForEvmRpcReady };

package/dist/index.js

@@ -0,0 +1,470 @@
+// src/profiles.ts
+import { HARDKAS_VERSION } from "@hardkas/artifacts";
+var BUILTIN_L2_PROFILES = [
+  {
+    schema: "hardkas.l2Profile.v1",
+    hardkasVersion: HARDKAS_VERSION,
+    name: "igra",
+    displayName: "Igra",
+    type: "evm-based-rollup",
+    settlementLayer: "kaspa",
+    executionLayer: "evm",
+    gasToken: "iKAS",
+    nativeTokenDecimals: 18,
+    security: {
+      bridgePhase: "pre-zk",
+      trustlessExit: false,
+      custodyModel: "Phase-dependent bridge custody; verify live Igra bridge phase before use.",
+      riskProfile: "high",
+      notes: [
+        "Kaspa L1 does not execute EVM.",
+        "Igra execution occurs on L2.",
+        "Kaspa L1 provides sequencing, data availability, state commitment anchoring and finality.",
+        "Bridge security is phase-dependent: pre-ZK -> MPC -> ZK.",
+        "Trustless exit exists only in the ZK phase."
+      ]
+    }
+  }
+];
+
+// src/registry.ts
+function getBuiltInL2Profiles() {
+  return BUILTIN_L2_PROFILES;
+}
+function listL2Profiles() {
+  return BUILTIN_L2_PROFILES;
+}
+function getL2Profile(name) {
+  return listL2Profiles().find((p) => p.name === name) || null;
+}
+function validateL2Profile(profile) {
+  const errors = [];
+  if (!profile || typeof profile !== "object") {
+    return { ok: false, errors: ["Profile must be an object"] };
+  }
+  if (profile.schema !== "hardkas.l2Profile.v1") {
+    errors.push(`Invalid schema: expected 'hardkas.l2Profile.v1', got '${profile.schema}'`);
+  }
+  if (typeof profile.hardkasVersion !== "string") {
+    errors.push("Missing or invalid hardkasVersion");
+  }
+  if (!profile.name || typeof profile.name !== "string") {
+    errors.push("Missing or invalid name");
+  }
+  if (profile.type !== "evm-based-rollup") {
+    errors.push(`Invalid type: expected 'evm-based-rollup', got '${profile.type}'`);
+  }
+  if (profile.settlementLayer !== "kaspa") {
+    errors.push(`Invalid settlementLayer: expected 'kaspa', got '${profile.settlementLayer}'`);
+  }
+  if (profile.executionLayer !== "evm") {
+    errors.push(`Invalid executionLayer: expected 'evm', got '${profile.executionLayer}'`);
+  }
+  if (!profile.gasToken || typeof profile.gasToken !== "string") {
+    errors.push("Missing or invalid gasToken");
+  }
+  if (profile.security) {
+    if (profile.security.bridgePhase === "zk") {
+    } else {
+      if (profile.security.trustlessExit === true) {
+        errors.push("Security invariant violation: trustlessExit must be false when bridgePhase is not 'zk'");
+      }
+    }
+    if (!Array.isArray(profile.security.notes) || profile.security.notes.length === 0) {
+      errors.push("Security notes must not be empty");
+    }
+  } else {
+    errors.push("Missing security assumptions");
+  }
+  return {
+    ok: errors.length === 0,
+    errors
+  };
+}
+function assertValidL2Profile(profile) {
+  const { ok, errors } = validateL2Profile(profile);
+  if (!ok) {
+    throw new Error(`Invalid L2 profile:
+${errors.map((e) => `  - ${e}`).join("\n")}`);
+  }
+  return profile;
+}
+
+// src/evm-rpc-client.ts
+var EvmJsonRpcClient = class {
+  url;
+  timeoutMs;
+  fetcher;
+  constructor(options) {
+    this.url = options.url;
+    this.timeoutMs = options.timeoutMs ?? 1e4;
+    this.fetcher = options.fetcher ?? globalThis.fetch;
+    if (!this.fetcher) {
+      throw new Error("No fetch implementation found. Ensure global fetch is available or provide a fetcher.");
+    }
+  }
+  async callRpc(method, params = []) {
+    const id = Math.floor(Math.random() * 1e6);
+    const body = JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      method,
+      params
+    });
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await this.fetcher(this.url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP error ${response.status}: ${response.statusText}`);
+      }
+      const json = await response.json();
+      if (json.error) {
+        throw new Error(`JSON-RPC error: ${json.error.message} (code: ${json.error.code})`);
+      }
+      return json.result;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async getChainId() {
+    const hex = await this.callRpc("eth_chainId");
+    return parseInt(hex, 16);
+  }
+  async getBlockNumber() {
+    const hex = await this.callRpc("eth_blockNumber");
+    return BigInt(hex);
+  }
+  async getGasPriceWei() {
+    const hex = await this.callRpc("eth_gasPrice");
+    return BigInt(hex);
+  }
+  async getBalanceWei(address, blockTag = "latest") {
+    this.validateAddress(address);
+    const hex = await this.callRpc("eth_getBalance", [address, blockTag]);
+    return BigInt(hex);
+  }
+  async getTransactionCount(address, blockTag = "latest") {
+    this.validateAddress(address);
+    const hex = await this.callRpc("eth_getTransactionCount", [address, blockTag]);
+    return BigInt(hex);
+  }
+  async call(request, blockTag = "latest") {
+    this.validateCallRequest(request);
+    return await this.callRpc("eth_call", [request, blockTag]);
+  }
+  async estimateGas(request, blockTag = "latest") {
+    this.validateCallRequest(request);
+    const hex = await this.callRpc("eth_estimateGas", [request, blockTag]);
+    return BigInt(hex);
+  }
+  async sendRawTransaction(rawTransaction) {
+    this.validateHexData(rawTransaction, "rawTransaction");
+    return await this.callRpc("eth_sendRawTransaction", [rawTransaction]);
+  }
+  async getTransactionReceipt(txHash) {
+    this.validateTxHash(txHash, "txHash");
+    return await this.callRpc("eth_getTransactionReceipt", [txHash]);
+  }
+  validateTxHash(txHash, fieldName) {
+    if (!/^0x[a-fA-F0-9]{64}$/.test(txHash)) {
+      throw new Error(`Invalid EVM ${fieldName}: must be a 0x-prefixed 64-character hex string.`);
+    }
+  }
+  validateCallRequest(request) {
+    if (request.to) this.validateAddress(request.to, "to");
+    if (request.from) this.validateAddress(request.from, "from");
+    if (request.data) this.validateHexData(request.data, "data");
+    if (request.value) this.validateHexQuantity(request.value, "value");
+    if (request.gas) this.validateHexQuantity(request.gas, "gas");
+    if (request.gasPrice) this.validateHexQuantity(request.gasPrice, "gasPrice");
+  }
+  validateAddress(address, fieldName = "address") {
+    if (!address || typeof address !== "string") {
+      throw new Error(`Invalid ${fieldName}: must be a non-empty string.`);
+    }
+    if (!/^0x[a-fA-F0-9]{40}$/.test(address)) {
+      throw new Error(`Invalid EVM ${fieldName}: must be a 0x-prefixed 40-character hex string.`);
+    }
+  }
+  validateHexData(data, fieldName) {
+    if (!/^0x([a-fA-F0-9]{2})*$/.test(data)) {
+      throw new Error(`Invalid hex ${fieldName}: must be a 0x-prefixed even-length hex string.`);
+    }
+  }
+  validateHexQuantity(qty, fieldName) {
+    if (!/^0x[0-9a-fA-F]+$/.test(qty)) {
+      throw new Error(`Invalid hex ${fieldName}: must be a 0x-prefixed hex quantity.`);
+    }
+  }
+};
+
+// src/evm-rpc-health.ts
+async function checkEvmRpcHealth(options) {
+  const start = Date.now();
+  const client = new EvmJsonRpcClient(options);
+  try {
+    const [chainId, blockNumber, gasPriceWei] = await Promise.all([
+      client.getChainId(),
+      client.getBlockNumber(),
+      client.getGasPriceWei()
+    ]);
+    const latencyMs = Date.now() - start;
+    return {
+      url: options.url,
+      ready: true,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      latencyMs,
+      chainId,
+      blockNumber,
+      gasPriceWei
+    };
+  } catch (e) {
+    return {
+      url: options.url,
+      ready: false,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      error: e instanceof Error ? e.message : String(e)
+    };
+  }
+}
+async function waitForEvmRpcReady(options) {
+  const interval = options.intervalMs ?? 1e3;
+  const maxWait = options.maxWaitMs ?? 6e4;
+  const start = Date.now();
+  while (true) {
+    const health = await checkEvmRpcHealth(options);
+    if (health.ready) return health;
+    if (Date.now() - start > maxWait) {
+      return health;
+    }
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+}
+
+// src/formatters.ts
+function formatWeiAsEtherLike(valueWei, symbol, decimals = 18) {
+  const s = valueWei.toString().padStart(decimals + 1, "0");
+  const pos = s.length - decimals;
+  const intPart = s.substring(0, pos);
+  const fracPart = s.substring(pos);
+  return `${intPart}.${fracPart} ${symbol}`;
+}
+function toHexQuantity(value) {
+  const big = BigInt(value);
+  return "0x" + big.toString(16);
+}
+
+// src/igra-signer.ts
+var UnsupportedIgraTxSigner = class {
+  async sign() {
+    throw new Error(
+      "Igra L2 transaction signing is not configured yet. Configure an EVM-compatible signer adapter in a future phase."
+    );
+  }
+};
+
+// src/viem-igra-signer.ts
+var ViemIgraTxSigner = class {
+  viemLoader;
+  accountsLoader;
+  constructor(options) {
+    this.viemLoader = options?.viemLoader || (() => import("viem"));
+    this.accountsLoader = options?.accountsLoader || (() => import("viem/accounts"));
+  }
+  async getAddress() {
+    throw new Error("ViemIgraTxSigner requires explicit account input for signing.");
+  }
+  async sign(input) {
+    const { plan, account } = input;
+    if (plan.schema !== "hardkas.igraTxPlan.v1") {
+      throw new Error(`Invalid plan schema: ${plan.schema}. Expected hardkas.igraTxPlan.v1`);
+    }
+    if (plan.status !== "built") {
+      throw new Error(`Plan must be in 'built' status to be signed. Current: ${plan.status}`);
+    }
+    if (!account) {
+      throw new Error("Signer requires an account input.");
+    }
+    if (!account.privateKey) {
+      throw new Error(`Account '${account.name}' has no private key available for signing.`);
+    }
+    if (!account.address || !account.address.startsWith("0x")) {
+      throw new Error("Igra L2 signing requires an EVM 0x account address.");
+    }
+    if (plan.request.from && plan.request.from.toLowerCase() !== account.address.toLowerCase()) {
+      throw new Error(`Account address '${account.address}' does not match plan 'from' address '${plan.request.from}'.`);
+    }
+    if (plan.request.gasLimit === void 0 || plan.request.gasLimit === null) {
+      throw new Error("Igra transaction plan is incomplete. Rebuild the plan with gas limit.");
+    }
+    if (plan.request.gasPriceWei === void 0 || plan.request.gasPriceWei === null) {
+      throw new Error("Igra transaction plan is incomplete. Rebuild the plan with gas price.");
+    }
+    if (plan.request.nonce === void 0 || plan.request.nonce === null) {
+      throw new Error("Igra transaction plan is incomplete. Rebuild the plan with nonce.");
+    }
+    let normalizedPk = account.privateKey;
+    if (!normalizedPk.startsWith("0x")) {
+      normalizedPk = `0x${normalizedPk}`;
+    }
+    const pkRegex = /^0x[a-fA-F0-9]{64}$/;
+    if (!pkRegex.test(normalizedPk)) {
+      throw new Error(`Invalid EVM private key format for account '${account.name}'.`);
+    }
+    let viem;
+    let accounts;
+    try {
+      viem = await this.viemLoader();
+      accounts = await this.accountsLoader();
+    } catch (e) {
+      throw new Error("EVM signing dependency (viem) is not installed. Install viem to enable Igra L2 signing.");
+    }
+    try {
+      const viemAccount = accounts.privateKeyToAccount(normalizedPk);
+      const signed = await viemAccount.signTransaction({
+        chainId: plan.chainId,
+        to: plan.request.to,
+        data: plan.request.data,
+        value: BigInt(plan.request.valueWei),
+        gas: BigInt(plan.request.gasLimit),
+        gasPrice: BigInt(plan.request.gasPriceWei),
+        nonce: Number(plan.request.nonce)
+      });
+      return {
+        rawTransaction: signed,
+        // Viem's signTransaction usually returns the raw serialized tx.
+        // We can use keccak256 to get the hash if viem provides it.
+        txHash: viem.keccak256 ? viem.keccak256(signed) : void 0
+      };
+    } catch (e) {
+      throw new Error(`Igra signing failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+};
+
+// src/evm-receipts.ts
+function normalizeEvmTransactionReceipt(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const txHash = raw.transactionHash;
+  if (!txHash || typeof txHash !== "string") return null;
+  let status = "unknown";
+  if (raw.status === "0x1") status = "success";
+  else if (raw.status === "0x0") status = "reverted";
+  return {
+    txHash,
+    blockHash: typeof raw.blockHash === "string" ? raw.blockHash : void 0,
+    blockNumber: raw.blockNumber ? BigInt(raw.blockNumber) : void 0,
+    from: typeof raw.from === "string" ? raw.from : void 0,
+    to: typeof raw.to === "string" || raw.to === null ? raw.to : void 0,
+    gasUsed: raw.gasUsed ? BigInt(raw.gasUsed) : void 0,
+    effectiveGasPrice: raw.effectiveGasPrice ? BigInt(raw.effectiveGasPrice) : void 0,
+    status,
+    raw
+  };
+}
+
+// src/bridge.ts
+import { HARDKAS_VERSION as HARDKAS_VERSION2 } from "@hardkas/artifacts";
+var IGRA_BRIDGE_ASSUMPTIONS = {
+  schema: "hardkas.l2BridgeAssumptions.v1",
+  hardkasVersion: HARDKAS_VERSION2,
+  l2Network: "igra",
+  bridgePhase: "pre-zk",
+  trustlessExit: false,
+  custodyModel: "Phase-dependent bridge custody; verify current bridge implementation before use.",
+  validatorModel: "Phase-dependent",
+  exitModel: "Trustless exit is available only in the ZK phase.",
+  riskProfile: "high",
+  notes: [
+    "Bridge security is phase-dependent: pre-ZK -> MPC -> ZK.",
+    "pre-ZK implies stronger trust assumptions.",
+    "MPC implies threshold committee trust assumptions.",
+    "ZK phase enables validity-proof based trustless exit.",
+    "HardKAS does not perform bridge operations in v0.2-alpha."
+  ],
+  updatedAt: "2026-05-07T00:00:00Z"
+  // Reference date for Phase 33
+};
+var BRIDGE_ASSUMPTIONS_REGISTRY = [
+  IGRA_BRIDGE_ASSUMPTIONS
+];
+function getL2BridgeAssumptions(network) {
+  return BRIDGE_ASSUMPTIONS_REGISTRY.find((a) => a.l2Network === network) || null;
+}
+function listL2BridgeAssumptions() {
+  return BRIDGE_ASSUMPTIONS_REGISTRY;
+}
+function validateL2BridgeAssumptions(input) {
+  const errors = [];
+  if (!input || typeof input !== "object") return { ok: false, errors: ["Input must be an object"] };
+  const v = input;
+  if (v.schema !== "hardkas.l2BridgeAssumptions.v1") errors.push("Invalid schema: expected 'hardkas.l2BridgeAssumptions.v1'");
+  if (typeof v.hardkasVersion !== "string" || !v.hardkasVersion) errors.push("Missing hardkasVersion");
+  if (typeof v.l2Network !== "string" || !v.l2Network) errors.push("Missing l2Network");
+  const validPhases = ["pre-zk", "mpc", "zk", "unknown"];
+  if (!validPhases.includes(v.bridgePhase)) errors.push(`Invalid bridgePhase: ${v.bridgePhase}`);
+  if (v.bridgePhase !== "zk" && v.trustlessExit === true) {
+    errors.push("trustlessExit must be false if bridgePhase is not 'zk'");
+  }
+  if (!Array.isArray(v.notes) || v.notes.length === 0) errors.push("Notes must be a non-empty array");
+  if (!v.updatedAt) errors.push("Missing updatedAt");
+  return { ok: errors.length === 0, errors };
+}
+function assertValidL2BridgeAssumptions(input) {
+  const { ok, errors } = validateL2BridgeAssumptions(input);
+  if (!ok) {
+    throw new Error(`Invalid L2 bridge assumptions:
+${errors.map((e) => `- ${e}`).join("\n")}`);
+  }
+  return input;
+}
+
+// src/abi.ts
+import { encodeDeployData, parseAbiItem } from "viem";
+function encodeConstructorArgs(bytecode, constructorSignature, args) {
+  const formattedBytecode = bytecode.startsWith("0x") ? bytecode : `0x${bytecode}`;
+  const abiItem = parseAbiItem(constructorSignature);
+  if (abiItem.type !== "constructor") {
+    throw new Error("Invalid constructor signature. Must start with 'constructor'.");
+  }
+  const parsedArgs = args.map((arg) => {
+    const trimmed = arg.trim();
+    if (trimmed.startsWith("0x")) return trimmed;
+    if (/^\d+$/.test(trimmed)) return BigInt(trimmed);
+    if (trimmed.toLowerCase() === "true") return true;
+    if (trimmed.toLowerCase() === "false") return false;
+    return trimmed;
+  });
+  return encodeDeployData({
+    abi: [abiItem],
+    bytecode: formattedBytecode,
+    args: parsedArgs
+  });
+}
+export {
+  BUILTIN_L2_PROFILES,
+  EvmJsonRpcClient,
+  UnsupportedIgraTxSigner,
+  ViemIgraTxSigner,
+  assertValidL2BridgeAssumptions,
+  assertValidL2Profile,
+  checkEvmRpcHealth,
+  encodeConstructorArgs,
+  formatWeiAsEtherLike,
+  getBuiltInL2Profiles,
+  getL2BridgeAssumptions,
+  getL2Profile,
+  listL2BridgeAssumptions,
+  listL2Profiles,
+  normalizeEvmTransactionReceipt,
+  toHexQuantity,
+  validateL2BridgeAssumptions,
+  validateL2Profile,
+  waitForEvmRpcReady
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@hardkas/l2",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "viem": "^2.48.8",
+    "@hardkas/artifacts": "0.1.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.4"
+  },
+  "license": "MIT",
+  "author": "Javier Rodriguez",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jrodrg92/Hardkas.git",
+    "directory": "packages/l2"
+  },
+  "bugs": {
+    "url": "https://github.com/jrodrg92/Hardkas/issues"
+  },
+  "homepage": "https://github.com/jrodrg92/Hardkas/tree/main/packages/l2#readme",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --watch --dts",
+    "test": "vitest run",
+    "lint": "tsc --noEmit"
+  }
+}