@veridex/sdk 1.1.5 → 1.1.7

package/dist/chains/starknet/index.d.mts

@@ -1,5 +1,5 @@
 import { a as SessionKey } from '../../types-C564CfsE.mjs';
-import { C as ChainClient, a as ChainConfig, T as TransferParams, E as ExecuteParams, B as BridgeParams, W as WebAuthnSignature, D as DispatchResult, V as VaultCreationResult, x as RegisterSessionParams, y as RevokeSessionParams, S as SessionValidationResult } from '../../types-DP2CQT8p.mjs';
+import { C as ChainClient, a as ChainConfig, T as TransferParams, E as ExecuteParams, B as BridgeParams, W as WebAuthnSignature, b as DispatchResult, V as VaultCreationResult, y as RegisterSessionParams, z as RevokeSessionParams, S as SessionValidationResult } from '../../types-CdlEbixV.mjs';
 import { RpcProvider } from 'starknet';
 
 /**
@@ -35,6 +35,13 @@ interface StarknetClientConfig {
     hubRpcUrl?: string;
     hubContractAddress?: string;
 }
+interface StarknetSessionTransferParams {
+    session: SessionKey;
+    recipient: string;
+    amount: bigint;
+    relayerUrl: string;
+    validForSeconds?: number;
+}
 declare class StarknetClient implements ChainClient {
     private config;
     private provider;
@@ -85,6 +92,7 @@ declare class StarknetClient implements ChainClient {
      * @throws Error - Session management must be done via Hub chain
      */
     revokeSession(_params: RevokeSessionParams): Promise<void>;
