@coinbase/cdp-core 0.0.36 → 0.0.38

package/README.md

@@ -234,6 +234,26 @@ console.log("Signed Transaction:", result.signedTransaction);
 // The signedTransaction can now be broadcast to the Solana network
 ```
 
+### Sign a Solana Message
+
+You can also sign arbitrary messages with Solana accounts:
+
+```typescript lines
+import { signSolanaMessage, getCurrentUser } from "@coinbase/cdp-core";
+
+const user = await getCurrentUser();
+const solanaAccount = user.solanaAccounts[0];
+
+const message = Buffer.from("Hello, Solana!", "utf8").toString("base64");
+const result = await signSolanaMessage({
+  solanaAccount,
+  message // Base64 encoded message to sign
+});
+
+console.log("Message Signature:", result.signature);
+// The signature can be used for authentication or verification purposes
+```
+
 ### Send a Solana Transaction
 
 You can sign and send a Solana transaction in a single call on the following Solana networks:
@@ -347,9 +367,11 @@ const typedDataResult = await signEvmTypedData({
 });
 ```
 
-### Export Private Key
+### Export Private Keys
+
+End users can export their private keys from their embedded wallet, allowing them to import them into compatible wallets of their choice.
 
-End users can export their private keys from their embedded wallet, allowing them to import it into an EVM-compatible wallet of their choice.
+#### Export EVM Private Key
 
 ```typescript lines
 import { exportEvmAccount, getCurrentUser } from "@coinbase/cdp-core";
@@ -362,7 +384,25 @@ const { privateKey } = await exportEvmAccount({
 });
 
 // WARNING: Handle private keys with extreme care!
-console.log("Private Key:", privateKey);
+console.log("EVM Private Key:", privateKey);
+```
+
+#### Export Solana Private Key
+
+When your application is configured with `solana: { createOnLogin: true }`, you can export Solana private keys:
+
+```typescript lines
+import { exportSolanaAccount, getCurrentUser } from "@coinbase/cdp-core";
+
+const user = await getCurrentUser();
+const solanaAccount = user.solanaAccounts[0];
+
+const { privateKey } = await exportSolanaAccount({
+  solanaAccount
+});
+
+// WARNING: Handle private keys with extreme care!
+console.log("Solana Private Key:", privateKey);
 ```
 
 ### EIP-1193 Provider

package/dist/esm/index.native.js

@@ -2,51 +2,53 @@ import { nativeCrypto as r } from "./index.native2.js";
 import { nativeSecureStorage as o } from "./index.native3.js";
 import { nativeStorage as e } from "./index.native4.js";
 import { setPlatformServices as t } from "./index.native5.js";
-import { exportEvmAccount as d, getAccessToken as S, getCurrentUser as f, getUserOperation as v, initialize as T, isSignedIn as u, onAuthStateChange as l, sendEvmTransaction as A, sendSolanaTransaction as y, sendUserOperation as h, signEvmHash as x, signEvmMessage as O, signEvmTransaction as P, signEvmTypedData as C, signInWithEmail as D, signInWithSms as I, signOut as R, signSolanaTransaction as U, verifyEmailOTP as W, verifySmsOTP as k } from "./index.native6.js";
-import { AuthManager as N } from "./index.native7.js";
-import { APIError as B, ErrorType as H, HttpErrorType as _, SendEvmTransactionWithEndUserAccountBodyNetwork as b, SendSolanaTransactionWithEndUserAccountBodyNetwork as z } from "@coinbase/cdp-api-client";
+import { exportEvmAccount as S, exportSolanaAccount as d, getAccessToken as f, getCurrentUser as v, getUserOperation as l, initialize as u, isSignedIn as T, onAuthStateChange as A, sendEvmTransaction as x, sendSolanaTransaction as y, sendUserOperation as h, signEvmHash as O, signEvmMessage as P, signEvmTransaction as C, signEvmTypedData as D, signInWithEmail as I, signInWithSms as R, signOut as U, signSolanaMessage as W, signSolanaTransaction as M, verifyEmailOTP as k, verifySmsOTP as N } from "./index.native6.js";
+import { AuthManager as B } from "./index.native7.js";
+import { APIError as _, ErrorType as b, HttpErrorType as z, SendEvmTransactionWithEndUserAccountBodyNetwork as V, SendSolanaTransactionWithEndUserAccountBodyNetwork as j } from "@coinbase/cdp-api-client";
 import "viem";
