@coinbase/cdp-core 0.0.30 → 0.0.31

package/dist/web/index.web94.js

@@ -1,7 +1,81 @@
-const e = 32, s = 4096, t = 131072, l = 761855;
+import { Hash as g, createView as l, aexists as b, toBytes as a, abytes as d, aoutput as x, clean as w } from "./index.web83.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);
+}
+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 {
-  t as bytesPerBlob,
-  e as bytesPerFieldElement,
-  s as fieldElementsPerBlob,
-  l as maxBytesPerTransaction
+  U as Chi,
+  m as HashMD,
+  _ as Maj,
+  B as SHA256_IV,
+  y as setBigUint64
 };

package/dist/web/index.web95.js

@@ -1,20 +1,7 @@
-function o(t) {
-  if (Uint8Array.prototype.toBase64)
-    return t.toBase64();
-  const e = 32768, n = [];
-  for (let r = 0; r < t.length; r += e)
-    n.push(String.fromCharCode.apply(null, t.subarray(r, r + e)));
-  return btoa(n.join(""));
-}
-function a(t) {
-  if (Uint8Array.fromBase64)
-    return Uint8Array.fromBase64(t);
-  const e = atob(t), n = new Uint8Array(e.length);
-  for (let r = 0; r < e.length; r++)
-    n[r] = e.charCodeAt(r);
-  return n;
-}
+const e = 32, s = 4096, t = 131072, l = 761855;
 export {
-  a as decodeBase64,
-  o as encodeBase64
+  t as bytesPerBlob,
+  e as bytesPerFieldElement,
+  s as fieldElementsPerBlob,
+  l as maxBytesPerTransaction
 };

package/dist/web/index.web96.js

@@ -1,30 +1,15 @@
-import { JOSENotSupported as r } from "./index.web27.js";
-const S = (e, s) => {
-  const a = `SHA-${e.slice(-3)}`;
-  switch (e) {
-    case "HS256":
-    case "HS384":
-    case "HS512":
-      return { hash: a, name: "HMAC" };
-    case "PS256":
-    case "PS384":
-    case "PS512":
-      return { hash: a, name: "RSA-PSS", saltLength: parseInt(e.slice(-3), 10) >> 3 };
-    case "RS256":
-    case "RS384":
-    case "RS512":
-      return { hash: a, name: "RSASSA-PKCS1-v1_5" };
-    case "ES256":
-    case "ES384":
-    case "ES512":
-      return { hash: a, name: "ECDSA", namedCurve: s.namedCurve };
-    case "Ed25519":
-    case "EdDSA":
-      return { name: "Ed25519" };
-    default:
-      throw new r(`alg ${e} is not supported either by JOSE or your javascript runtime`);
+const s = {
+  gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
+  l1Block: { address: "0x4200000000000000000000000000000000000015" },
+  l2CrossDomainMessenger: {
+    address: "0x4200000000000000000000000000000000000007"
+  },
+  l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
+  l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
+  l2ToL1MessagePasser: {
+    address: "0x4200000000000000000000000000000000000016"
   }
 };
 export {
-  S as default
+  s as contracts
 };

package/dist/web/index.web97.js

@@ -1,10 +1,38 @@
-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 { hexToBigInt as n } from "./index.web48.js";
+import { defineBlock as r } from "./index.web45.js";
+import { defineTransaction as s, formatTransaction as m } from "./index.web47.js";
+import { defineTransactionReceipt as l } from "./index.web50.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
+      };
+    }
+  }),
+  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;
+    }
+  }),
+  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
+      };
+    }
+  })
 };
 export {
-  o as default
+  p as formatters
 };

package/dist/web/index.web98.js

@@ -1,13 +1,44 @@
-import { checkSigCryptoKey as i } from "./index.web106.js";
-import o from "./index.web99.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 { InvalidAddressError as a } from "./index.web63.js";
+import { isAddress as f } from "./index.web37.js";
+import { concatHex as p } from "./index.web38.js";
+import { toHex as i } from "./index.web32.js";
+import { toRlp as x } from "./index.web51.js";
+import { serializeTransaction as l } from "./index.web18.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 default
+  w as assertTransactionDeposit,
+  T as serializeTransaction,
+  E as serializers
 };

package/dist/web/index.web99.js

@@ -1,15 +1,20 @@
-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;
+function o(t) {
+  if (Uint8Array.prototype.toBase64)
+    return t.toBase64();
+  const e = 32768, n = [];
+  for (let r = 0; r < t.length; r += e)
+    n.push(String.fromCharCode.apply(null, t.subarray(r, r + e)));
+  return btoa(n.join(""));
 }
-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 a(t) {
+  if (Uint8Array.fromBase64)
+    return Uint8Array.fromBase64(t);
+  const e = atob(t), n = new Uint8Array(e.length);
+  for (let r = 0; r < e.length; r++)
+    n[r] = e.charCodeAt(r);
+  return n;
 }
 export {
-  r as default,
-  t as withAlg
+  a as decodeBase64,
+  o as encodeBase64
 };

package/dist/web-types/viem/factory.d.ts

@@ -0,0 +1,61 @@
+export declare const COINBASE_SMART_WALLET_FACTORY_ADDRESS = "0xba5ed110efdba3d005bfc882d75358acbbb85842";
+export declare const COINBASE_SMART_WALLET_FACTORY_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly name: "implementation_";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "constructor";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "OwnerRequired";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "owners";
+        readonly type: "bytes[]";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }];
+    readonly name: "createAccount";
+    readonly outputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "owners";
+        readonly type: "bytes[]";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }];
+    readonly name: "getAddress";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "implementation";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "initCodeHash";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinbase/cdp-core",
-  "version": "0.0.30",
+  "version": "0.0.31",
   "type": "module",
   "files": [
     "dist/**",
@@ -25,7 +25,7 @@
     "ox": "0.8.1",
     "viem": "^2.33.0",
     "zustand": "^5.0.6",
-    "@coinbase/cdp-api-client": "^0.0.30"
+    "@coinbase/cdp-api-client": "^0.0.31"
   },
   "peerDependencies": {
     "@react-native-async-storage/async-storage": "^2.0.0"