@aastar/sdk 0.20.5 → 0.20.7

package/dist/{chunk-4KRQXOTI.js → chunk-X3AMH53O.js}

@@ -1,26 +1,102 @@
 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';
 
-// ../airaccount/dist/index.js
-var dist_exports = {};
-__export(dist_exports, {
-  ALG_BLS: () => ALG_BLS,
-  ALG_CUMULATIVE_T2: () => ALG_CUMULATIVE_T2,
-  ALG_CUMULATIVE_T3: () => ALG_CUMULATIVE_T3,
-  ALG_ECDSA: () => ALG_ECDSA,
-  ALG_P256: () => ALG_P256,
-  BLSManager: () => BLSManager,
-  CryptoUtil: () => CryptoUtil,
-  ERC4337Utils: () => ERC4337Utils,
-  PasskeyManager: () => PasskeyManager,
-  UserOpBuilder: () => UserOpBuilder,
-  YAAAClient: () => YAAAClient,
-  algIdForTier: () => algIdForTier,
-  resolveTier: () => resolveTier
-});
+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;
+  routes;
+  constructor(baseURL, tokenProvider, routes) {
+    this.routes = { ...DEFAULT_PASSKEY_ROUTES, ...routes };
+    this.api = axios2.create({
+      baseURL,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    if (tokenProvider) {
+      this.api.interceptors.request.use((config) => {
+        const token = tokenProvider();
+        if (token) {
+          config.headers.Authorization = `Bearer ${token}`;
+        }
+        return config;
+      });
+    }
+  }
+  /**
+   * Complete Passkey Registration Flow
+   */
+  async register(params) {
+    const beginResponse = await this.api.post(
+      this.routes.registerBegin,
+      params
+    );
+    const credential = await startRegistration(beginResponse.data);
+    const completeResponse = await this.api.post(this.routes.registerComplete, {
+      email: params.email,
+      username: params.username,
+      password: params.password,
+      credential
+    });
+    return completeResponse.data;
+  }
+  /**
+   * Complete Passkey Login/Authentication Flow
+   */
+  async authenticate(params) {
+    const beginResponse = await this.api.post(
+      this.routes.loginBegin,
+      params
+    );
+    const credential = await startAuthentication(beginResponse.data);
+    const completeResponse = await this.api.post(this.routes.loginComplete, { credential });
+    return completeResponse.data;
+  }
+  /**
+   * Verify a transaction (Sign UserOpHash) with Passkey
+   * Returns the verification credential needed for the transaction
+   */
+  async verifyTransaction(params) {
+    const beginResponse = await this.api.post(
+      this.routes.transactionVerifyBegin,
+      { transaction: params }
+    );
+    const { userOpHash, ...authOptions } = beginResponse.data;
+    const credential = await startAuthentication(authOptions);
+    return {
+      credential,
+      userOpHash
+      // Return pre-calculated hash to ensure consistency
+    };
+  }
+  /**
+   * Add a new device (Passkey) to existing account
+   */
+  async addDevice(params) {
+    const beginResponse = await this.api.post(
+      this.routes.deviceBegin,
+      params
+    );
+    const credential = await startRegistration(beginResponse.data);
+    const completeResponse = await this.api.post(this.routes.deviceComplete, {
+      email: params.email,
+      password: params.password,
+      credential
+    });
+    return completeResponse.data.passkey;
+  }
+};
 
 // ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/utils.js
 function isBytes(a) {
@@ -3954,88 +4030,93 @@ function mapToG2(scalars) {
   const { x, y } = G2_SWU(Fp2.fromBigTuple(scalars));
   return isogenyMapG2(x, y);
 }
-var PasskeyManager = class {
-  api;
-  constructor(baseURL, tokenProvider) {
-    this.api = axios2.create({
-      baseURL,
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-    if (tokenProvider) {
-      this.api.interceptors.request.use((config) => {
-        const token = tokenProvider();
-        if (token) {
-          config.headers.Authorization = `Bearer ${token}`;
-        }
-        return config;
-      });
-    }
-  }
-  /**
-   * Complete Passkey Registration Flow
-   */
-  async register(params) {
-    const beginResponse = await this.api.post(
-      "/auth/passkey/register/begin",
-      params
-    );
-    const credential = await startRegistration(beginResponse.data);
-    const completeResponse = await this.api.post("/auth/passkey/register/complete", {
-      email: params.email,
-      username: params.username,
-      password: params.password,
-      credential
-    });
-    return completeResponse.data;
-  }
-  /**
-   * Complete Passkey Login/Authentication Flow
-   */
-  async authenticate(params) {
-    const beginResponse = await this.api.post(
-      "/auth/passkey/login/begin",
-      params
-    );
-    const credential = await startAuthentication(beginResponse.data);
-    const completeResponse = await this.api.post("/auth/passkey/login/complete", { credential });
-    return completeResponse.data;
-  }
-  /**
-   * Verify a transaction (Sign UserOpHash) with Passkey
-   * Returns the verification credential needed for the transaction
-   */
-  async verifyTransaction(params) {
-    const beginResponse = await this.api.post(
-      "/auth/transaction/verify/begin",
-      { transaction: params }
-    );
-    const { userOpHash, ...authOptions } = beginResponse.data;
-    const credential = await startAuthentication(authOptions);
-    return {
-      credential,
-      userOpHash
-      // Return pre-calculated hash to ensure consistency
-    };
-  }
-  /**
-   * Add a new device (Passkey) to existing account
-   */
-  async addDevice(params) {
-    const beginResponse = await this.api.post(
-      "/auth/device/passkey/begin",
-      params
-    );
-    const credential = await startRegistration(beginResponse.data);
-    const completeResponse = await this.api.post("/auth/device/passkey/complete", {
-      email: params.email,
-      password: params.password,
-      credential
-    });
-    return completeResponse.data.passkey;
-  }
-};
+
+// ../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;
   constructor(config) {
@@ -4075,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.
@@ -4139,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.
@@ -4167,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
@@ -4211,15 +4213,22 @@ var BLSManager = class {
     return sig.startsWith("0x") ? sig : `0x${sig}`;
   }
 };
-var YAAAClient = class {
+
+// ../airaccount/src/client.ts
+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;
@@ -4261,6 +4270,8 @@ var CryptoUtil = class _CryptoUtil {
     return crypto.randomBytes(32).toString("hex");
   }
 };
+
+// ../airaccount/src/core/erc4337/utils.ts
 var ERC4337Utils = class _ERC4337Utils {
   static packAccountGasLimits(verificationGasLimit, callGasLimit) {
     const vgl = BigInt(verificationGasLimit);
@@ -4322,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;
@@ -4358,33 +4387,37 @@ 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)]
       )
     );
   }
   // Legacy v0.6 hashing support could be added here if needed
 };