-import { createCDPEmbeddedWallet as j } from "./index.native8.js";
-import { EIP1193ProviderError as F, STANDARD_ERROR_CODES as G } from "./index.native9.js";
+import { createCDPEmbeddedWallet as F } from "./index.native8.js";
+import { EIP1193ProviderError as J, STANDARD_ERROR_CODES as K } from "./index.native9.js";
 import "ox";
 import "zustand";
-import { toViemAccount as K } from "./index.native10.js";
-import { ModuleResolutionError as Q } from "./index.native11.js";
+import { toViemAccount as Q } from "./index.native10.js";
+import { ModuleResolutionError as Y } from "./index.native11.js";
 t({
   crypto: r,
   storage: e,
   secureStorage: o
 });
 export {
-  B as APIError,
-  N as AuthManager,
-  F as EIP1193ProviderError,
-  H as ErrorType,
-  _ as HttpErrorType,
-  Q as ModuleResolutionError,
-  G as STANDARD_ERROR_CODES,
-  b as SendEvmTransactionWithEndUserAccountBodyNetwork,
-  z as SendSolanaTransactionWithEndUserAccountBodyNetwork,
-  j as createCDPEmbeddedWallet,
-  d as exportEvmAccount,
-  S as getAccessToken,
-  f as getCurrentUser,
-  v as getUserOperation,
-  T as initialize,
-  u as isSignedIn,
-  l as onAuthStateChange,
-  A as sendEvmTransaction,
+  _ as APIError,
+  B as AuthManager,
+  J as EIP1193ProviderError,
+  b as ErrorType,
+  z as HttpErrorType,
+  Y as ModuleResolutionError,
+  K as STANDARD_ERROR_CODES,
+  V as SendEvmTransactionWithEndUserAccountBodyNetwork,
+  j as SendSolanaTransactionWithEndUserAccountBodyNetwork,
+  F as createCDPEmbeddedWallet,
+  S as exportEvmAccount,
+  d as exportSolanaAccount,
+  f as getAccessToken,
+  v as getCurrentUser,
+  l as getUserOperation,
+  u as initialize,
+  T as isSignedIn,
+  A as onAuthStateChange,
+  x as sendEvmTransaction,
   y as sendSolanaTransaction,
   h as sendUserOperation,
-  x as signEvmHash,
-  O as signEvmMessage,
-  P as signEvmTransaction,
-  C as signEvmTypedData,
-  D as signInWithEmail,
-  I as signInWithSms,
-  R as signOut,
-  U as signSolanaTransaction,
-  K as toViemAccount,
-  W as verifyEmailOTP,
-  k as verifySmsOTP
+  O as signEvmHash,
+  P as signEvmMessage,
+  C as signEvmTransaction,
+  D as signEvmTypedData,
+  I as signInWithEmail,
+  R as signInWithSms,
+  U as signOut,
+  W as signSolanaMessage,
+  M as signSolanaTransaction,
+  Q as toViemAccount,
+  k as verifyEmailOTP,
+  N as verifySmsOTP
 };

package/dist/esm/index.native100.js

