@aastar/sdk 0.20.6 → 0.20.8

package/dist/{chunk-FUU7RIIA.js → chunk-X3AMH53O.js}

@@ -1,12 +1,23 @@
 import { __export } from './chunk-PZ5AY32C.js';
 import axios2 from 'axios';
 import { startRegistration, startAuthentication } from '@simplewebauthn/browser';
-import { ethers } from 'ethers';
+import { parseAbiParameters, encodeAbiParameters, keccak256 as keccak256$1, encodePacked, hexToBytes as hexToBytes$1, bytesToHex as bytesToHex$1, numberToHex, stringToBytes } from 'viem';
 import * as crypto from 'crypto';
 
+var DEFAULT_PASSKEY_ROUTES = {
+  registerBegin: "/auth/passkey/register/begin",
+  registerComplete: "/auth/passkey/register/complete",
+  loginBegin: "/auth/passkey/login/begin",
+  loginComplete: "/auth/passkey/login/complete",
+  deviceBegin: "/auth/device/passkey/begin",
+  deviceComplete: "/auth/device/passkey/complete",
+  transactionVerifyBegin: "/auth/transaction/verify/begin"
+};
 var PasskeyManager = class {
   api;
-  constructor(baseURL, tokenProvider) {
+  routes;
+  constructor(baseURL, tokenProvider, routes) {
+    this.routes = { ...DEFAULT_PASSKEY_ROUTES, ...routes };
     this.api = axios2.create({
       baseURL,
       headers: {
@@ -28,11 +39,11 @@ var PasskeyManager = class {
    */
   async register(params) {
     const beginResponse = await this.api.post(
-      "/auth/passkey/register/begin",
+      this.routes.registerBegin,
       params
     );
     const credential = await startRegistration(beginResponse.data);
-    const completeResponse = await this.api.post("/auth/passkey/register/complete", {
+    const completeResponse = await this.api.post(this.routes.registerComplete, {
       email: params.email,
       username: params.username,
       password: params.password,
@@ -45,11 +56,11 @@ var PasskeyManager = class {
    */
   async authenticate(params) {
     const beginResponse = await this.api.post(
-      "/auth/passkey/login/begin",
+      this.routes.loginBegin,
       params
     );
     const credential = await startAuthentication(beginResponse.data);
-    const completeResponse = await this.api.post("/auth/passkey/login/complete", { credential });
+    const completeResponse = await this.api.post(this.routes.loginComplete, { credential });
     return completeResponse.data;
   }
   /**
@@ -58,7 +69,7 @@ var PasskeyManager = class {
    */
   async verifyTransaction(params) {
     const beginResponse = await this.api.post(
-      "/auth/transaction/verify/begin",
+      this.routes.transactionVerifyBegin,
       { transaction: params }
     );
     const { userOpHash, ...authOptions } = beginResponse.data;
@@ -74,11 +85,11 @@ var PasskeyManager = class {
    */
   async addDevice(params) {
     const beginResponse = await this.api.post(
-      "/auth/device/passkey/begin",
+      this.routes.deviceBegin,
       params
     );
     const credential = await startRegistration(beginResponse.data);
-    const completeResponse = await this.api.post("/auth/device/passkey/complete", {
+    const completeResponse = await this.api.post(this.routes.deviceComplete, {
       email: params.email,
       password: params.password,
       credential
@@ -4020,6 +4031,91 @@ function mapToG2(scalars) {
   return isogenyMapG2(x, y);
 }
 
+// ../airaccount/src/migration/viem/bls-packing.ts
+var BLS_DST = "BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_POP_";
+function packSignature(data) {
+  if (!data.nodeIds || !data.aaSignature || !data.messagePointSignature) {
+    throw new Error("Missing required signature components");
+  }
+  const nodeIdsLength = encodePacked(["uint256"], [BigInt(data.nodeIds.length)]);
+  const nodeIdsBytes = encodePacked(
+    Array(data.nodeIds.length).fill("bytes32"),
+    data.nodeIds
+  );
+  return encodePacked(
+    ["bytes", "bytes", "bytes", "bytes", "bytes", "bytes"],
+    [
+      nodeIdsLength,
+      nodeIdsBytes,
+      data.signature,
+      data.messagePoint,
+      data.aaSignature,
+      data.messagePointSignature
+    ]
+  );
+}
+function packCumulativeT2Signature(data) {
+  const nodeIdsLength = encodePacked(["uint256"], [BigInt(data.nodeIds.length)]);
+  const nodeIdsBytes = encodePacked(
+    Array(data.nodeIds.length).fill("bytes32"),
+    data.nodeIds
+  );
+  return encodePacked(
+    ["bytes1", "bytes", "bytes", "bytes", "bytes", "bytes", "bytes"],
+    [
+      "0x04",
+      data.p256Signature,
+      nodeIdsLength,
+      nodeIdsBytes,
+      data.blsSignature,
+      data.messagePoint,
+      data.messagePointSignature
+    ]
+  );
+}
+function packCumulativeT3Signature(data) {
+  const nodeIdsLength = encodePacked(["uint256"], [BigInt(data.nodeIds.length)]);
+  const nodeIdsBytes = encodePacked(
+    Array(data.nodeIds.length).fill("bytes32"),
+    data.nodeIds
+  );
+  return encodePacked(
+    ["bytes1", "bytes", "bytes", "bytes", "bytes", "bytes", "bytes", "bytes"],
+    [
+      "0x05",
+      data.p256Signature,
+      nodeIdsLength,
+      nodeIdsBytes,
+      data.blsSignature,
+      data.messagePoint,
+      data.messagePointSignature,
+      data.guardianSignature
+    ]
+  );
+}
+function encodeG2Point(point) {
+  const result = new Uint8Array(256);
+  const affine = point.toAffine();
+  const x0Bytes = hexToBytes$1(numberToHex(affine.x.c0, { size: 48 }));
+  const x1Bytes = hexToBytes$1(numberToHex(affine.x.c1, { size: 48 }));
+  const y0Bytes = hexToBytes$1(numberToHex(affine.y.c0, { size: 48 }));
+  const y1Bytes = hexToBytes$1(numberToHex(affine.y.c1, { size: 48 }));
+  result.set(x0Bytes, 16);
+  result.set(x1Bytes, 80);
+  result.set(y0Bytes, 144);
+  result.set(y1Bytes, 208);
+  return result;
+}
+async function hashToCurve(messageBytes) {
+  return bls12_381.G2.hashToCurve(messageBytes, { DST: BLS_DST });
+}
+async function generateMessagePoint(message) {
+  const messageBytes = typeof message === "string" ? hexToBytes$1(message) : message;
+  const messagePointBLS = await hashToCurve(messageBytes);
+  const messageG2EIP = encodeG2Point(messagePointBLS);
+  return bytesToHex$1(messageG2EIP);
+}
+
 // ../airaccount/src/core/bls/bls.manager.ts
 var BLSManager = class {
   config;
@@ -4060,59 +4156,13 @@ var BLSManager = class {
    * Format: [nodeIdsLength][nodeIds...][blsSignature][messagePoint][aaSignature][messagePointSignature]
    */
   packSignature(data) {
-    if (!data.nodeIds || !data.aaSignature || !data.messagePointSignature) {
-      throw new Error("Missing required signature components");
-    }
-    const nodeIdsLength = ethers.solidityPacked(["uint256"], [data.nodeIds.length]);
-    const nodeIdsBytes = ethers.solidityPacked(
-      Array(data.nodeIds.length).fill("bytes32"),
-      data.nodeIds
-    );
-    return ethers.solidityPacked(
-      ["bytes", "bytes", "bytes", "bytes", "bytes", "bytes"],
-      [
-        nodeIdsLength,
-        nodeIdsBytes,
-        data.signature,
-        data.messagePoint,
-        data.aaSignature,
-        data.messagePointSignature
-      ]
-    );
+    return packSignature(data);
   }
   /**
    * Calculate the MessagePoint G2 point for a given message (UserOpHash)
    */
   async generateMessagePoint(message) {
-    const messageBytes = typeof message === "string" ? ethers.getBytes(message) : message;
-    const DST = "BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_POP_";
-    const messagePointBLS = await bls12_381.G2.hashToCurve(messageBytes, { DST });
-    const messageG2EIP = this.encodeG2Point(messagePointBLS);
-    return "0x" + Buffer.from(messageG2EIP).toString("hex");
-  }
-  /**
-   * Encode G2 Point to bytes for EIP-2537 format
-   */
-  encodeG2Point(point) {
-    const result = new Uint8Array(256);
-    const affine = point.toAffine();
-    const x0Bytes = this.hexToBytes(affine.x.c0.toString(16).padStart(96, "0"));
-    const x1Bytes = this.hexToBytes(affine.x.c1.toString(16).padStart(96, "0"));
-    const y0Bytes = this.hexToBytes(affine.y.c0.toString(16).padStart(96, "0"));
-    const y1Bytes = this.hexToBytes(affine.y.c1.toString(16).padStart(96, "0"));
-    result.set(x0Bytes, 16);
-    result.set(x1Bytes, 80);
-    result.set(y0Bytes, 144);
-    result.set(y1Bytes, 208);
-    return result;
-  }
-  hexToBytes(hex) {
-    if (hex.startsWith("0x")) hex = hex.slice(2);
-    const bytes = new Uint8Array(hex.length / 2);
-    for (let i = 0; i < hex.length; i += 2) {
-      bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
-    }
-    return bytes;
+    return generateMessagePoint(message);
   }
   /**
    * Pack cumulative Tier 2 signature (algId 0x04): P256 + BLS.
@@ -4124,23 +4174,7 @@ var BLSManager = class {
    *   [messagePointECDSA (65)]
    */
   packCumulativeT2Signature(data) {
-    const nodeIdsLength = ethers.solidityPacked(["uint256"], [data.nodeIds.length]);
-    const nodeIdsBytes = ethers.solidityPacked(
-      Array(data.nodeIds.length).fill("bytes32"),
-      data.nodeIds
-    );
-    return ethers.solidityPacked(
-      ["bytes1", "bytes", "bytes", "bytes", "bytes", "bytes", "bytes"],
-      [
-        "0x04",
-        data.p256Signature,
-        nodeIdsLength,
-        nodeIdsBytes,
-        data.blsSignature,
-        data.messagePoint,
-        data.messagePointSignature
-      ]
-    );
+    return packCumulativeT2Signature(data);
   }
   /**
    * Pack cumulative Tier 3 signature (algId 0x05): P256 + BLS + Guardian.
@@ -4152,24 +4186,7 @@ var BLSManager = class {
    *   [messagePointECDSA (65)] [guardianECDSA (65)]
    */
   packCumulativeT3Signature(data) {
-    const nodeIdsLength = ethers.solidityPacked(["uint256"], [data.nodeIds.length]);
-    const nodeIdsBytes = ethers.solidityPacked(
-      Array(data.nodeIds.length).fill("bytes32"),
-      data.nodeIds
-    );
-    return ethers.solidityPacked(
-      ["bytes1", "bytes", "bytes", "bytes", "bytes", "bytes", "bytes", "bytes"],
-      [
-        "0x05",
-        data.p256Signature,
-        nodeIdsLength,
-        nodeIdsBytes,
-        data.blsSignature,
-        data.messagePoint,
-        data.messagePointSignature,
-        data.guardianSignature
-      ]
-    );
+    return packCumulativeT3Signature(data);
   }
   /**
    * Request signature from a single node
@@ -4198,15 +4215,20 @@ var BLSManager = class {
 };
 
 // ../airaccount/src/client.ts
-var YAAAClient = class {
+var AirAccountClient = class {
   constructor(config) {
     this.config = config;
-    this.passkey = new PasskeyManager(config.apiURL, config.tokenProvider);
+    this.passkey = new PasskeyManager(
+      config.apiURL,
+      config.tokenProvider,
+      config.passkeyRoutes
+    );
     this.bls = new BLSManager(config.bls);
   }
   passkey;
   bls;
 };
+var YAAAClient = AirAccountClient;
 var CryptoUtil = class _CryptoUtil {
   static ALGORITHM = "aes-256-gcm";
   static KEY_LENGTH = 32;
@@ -4311,6 +4333,24 @@ var ERC4337Utils = class _ERC4337Utils {
     };
   }
 };
+function encodeAbiParams(types, values) {
+  const params = parseAbiParameters(types.join(", "));
+  return encodeAbiParameters(params, values);
+}
+function solidityPacked(types, values) {
+  return encodePacked(types, values);
+}
+function id(value) {
+  return keccak256$1(stringToBytes(value));
+}
+function keccak256(data) {
+  return keccak256$1(data);
+}
+function selectorFromId(signature) {
+  return id(signature).slice(0, 10);
+}
+
+// ../airaccount/src/core/erc4337/userop.builder.ts
 var UserOpBuilder = class _UserOpBuilder {
   // Basic defaults
   static DEFAULT_VERIFICATION_GAS_LIMIT = 100000n;
@@ -4347,23 +4387,23 @@ var UserOpBuilder = class _UserOpBuilder {
    * Hash the UserOperation for signing (ERC-4337 v0.7)
    */
   getUserOpHash(userOp, entryPoint, chainId) {
-    const encoded = ethers.AbiCoder.defaultAbiCoder().encode(
+    const encoded = encodeAbiParams(
       ["address", "uint256", "bytes32", "bytes32", "bytes32", "uint256", "bytes32", "bytes32"],
       [
         userOp.sender,
         userOp.nonce,
-        ethers.keccak256(userOp.initCode),
-        ethers.keccak256(userOp.callData),
+        keccak256(userOp.initCode),
+        keccak256(userOp.callData),
         userOp.accountGasLimits,
         userOp.preVerificationGas,
         userOp.gasFees,
-        ethers.keccak256(userOp.paymasterAndData)
+        keccak256(userOp.paymasterAndData)
       ]
     );
-    return ethers.keccak256(
-      ethers.AbiCoder.defaultAbiCoder().encode(
+    return keccak256(
+      encodeAbiParams(
         ["bytes32", "address", "uint256"],
-        [ethers.keccak256(encoded), entryPoint, chainId]
+        [keccak256(encoded), entryPoint, BigInt(chainId)]
       )
     );
   }
@@ -4403,8 +4443,10 @@ __export(src_exports, {
   ALG_CUMULATIVE_T3: () => ALG_CUMULATIVE_T3,
   ALG_ECDSA: () => ALG_ECDSA,
   ALG_P256: () => ALG_P256,
+  AirAccountClient: () => AirAccountClient,
   BLSManager: () => BLSManager,
   CryptoUtil: () => CryptoUtil,
+  DEFAULT_PASSKEY_ROUTES: () => DEFAULT_PASSKEY_ROUTES,
   ERC4337Utils: () => ERC4337Utils,
   PasskeyManager: () => PasskeyManager,
   UserOpBuilder: () => UserOpBuilder,
@@ -4427,6 +4469,6 @@ __export(src_exports, {
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
 
-export { ALG_BLS, ALG_CUMULATIVE_T2, ALG_CUMULATIVE_T3, ALG_ECDSA, ALG_P256, BLSManager, CryptoUtil, ERC4337Utils, PasskeyManager, UserOpBuilder, YAAAClient, algIdForTier, ecdsa, resolveTier, sha256, src_exports, weierstrass };
-//# sourceMappingURL=chunk-FUU7RIIA.js.map
-//# sourceMappingURL=chunk-FUU7RIIA.js.map
+export { ALG_BLS, ALG_CUMULATIVE_T2, ALG_CUMULATIVE_T3, ALG_ECDSA, ALG_P256, AirAccountClient, BLSManager, CryptoUtil, DEFAULT_PASSKEY_ROUTES, ERC4337Utils, PasskeyManager, UserOpBuilder, YAAAClient, algIdForTier, ecdsa, encodeAbiParams, keccak256, resolveTier, selectorFromId, sha256, solidityPacked, src_exports, weierstrass };
+//# sourceMappingURL=chunk-X3AMH53O.js.map
+//# sourceMappingURL=chunk-X3AMH53O.js.map