+    executeSessionTransfer(params: StarknetSessionTransferParams): Promise<DispatchResult>;
     /**
      * Check if a session is active by querying the Hub
      * This method queries the Hub contract directly for session validation
@@ -168,4 +176,30 @@ declare class StarknetClient implements ChainClient {
     isProtocolPaused(): Promise<boolean>;
 }
 
-export { StarknetClient, type StarknetClientConfig };
+interface StarknetSessionTransferContext {
+    spokeAddress: string;
+    vaultAddress: string;
+    authorizedCaller: string;
+    userKeyHash: string;
+    nonceCounter: bigint;
+    validUntil: bigint;
+    recipient: string;
+    amount: bigint;
+}
+interface StarknetSessionTransferSignature {
+    digest: string;
+    sessionKeyHash: string;
+    publicKeyX: string;
+    publicKeyY: string;
+    r: string;
+    s: string;
+}
+declare function buildStarknetSessionTransferChallenge(context: StarknetSessionTransferContext, publicKey: Uint8Array): {
+    digest: string;
+    sessionKeyHash: string;
+    publicKeyX: string;
+    publicKeyY: string;
+};
+declare function signStarknetSessionTransfer(context: StarknetSessionTransferContext, privateKey: Uint8Array): StarknetSessionTransferSignature;
+
+export { StarknetClient, type StarknetClientConfig, type StarknetSessionTransferContext, type StarknetSessionTransferParams, type StarknetSessionTransferSignature, buildStarknetSessionTransferChallenge, signStarknetSessionTransfer };

package/dist/chains/starknet/index.js

@@ -20,11 +20,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/chains/starknet/index.ts
 var starknet_exports = {};
 __export(starknet_exports, {
-  StarknetClient: () => StarknetClient
+  StarknetClient: () => StarknetClient,
+  buildStarknetSessionTransferChallenge: () => buildStarknetSessionTransferChallenge,
+  signStarknetSessionTransfer: () => signStarknetSessionTransfer
 });
 module.exports = __toCommonJS(starknet_exports);
 
 // src/chains/starknet/StarknetClient.ts
+var import_ethers3 = require("ethers");
 var import_crypto = require("crypto");
 var import_starknet = require("starknet");
 
@@ -101,6 +104,123 @@ function padTo32Bytes(address) {
   }
   return "0x" + hex.padStart(64, "0");
 }
+var CHALLENGE_DOMAIN = import_ethers.ethers.sha256(import_ethers.ethers.toUtf8Bytes("veridex.challenge.v1"));
+
+// src/core/relayerUrl.ts
+var API_ROOT = "/api/v1";
+function trimTrailingSlashes(value) {
+  return value.trim().replace(/\/+$/, "");
+}
+function buildRelayerApiUrl(baseUrl, path) {
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  const trimmed = trimTrailingSlashes(baseUrl);
+  if (!trimmed) {
+    return `${API_ROOT}${normalizedPath}`;
+  }
+  if (trimmed.startsWith("/")) {
+    if (/\/api\/v1$/i.test(trimmed) || /\/api\/auth\/relay$/i.test(trimmed)) {
+      return `${trimmed}${normalizedPath}`;
+    }
+    return `${trimmed}${normalizedPath}`;
+  }
+  try {
+    const url = new URL(trimmed);
+    if (/\/api\/v1$/i.test(url.pathname) || /\/api\/auth\/relay$/i.test(url.pathname)) {
+      url.pathname = `${url.pathname.replace(/\/+$/, "")}${normalizedPath}`;
+      return url.toString();
+    }
+    if (!url.pathname || url.pathname === "/") {
+      url.pathname = `${API_ROOT}${normalizedPath}`;
+      return url.toString();
+    }
+    url.pathname = `${url.pathname.replace(/\/+$/, "")}${normalizedPath}`;
+    return url.toString();
+  } catch {
+    if (/\/api\/v1$/i.test(trimmed) || /\/api\/auth\/relay$/i.test(trimmed)) {
+      return `${trimmed}${normalizedPath}`;
+    }
+    return `${trimmed}${API_ROOT}${normalizedPath}`;
+  }
+}
+
+// src/chains/starknet/session.ts
+var import_ethers2 = require("ethers");
+var STARKNET_VERIDEX_CHAIN_ID = 4;
+var TIER_T1_ATTESTED = 2;
+var SESSION_ACTION_VERSION = 1;
+var SESSION_ACTION_DOMAIN = import_ethers2.ethers.keccak256(
+  import_ethers2.ethers.toUtf8Bytes("veridex.session.action.v1")
+);
+var CHALLENGE_DOMAIN2 = import_ethers2.ethers.sha256(import_ethers2.ethers.toUtf8Bytes("veridex.challenge.v1"));
+function buildStarknetSessionTransferChallenge(context, publicKey) {
+  if (publicKey.length !== 65 || publicKey[0] !== 4) {
+    throw new Error("Starknet session public key must be 65-byte uncompressed secp256k1");
+  }
+  if (context.nonceCounter < 0n || context.nonceCounter > 0xffffffffffffffffn) {
+    throw new Error("Starknet session nonce must fit u64");
+  }
+  if (context.validUntil <= 0n || context.validUntil > 0xffffffffffffffffn) {
+    throw new Error("Starknet session validUntil must fit non-zero u64");
+  }
+  if (context.amount <= 0n) {
+    throw new Error("Starknet session transfer amount must be positive");
+  }
+  const publicKeyX = import_ethers2.ethers.hexlify(publicKey.slice(1, 33));
+  const publicKeyY = import_ethers2.ethers.hexlify(publicKey.slice(33, 65));
+  const sessionKeyHash = import_ethers2.ethers.keccak256(publicKey);
+  const actionHash = import_ethers2.ethers.solidityPackedKeccak256(
+    ["uint8", "bytes32", "bytes32", "uint256"],
+    [1, import_ethers2.ethers.ZeroHash, toBytes32(context.recipient), context.amount]
+  );
+  const actionCommitment = import_ethers2.ethers.solidityPackedKeccak256(
+    ["bytes32", "uint8", "bytes32", "bytes32", "bytes32", "bytes32", "uint64", "bytes32"],
+    [
+      SESSION_ACTION_DOMAIN,
+      SESSION_ACTION_VERSION,
+      toBytes32(context.userKeyHash),
+      sessionKeyHash,
+      toBytes32(context.vaultAddress),
+      toBytes32(context.authorizedCaller),
+      context.validUntil,
+      actionHash
+    ]
+  );
+  const digest = import_ethers2.ethers.sha256(import_ethers2.ethers.solidityPacked(
+    ["bytes32", "uint8", "uint8", "uint32", "bytes32", "uint32", "uint64", "bytes32"],
+    [
+      CHALLENGE_DOMAIN2,
+      1,
+      TIER_T1_ATTESTED,
+      STARKNET_VERIDEX_CHAIN_ID,
+      toBytes32(context.spokeAddress),
+      STARKNET_VERIDEX_CHAIN_ID,
+      context.nonceCounter,
+      actionCommitment
+    ]
+  ));
+  return { digest, sessionKeyHash, publicKeyX, publicKeyY };
+}
+function signStarknetSessionTransfer(context, privateKey) {
+  if (privateKey.length !== 32) {
+    throw new Error("Starknet session private key must be 32 bytes");
+  }
+  const signingKey = new import_ethers2.ethers.SigningKey(privateKey);
+  const publicKey = import_ethers2.ethers.getBytes(signingKey.publicKey);
+  const challenge = buildStarknetSessionTransferChallenge(context, publicKey);
+  const signature = signingKey.sign(challenge.digest);
+  return {
+    ...challenge,
+    r: signature.r,
+    s: signature.s
+  };
+}
+function toBytes32(value) {
+  const bytes = import_ethers2.ethers.getBytes(value);
+  if (bytes.length > 32) {
+    throw new Error(`Value exceeds 32 bytes: ${value}`);
+  }
+  return import_ethers2.ethers.zeroPadValue(bytes, 32);
+}
 
 // src/chains/starknet/StarknetClient.ts
 var U128_MAX = BigInt("0x100000000000000000000000000000000");
@@ -167,41 +287,16 @@ var StarknetClient = class {
     );
   }
   async dispatchGasless(signature, publicKeyX, publicKeyY, targetChain, actionPayload, nonce, relayerUrl) {
-    const keyHash = this.computeKeyHash(publicKeyX, publicKeyY);
-    const request = {
-      signature: {
-        r: "0x" + signature.r.toString(16).padStart(64, "0"),
-        s: "0x" + signature.s.toString(16).padStart(64, "0"),
-        authenticatorData: signature.authenticatorData,
-        clientDataJSON: signature.clientDataJSON,
-        challengeIndex: signature.challengeIndex,
-        typeIndex: signature.typeIndex
-      },
-      publicKeyX: "0x" + publicKeyX.toString(16).padStart(64, "0"),
-      publicKeyY: "0x" + publicKeyY.toString(16).padStart(64, "0"),
-      targetChain,
-      // 50001 for Starknet
-      actionPayload,
-      userNonce: Number(nonce)
-    };
-    const response = await fetch(`${relayerUrl}/api/v1/submit`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(request)
-    });
-    if (!response.ok) {
-      const errorText = await response.text().catch(() => "Unknown error");
-      throw new Error(
-        `Relayer submission failed: ${response.status} ${response.statusText}. Error: ${errorText}`
-      );
-    }
-    const result = await response.json();
-    return {
-      transactionHash: result.transactionHash ?? result.txHash ?? result.hubTxHash,
-      sequence: BigInt(result.sequence || 0),
-      userKeyHash: keyHash,
-      targetChain
-    };
+    void signature;
+    void publicKeyX;
+    void publicKeyY;
+    void targetChain;
+    void actionPayload;
+    void nonce;
+    void relayerUrl;
+    throw new Error(
+      "ChainClient.dispatchGasless() cannot bind v3 destination metadata. Use VeridexSDK.transferViaRelayer() or bridgeViaRelayer()."
+    );
   }
   // Note: getVaultAddress is now defined in the Social Recovery section below
   // with enhanced spoke contract querying support.
@@ -337,6 +432,80 @@ var StarknetClient = class {
       "Session revocation must be performed on the Hub chain (Base). Use EVMClient connected to the Hub to call revokeSession()."
     );
   }
+  async executeSessionTransfer(params) {
+    const derivedPublicKey = new import_ethers3.ethers.SigningKey(params.session.privateKey).publicKey;
+    const storedPublicKey = import_ethers3.ethers.hexlify(params.session.publicKey);
+    if (derivedPublicKey.toLowerCase() !== storedPublicKey.toLowerCase()) {
+      throw new Error("Starknet session public and private keys do not match");
+    }
+    if (import_ethers3.ethers.keccak256(params.session.publicKey).toLowerCase() !== params.session.keyHash.toLowerCase()) {
+      throw new Error("Starknet session key hash does not match its public key");
+    }
+    const validForSeconds = params.validForSeconds ?? 60;
+    if (!Number.isSafeInteger(validForSeconds) || validForSeconds < 1 || validForSeconds > 600) {
+      throw new Error("Starknet session signature validity must be 1-600 seconds");
+    }
+    if (params.session.chainScopes.length > 0 && !params.session.chainScopes.includes(this.config.wormholeChainId)) {
+      throw new Error(`Session is not scoped to Starknet chain ${this.config.wormholeChainId}`);
+    }
+    if (params.session.maxValue === 0n || params.amount > params.session.maxValue) {
+      throw new Error("Starknet session transfer exceeds its bounded grant");
+    }
+    const contextUrl = new URL(buildRelayerApiUrl(params.relayerUrl, "/starknet/session/context"));
+    contextUrl.searchParams.set("chainId", String(this.config.wormholeChainId));
+    contextUrl.searchParams.set("userKeyHash", params.session.userKeyHash);
+    contextUrl.searchParams.set("sessionKeyHash", params.session.keyHash);
+    const contextResponse = await fetch(contextUrl);
+    if (!contextResponse.ok) {
+      throw new Error(`Failed to load Starknet session context: ${contextResponse.status}`);
+    }
+    const context = await contextResponse.json();
+    const nonceCounter = BigInt(context.nonceCounter);
+    const validUntil = BigInt(Math.floor(Date.now() / 1e3) + validForSeconds);
+    if (validUntil > BigInt(Math.floor(params.session.expiry / 1e3))) {
+      throw new Error("Starknet session signature deadline exceeds session expiry");
+    }
+    const signed = signStarknetSessionTransfer({
+      spokeAddress: context.spokeAddress,
+      vaultAddress: context.vaultAddress,
+      authorizedCaller: context.authorizedCaller,
+      userKeyHash: params.session.userKeyHash,
+      nonceCounter,
+      validUntil,
+      recipient: params.recipient,
+      amount: params.amount
+    }, params.session.privateKey);
+    const executeResponse = await fetch(
+      buildRelayerApiUrl(params.relayerUrl, "/starknet/session/execute"),
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          targetChain: this.config.wormholeChainId,
+          userKeyHash: params.session.userKeyHash,
+          sessionKeyHash: signed.sessionKeyHash,
+          sessionSignatureR: signed.r,
+          sessionSignatureS: signed.s,
+          sessionPublicKeyX: signed.publicKeyX,
+          sessionPublicKeyY: signed.publicKeyY,
+          nonceCounter: nonceCounter.toString(),
+          validUntil: validUntil.toString(),
+          recipient: params.recipient,
+          amount: params.amount.toString()
+        })
+      }
+    );
+    const result = await executeResponse.json();
+    if (!executeResponse.ok || !result.success) {
+      throw new Error(result.error ?? `Starknet session execution failed: ${executeResponse.status}`);
+    }
+    return {
+      transactionHash: result.transactionHash,
+      sequence: 0n,
+      userKeyHash: params.session.userKeyHash,
+      targetChain: this.config.wormholeChainId
+    };
+  }
   /**
    * Check if a session is active by querying the Hub
    * This method queries the Hub contract directly for session validation
@@ -517,6 +686,8 @@ var StarknetClient = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  StarknetClient
+  StarknetClient,
+  buildStarknetSessionTransferChallenge,
+  signStarknetSessionTransfer
 });
 //# sourceMappingURL=index.js.map