@@ -1,10 +1,23 @@
-const o = (t, r) => {
-  if (t.startsWith("RS") || t.startsWith("PS")) {
-    const { modulusLength: e } = r.algorithm;
-    if (typeof e != "number" || e < 2048)
-      throw new TypeError(`${t} requires key modulusLength to be 2048 bits or larger`);
+import { JOSENotSupported as f } from "./index.native34.js";
+const w = (n, r, a, e, s) => {
+  if (s.crit !== void 0 && e?.crit === void 0)
+    throw new n('"crit" (Critical) Header Parameter MUST be integrity protected');
+  if (!e || e.crit === void 0)
+    return /* @__PURE__ */ new Set();
+  if (!Array.isArray(e.crit) || e.crit.length === 0 || e.crit.some((i) => typeof i != "string" || i.length === 0))
+    throw new n('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');
+  let t;
+  a !== void 0 ? t = new Map([...Object.entries(a), ...r.entries()]) : t = r;
+  for (const i of e.crit) {
+    if (!t.has(i))
+      throw new f(`Extension Header Parameter "${i}" is not recognized`);
+    if (s[i] === void 0)
+      throw new n(`Extension Header Parameter "${i}" is missing`);
+    if (t.get(i) && e[i] === void 0)
+      throw new n(`Extension Header Parameter "${i}" MUST be integrity protected`);
   }
+  return new Set(e.crit);
 };
 export {
-  o as default
+  w as default
 };

package/dist/esm/index.native101.js

@@ -1,13 +1,120 @@
-import { checkSigCryptoKey as i } from "./index.native109.js";
-import o from "./index.native102.js";
-const s = async (t, r, e) => {
-  if (r instanceof Uint8Array) {
-    if (!t.startsWith("HS"))
-      throw new TypeError(o(r, "CryptoKey", "KeyObject", "JSON Web Key"));
-    return crypto.subtle.importKey("raw", r, { hash: `SHA-${t.slice(-3)}`, name: "HMAC" }, !1, [e]);
-  }
-  return i(r, t, e), r;
+import { isJWK as p } from "./index.native113.js";
+import { decode as m } from "./index.native96.js";
+import y from "./index.native114.js";
+import { isCryptoKey as S, isKeyObject as K } from "./index.native112.js";
+let c;
+const f = async (e, r, s, i = !1) => {
+  c ||= /* @__PURE__ */ new WeakMap();
+  let n = c.get(e);
+  if (n?.[s])
+    return n[s];
+  const t = await y({ ...r, alg: s });
+  return i && Object.freeze(e), n ? n[s] = t : c.set(e, { [s]: t }), t;
+}, E = (e, r) => {
+  c ||= /* @__PURE__ */ new WeakMap();
+  let s = c.get(e);
+  if (s?.[r])
+    return s[r];
+  const i = e.type === "public", n = !!i;
+  let t;
+  if (e.asymmetricKeyType === "x25519") {
+    switch (r) {
+      case "ECDH-ES":
+      case "ECDH-ES+A128KW":
+      case "ECDH-ES+A192KW":
+      case "ECDH-ES+A256KW":
+        break;
+      default:
+        throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+    }
+    t = e.toCryptoKey(e.asymmetricKeyType, n, i ? [] : ["deriveBits"]);
+  }
+  if (e.asymmetricKeyType === "ed25519") {
+    if (r !== "EdDSA" && r !== "Ed25519")
+      throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+    t = e.toCryptoKey(e.asymmetricKeyType, n, [
+      i ? "verify" : "sign"
+    ]);
+  }
+  if (e.asymmetricKeyType === "rsa") {
+    let a;
+    switch (r) {
+      case "RSA-OAEP":
+        a = "SHA-1";
+        break;
+      case "RS256":
+      case "PS256":
+      case "RSA-OAEP-256":
+        a = "SHA-256";
+        break;
+      case "RS384":
+      case "PS384":
+      case "RSA-OAEP-384":
+        a = "SHA-384";
+        break;
+      case "RS512":
+      case "PS512":
+      case "RSA-OAEP-512":
+        a = "SHA-512";
+        break;
+      default:
+        throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+    }
+    if (r.startsWith("RSA-OAEP"))
+      return e.toCryptoKey({
+        name: "RSA-OAEP",
+        hash: a
+      }, n, i ? ["encrypt"] : ["decrypt"]);
+    t = e.toCryptoKey({
+      name: r.startsWith("PS") ? "RSA-PSS" : "RSASSA-PKCS1-v1_5",
+      hash: a
+    }, n, [i ? "verify" : "sign"]);
+  }
+  if (e.asymmetricKeyType === "ec") {
+    const o = (/* @__PURE__ */ new Map([
+      ["prime256v1", "P-256"],
+      ["secp384r1", "P-384"],
+      ["secp521r1", "P-521"]
+    ])).get(e.asymmetricKeyDetails?.namedCurve);
+    if (!o)
+      throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+    r === "ES256" && o === "P-256" && (t = e.toCryptoKey({
+      name: "ECDSA",
+      namedCurve: o
+    }, n, [i ? "verify" : "sign"])), r === "ES384" && o === "P-384" && (t = e.toCryptoKey({
+      name: "ECDSA",
+      namedCurve: o
+    }, n, [i ? "verify" : "sign"])), r === "ES512" && o === "P-521" && (t = e.toCryptoKey({
+      name: "ECDSA",
+      namedCurve: o
+    }, n, [i ? "verify" : "sign"])), r.startsWith("ECDH-ES") && (t = e.toCryptoKey({
+      name: "ECDH",
+      namedCurve: o
+    }, n, i ? [] : ["deriveBits"]));
+  }
+  if (!t)
+    throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+  return s ? s[r] = t : c.set(e, { [r]: t }), t;
+}, d = async (e, r) => {
+  if (e instanceof Uint8Array || S(e))
+    return e;
+  if (K(e)) {
+    if (e.type === "secret")
+      return e.export();
+    if ("toCryptoKey" in e && typeof e.toCryptoKey == "function")
+      try {
+        return E(e, r);
+      } catch (i) {
+        if (i instanceof TypeError)
+          throw i;
+      }
+    let s = e.export({ format: "jwk" });
+    return f(e, s, r);
+  }
+  if (p(e))
+    return e.k ? m(e.k) : f(e, e, r, !0);
+  throw new Error("unreachable");
 };
 export {
-  s as default
+  d as default
 };

package/dist/esm/index.native102.js

@@ -1,15 +1,81 @@
-function i(n, e, ...o) {
-  if (o = o.filter(Boolean), o.length > 2) {
-    const f = o.pop();
-    n += `one of type ${o.join(", ")}, or ${f}.`;
-  } else o.length === 2 ? n += `one of type ${o[0]} or ${o[1]}.` : n += `of type ${o[0]}.`;
-  return e == null ? n += ` Received ${e}` : typeof e == "function" && e.name ? n += ` Received function ${e.name}` : typeof e == "object" && e != null && e.constructor?.name && (n += ` Received an instance of ${e.constructor.name}`), n;
+import { Hash as g, createView as l, aexists as b, toBytes as a, abytes as d, aoutput as x, clean as w } from "./index.native91.js";
+function y(o, t, s, n) {
+  if (typeof o.setBigUint64 == "function")
+    return o.setBigUint64(t, s, n);
+  const i = BigInt(32), h = BigInt(4294967295), e = Number(s >> i & h), r = Number(s & h), c = n ? 4 : 0, u = n ? 0 : 4;
+  o.setUint32(t + c, e, n), o.setUint32(t + u, r, n);
 }
-const r = (n, ...e) => i("Key must be ", n, ...e);
-function t(n, e, ...o) {
-  return i(`Key for the ${n} algorithm must be `, e, ...o);
+function U(o, t, s) {
+  return o & t ^ ~o & s;
 }
+function _(o, t, s) {
+  return o & t ^ o & s ^ t & s;
+}
+class m extends g {
+  constructor(t, s, n, i) {
+    super(), this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.blockLen = t, this.outputLen = s, this.padOffset = n, this.isLE = i, this.buffer = new Uint8Array(t), this.view = l(this.buffer);
+  }
+  update(t) {
+    b(this), t = a(t), d(t);
+    const { view: s, buffer: n, blockLen: i } = this, h = t.length;
+    for (let e = 0; e < h; ) {
+      const r = Math.min(i - this.pos, h - e);
+      if (r === i) {
+        const c = l(t);
+        for (; i <= h - e; e += i)
+          this.process(c, e);
+        continue;
+      }
+      n.set(t.subarray(e, e + r), this.pos), this.pos += r, e += r, this.pos === i && (this.process(s, 0), this.pos = 0);
+    }
+    return this.length += t.length, this.roundClean(), this;
+  }
+  digestInto(t) {
+    b(this), x(t, this), this.finished = !0;
+    const { buffer: s, view: n, blockLen: i, isLE: h } = this;
+    let { pos: e } = this;
+    s[e++] = 128, w(this.buffer.subarray(e)), this.padOffset > i - e && (this.process(n, 0), e = 0);
+    for (let f = e; f < i; f++)
+      s[f] = 0;
+    y(n, i - 8, BigInt(this.length * 8), h), this.process(n, 0);
+    const r = l(t), c = this.outputLen;
+    if (c % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const u = c / 4, p = this.get();
+    if (u > p.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let f = 0; f < u; f++)
+      r.setUint32(4 * f, p[f], h);
+  }
+  digest() {
+    const { buffer: t, outputLen: s } = this;
+    this.digestInto(t);
+    const n = t.slice(0, s);
+    return this.destroy(), n;
+  }
+  _cloneInto(t) {
+    t || (t = new this.constructor()), t.set(...this.get());
+    const { blockLen: s, buffer: n, length: i, finished: h, destroyed: e, pos: r } = this;
+    return t.destroyed = e, t.finished = h, t.length = i, t.pos = r, i % s && t.buffer.set(n), t;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+const B = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
 export {
-  r as default,
-  t as withAlg
+  U as Chi,
+  m as HashMD,
+  _ as Maj,
+  B as SHA256_IV,
+  y as setBigUint64
 };

package/dist/esm/index.native103.js

@@ -1,12 +1,7 @@
-function e(t) {
-  return t?.[Symbol.toStringTag] === "CryptoKey";
-}
-function r(t) {
-  return t?.[Symbol.toStringTag] === "KeyObject";
-}
-const n = (t) => e(t) || r(t);
+const e = 32, s = 4096, t = 131072, l = 761855;
 export {
-  n as default,
-  e as isCryptoKey,
-  r as isKeyObject
+  t as bytesPerBlob,
+  e as bytesPerFieldElement,
+  s as fieldElementsPerBlob,
+  l as maxBytesPerTransaction
 };

package/dist/esm/index.native104.js

@@ -1,19 +1,15 @@
-import n from "./index.native81.js";
-function r(t) {
-  return n(t) && typeof t.kty == "string";
-}
-function o(t) {
-  return t.kty !== "oct" && typeof t.d == "string";
-}
-function e(t) {
-  return t.kty !== "oct" && typeof t.d > "u";
-}
-function c(t) {
-  return t.kty === "oct" && typeof t.k == "string";
-}
+const s = {
+  gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
+  l1Block: { address: "0x4200000000000000000000000000000000000015" },
+  l2CrossDomainMessenger: {
+    address: "0x4200000000000000000000000000000000000007"
+  },
+  l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
+  l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
+  l2ToL1MessagePasser: {
+    address: "0x4200000000000000000000000000000000000016"
+  }
+};
 export {
-  r as isJWK,
-  o as isPrivateJWK,
-  e as isPublicJWK,
-  c as isSecretJWK
+  s as contracts
 };

package/dist/esm/index.native105.js

@@ -1,83 +1,38 @@
-import { JOSENotSupported as s } from "./index.native30.js";
-function n(e) {
-  let a, r;
-  switch (e.kty) {
-    case "RSA": {
-      switch (e.alg) {
-        case "PS256":
-        case "PS384":
-        case "PS512":
-          a = { name: "RSA-PSS", hash: `SHA-${e.alg.slice(-3)}` }, r = e.d ? ["sign"] : ["verify"];
-          break;
-        case "RS256":
-        case "RS384":
-        case "RS512":
-          a = { name: "RSASSA-PKCS1-v1_5", hash: `SHA-${e.alg.slice(-3)}` }, r = e.d ? ["sign"] : ["verify"];
-          break;
-        case "RSA-OAEP":
-        case "RSA-OAEP-256":
-        case "RSA-OAEP-384":
-        case "RSA-OAEP-512":
-          a = {
-            name: "RSA-OAEP",
-            hash: `SHA-${parseInt(e.alg.slice(-3), 10) || 1}`
-          }, r = e.d ? ["decrypt", "unwrapKey"] : ["encrypt", "wrapKey"];
-          break;
-        default:
-          throw new s('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
-      }
-      break;
+import { hexToBigInt as n } from "./index.native56.js";
+import { defineBlock as r } from "./index.native53.js";
+import { defineTransaction as s, formatTransaction as m } from "./index.native55.js";
+import { defineTransactionReceipt as l } from "./index.native58.js";
+const p = {
+  block: /* @__PURE__ */ r({
+    format(e) {
+      return {
+        transactions: e.transactions?.map((t) => {
+          if (typeof t == "string")
+            return t;
+          const i = m(t);
+          return i.typeHex === "0x7e" && (i.isSystemTx = t.isSystemTx, i.mint = t.mint ? n(t.mint) : void 0, i.sourceHash = t.sourceHash, i.type = "deposit"), i;
+        }),
+        stateRoot: e.stateRoot
+      };
     }
-    case "EC": {
-      switch (e.alg) {
-        case "ES256":
-          a = { name: "ECDSA", namedCurve: "P-256" }, r = e.d ? ["sign"] : ["verify"];
-          break;
-        case "ES384":
-          a = { name: "ECDSA", namedCurve: "P-384" }, r = e.d ? ["sign"] : ["verify"];
-          break;
-        case "ES512":
-          a = { name: "ECDSA", namedCurve: "P-521" }, r = e.d ? ["sign"] : ["verify"];
-          break;
-        case "ECDH-ES":
-        case "ECDH-ES+A128KW":
-        case "ECDH-ES+A192KW":
-        case "ECDH-ES+A256KW":
-          a = { name: "ECDH", namedCurve: e.crv }, r = e.d ? ["deriveBits"] : [];
-          break;
-        default:
-          throw new s('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
-      }
-      break;
+  }),
+  transaction: /* @__PURE__ */ s({
+    format(e) {
+      const o = {};
+      return e.type === "0x7e" && (o.isSystemTx = e.isSystemTx, o.mint = e.mint ? n(e.mint) : void 0, o.sourceHash = e.sourceHash, o.type = "deposit"), o;
     }
-    case "OKP": {
-      switch (e.alg) {
-        case "Ed25519":
-        case "EdDSA":
-          a = { name: "Ed25519" }, r = e.d ? ["sign"] : ["verify"];
-          break;
-        case "ECDH-ES":
-        case "ECDH-ES+A128KW":
-        case "ECDH-ES+A192KW":
-        case "ECDH-ES+A256KW":
-          a = { name: e.crv }, r = e.d ? ["deriveBits"] : [];
-          break;
-        default:
-          throw new s('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
-      }
-      break;
+  }),
+  transactionReceipt: /* @__PURE__ */ l({
+    format(e) {
+      return {
+        l1GasPrice: e.l1GasPrice ? n(e.l1GasPrice) : null,
+        l1GasUsed: e.l1GasUsed ? n(e.l1GasUsed) : null,
+        l1Fee: e.l1Fee ? n(e.l1Fee) : null,
+        l1FeeScalar: e.l1FeeScalar ? Number(e.l1FeeScalar) : null
+      };
     }
-    default:
-      throw new s('Invalid or unsupported JWK "kty" (Key Type) Parameter value');
-  }
-  return { algorithm: a, keyUsages: r };
-}
-const i = async (e) => {
-  if (!e.alg)
-    throw new TypeError('"alg" argument is required when "jwk.alg" is not present');
-  const { algorithm: a, keyUsages: r } = n(e), t = { ...e };
-  return delete t.alg, delete t.use, crypto.subtle.importKey("jwk", t, a, e.ext ?? !e.d, e.key_ops ?? r);
+  })
 };
 export {
-  i as default
+  p as formatters
 };

package/dist/esm/index.native106.js

@@ -1,15 +1,44 @@
-const s = {
-  gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
-  l1Block: { address: "0x4200000000000000000000000000000000000015" },
-  l2CrossDomainMessenger: {
-    address: "0x4200000000000000000000000000000000000007"
-  },
-  l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
-  l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
-  l2ToL1MessagePasser: {
-    address: "0x4200000000000000000000000000000000000016"
-  }
+import { InvalidAddressError as a } from "./index.native71.js";
+import { isAddress as f } from "./index.native45.js";
+import { concatHex as p } from "./index.native46.js";
+import { toHex as i } from "./index.native40.js";
+import { toRlp as x } from "./index.native59.js";
+import { serializeTransaction as l } from "./index.native20.js";
+function T(r, e) {
+  return h(r) ? z(r) : l(r, e);
+}
+const E = {
+  transaction: T
 };
+function z(r) {
+  w(r);
+  const { sourceHash: e, data: o, from: m, gas: t, isSystemTx: u, mint: s, to: c, value: n } = r, d = [
+    e,
+    m,
+    c ?? "0x",
+    s ? i(s) : "0x",
+    n ? i(n) : "0x",
+    t ? i(t) : "0x",
+    u ? "0x1" : "0x",
+    o ?? "0x"
+  ];
+  return p([
+    "0x7e",
+    x(d)
+  ]);
+}
+function h(r) {
+  return r.type === "deposit" || typeof r.sourceHash < "u";
+}
+function w(r) {
+  const { from: e, to: o } = r;
+  if (e && !f(e))
+    throw new a({ address: e });
+  if (o && !f(o))
+    throw new a({ address: o });
+}
 export {
-  s as contracts
+  w as assertTransactionDeposit,
+  T as serializeTransaction,
+  E as serializers
 };