+
+// ../airaccount/src/core/tier/types.ts
 var ALG_BLS = 1;
 var ALG_ECDSA = 2;
 var ALG_P256 = 3;
 var ALG_CUMULATIVE_T2 = 4;
 var ALG_CUMULATIVE_T3 = 5;
+
+// ../airaccount/src/core/tier/tier-router.ts
 function resolveTier(value, config) {
   if (config.tier1Limit === 0n && config.tier2Limit === 0n) return 1;
   if (config.tier1Limit > 0n && value <= config.tier1Limit) return 1;
@@ -4401,6 +4434,26 @@ function algIdForTier(tier) {
       return ALG_CUMULATIVE_T3;
   }
 }
+
+// ../airaccount/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ALG_BLS: () => ALG_BLS,
+  ALG_CUMULATIVE_T2: () => ALG_CUMULATIVE_T2,
+  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,
+  YAAAClient: () => YAAAClient,
+  algIdForTier: () => algIdForTier,
+  resolveTier: () => resolveTier
+});
 /*! Bundled license information:
 
 @noble/hashes/utils.js:
@@ -4416,6 +4469,6 @@ function algIdForTier(tier) {
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
 
-export { BLSManager, CryptoUtil, ERC4337Utils, PasskeyManager, UserOpBuilder, YAAAClient, bls12_381, dist_exports, ecdsa, sha256, weierstrass };
-//# sourceMappingURL=chunk-4KRQXOTI.js.map
-//# sourceMappingURL=chunk-4KRQXOTI.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