fix: remove hardcoded gas, fix estimation, sdk improvements

cspell-config/cspell-misc.txt

@@ -9,6 +9,7 @@ Nuxt
 nuxtjs
 testid
 vueuse
+ethereum
 
 // examples/bank-demo
 ctap
@@ -25,4 +26,3 @@ usdc
 // examples/nft-quest
 Fren
 fren
-trxn

examples/demo-app/pages/index.vue

@@ -40,7 +40,7 @@
 </template>
 
 <script lang="ts" setup>
-import { disconnect, getBalance, watchAccount, sendTransaction, createConfig, connect, reconnect, type GetBalanceReturnType } from "@wagmi/core";
+import { disconnect, getBalance, watchAccount, sendTransaction, createConfig, connect, reconnect, waitForTransactionReceipt, type GetBalanceReturnType } from "@wagmi/core";
 import { zksyncSsoConnector } from "zksync-sso/connector";
 import { zksyncInMemoryNode } from "@wagmi/core/chains";
 import { createWalletClient, http, parseEther, type Address } from "viem";
@@ -142,15 +142,17 @@ const sendTokens = async () => {
   errorMessage.value = "";
   isSendingEth.value = true;
   try {
-    await sendTransaction(wagmiConfig, {
+    const transactionHash = await sendTransaction(wagmiConfig, {
       to: testTransferTarget,
       value: parseEther("0.1"),
-      gas: 100_000_000n,
     });
 
     balance.value = await getBalance(wagmiConfig, {
       address: address.value,
     });
+
+    const receipt = await waitForTransactionReceipt(wagmiConfig, { hash: transactionHash });
+    if (receipt.status === "reverted") throw new Error("Transaction reverted");
   } catch (error) {
     // eslint-disable-next-line no-console
     console.error("Transaction failed:", error);

examples/nft-quest/composables/useMintNft.ts

@@ -1,5 +1,5 @@
-import { estimateGas, waitForTransactionReceipt, writeContract } from "@wagmi/core";
-import { type Address, encodeFunctionData } from "viem";
+import { waitForTransactionReceipt, writeContract } from "@wagmi/core";
+import type { Address } from "viem";
 import { getGeneralPaymasterInput } from "viem/zksync";
 
 export const useMintNft = async (_address: MaybeRef<Address>) => {
@@ -10,24 +10,11 @@ export const useMintNft = async (_address: MaybeRef<Address>) => {
     const { wagmiConfig } = storeToRefs(useConnectorStore());
 
     const mintingForAddress = address.value;
-    const data = encodeFunctionData({
-      abi: nftAbi,
-      functionName: "mint",
-      args: [address.value],
-    });
-
-    const estimatedGas = await estimateGas(wagmiConfig.value, {
-      to: runtimeConfig.public.contracts.nft as Address,
-      chainId: runtimeConfig.public.chain.id,
-      data,
-    });
-
     const transactionHash = await writeContract(wagmiConfig.value, {
       address: runtimeConfig.public.contracts.nft as Address,
       abi: nftAbi,
       functionName: "mint",
       args: [mintingForAddress],
-      gas: estimatedGas + (estimatedGas / 100n * 25n), // gas may be underestimated
       paymaster: runtimeConfig.public.contracts.paymaster as Address,
       paymasterInput: getGeneralPaymasterInput({ innerInput: "0x" }),
     });

examples/nft-quest/nuxt.config.ts

@@ -102,4 +102,14 @@ export default defineNuxtConfig({
       },
     },
   },
+
+  vite: {
+    css: {
+      preprocessorOptions: {
+        scss: {
+          api: "modern", // Fix warning: "The legacy JS API is deprecated and will be removed in Dart Sass 2.0.0"
+        },
+      },
+    },
+  },
 });

packages/auth-server/nuxt.config.ts

@@ -57,4 +57,14 @@ export default defineNuxtConfig({
       chainId: parseInt(process.env.NUXT_PUBLIC_DEFAULT_CHAIN_ID || "") || zksyncInMemoryNode.id,
     },
   },
+
+  vite: {
+    css: {
+      preprocessorOptions: {
+        scss: {
+          api: "modern", // Fix warning: "The legacy JS API is deprecated and will be removed in Dart Sass 2.0.0"
+        },
+      },
+    },
+  },
 });

packages/contracts/test/PasskeyModule.ts

@@ -220,9 +220,6 @@ async function rawVerify(
   const hashedData = await toHash(concat([authDataBuffer, clientDataHash]));
   const rs = unwrapEC2Signature(toBuffer(b64SignedChallange));
   const publicKeys = await getPublicKey(publicKeyEs256Bytes);
-  /* console.log("externalSignature", ethers.hexlify(hashedData));
-  console.log("rs", ethers.hexlify(rs[0]), ethers.hexlify(rs[1]));
-  console.log("pubkey xy", publicKeys); */
   return await passkeyValidator.rawVerify(hashedData, rs, publicKeys);
 }
 

packages/contracts/test/SessionKeyTest.ts

@@ -311,7 +311,6 @@ describe("SessionKeyModule tests", function () {
       await tester.sendTxSuccess({
         to: sessionTarget,
         value: parseEther("0.01"),
-        gasLimit: 10_000_000n,
       });
       expect(await provider.getBalance(sessionTarget))
         .to.equal(parseEther("0.01"), "session target should have received the funds");

packages/sdk/.gitignore

@@ -2,4 +2,5 @@ dist
 
 node_modules
 tsconfig*.tsbuildinfo
-.DS_Store
+.DS_Store
+README.md

packages/sdk/prepare-package.mjs

@@ -1,20 +1,17 @@
 import { promises as fs } from "fs";
 import path from "path";
 
-// Define the path to the package.json
-const packageJsonPath = path.resolve("./package.json");
-console.log(packageJsonPath);
-
-// Get the version from environment variables
 const version = process.env.INPUT_VERSION;
 if (!version) {
   console.error("Error: INPUT_VERSION is required.");
   process.exit(1);
 }
 
+const packageJsonPath = path.resolve("./package.json");
+const readmePath = path.resolve("../../README.md"); // copy readme into current path
+
 async function preparePackageJson() {
   try {
-    // Read the existing package.json
     const packageJsonData = await fs.readFile(packageJsonPath, "utf8");
     const packageJson = JSON.parse(packageJsonData);
 
@@ -36,4 +33,14 @@ async function preparePackageJson() {
   }
 }
 
+async function copyReadme() {
+  try {
+    await fs.copyFile(readmePath, path.resolve("./README.md"));
+  } catch (error) {
+    console.error("Error copying README.md:", error);
+    process.exit(1);
+  }
+}
+
 preparePackageJson();
+copyReadme();

packages/sdk/src/client-auth-server/Signer.ts

@@ -20,6 +20,7 @@ type Account = {
 interface SignerInterface {
   accounts: Address[];
   chain: Chain;
+  getClient(parameters?: { chainId?: number }): ZksyncSsoSessionClient;
   handshake(): Promise<Address[]>;
   request<TMethod extends Method>(request: RequestArguments<TMethod>): Promise<ExtractReturnType<TMethod>>;
   disconnect: () => Promise<void>;
@@ -83,6 +84,15 @@ export class Signer implements SignerInterface {
     }
   }
 
+  getClient(parameters?: { chainId?: number }) {
+    const chainId = parameters?.chainId || this.chain.id;
+    const chain = this.chains.find((e) => e.id === chainId);
+    if (!chain) throw new Error(`Chain with id ${chainId} is not supported`);
+
+    if (!this.walletClient) throw new Error("Wallet client is not created");
+    return this.walletClient;
+  }
+
   private get account(): Account | null {
     const account = this._account.get();
     if (!account) return null;

packages/sdk/src/client-auth-server/WalletProvider.ts

@@ -52,6 +52,10 @@ export class WalletProvider extends EventEmitter implements ProviderInterface {
     return this.signer.accounts.length > 0;
   }
 
+  public getClient(parameters?: { chainId?: number }) {
+    return this.signer.getClient(parameters);
+  }
+
   public async request<M extends Method>(request: RequestArguments<M>): Promise<ExtractReturnType<M>> {
     try {
       switch (request.method) {

packages/sdk/src/client-auth-server/interface.ts

@@ -1,6 +1,7 @@
 import { EventEmitter } from "eventemitter3";
 import type { RpcSchema as RpcSchemaGeneric } from "viem";
 
+import type { ZksyncSsoSessionClient } from "../client/index.js";
 import type { ExtractParams, ExtractReturnType, Method, RpcSchema } from "./rpc.js";
 
 export interface RequestArguments<M extends Method<TSchema>, TSchema extends RpcSchemaGeneric = RpcSchema> {
@@ -26,6 +27,7 @@ interface ProviderConnectInfo {
 export interface ProviderInterface extends EventEmitter {
   request<M extends Method>(args: RequestArguments<M>): Promise<ExtractReturnType<M>>;
   disconnect(): Promise<void>;
+  getClient(parameters?: { chainId?: number }): Promise<ZksyncSsoSessionClient> | ZksyncSsoSessionClient;
   on(event: "connect", listener: (info: ProviderConnectInfo) => void): this;
   on(event: "disconnect", listener: (error: ProviderRpcError) => void): this;
   on(event: "chainChanged", listener: (chainId: string) => void): this;

packages/sdk/src/client/actions/sendEip712Transaction.ts

@@ -0,0 +1,149 @@
+import { type Account, assertRequest, type AssertRequestErrorType, type Chain, type Client, type ExactPartial, type Hash, type PublicActions, type RpcSchema, type SendTransactionRequest, type Transport, type WalletActions } from "viem";
+import { parseAccount } from "viem/accounts";
+import { prepareTransactionRequest, sendRawTransaction } from "viem/actions";
+import { type ChainEIP712, type SendEip712TransactionParameters, type SendEip712TransactionReturnType, type SendTransactionParameters, zksync } from "viem/zksync";
+
+import { InvalidEip712TransactionError, type InvalidEip712TransactionErrorType } from "../utils/assertEip712Transaction.js";
+import { isEIP712Transaction } from "../utils/isEip712Transaction.js";
+
+/**
+ * Creates, signs, and sends a new EIP712 transaction to the network.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SendEip712TransactionParameters}
+ * @returns The [Transaction](https://viem.sh/docs/glossary/terms#transaction) hash. {@link SendTransactionReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { zksync } from 'viem/chains'
+ * import { sendEip712Transaction } from 'viem/zksync'
+ *
+ * const client = createWalletClient({
+ *   chain: zksync,
+ *   transport: custom(window.ethereum),
+ * })
+ * const hash = await sendEip712Transaction(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { zksync } from 'viem/chains'
+ * import { sendEip712Transaction } from 'viem/zksync'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: zksync,
+ *   transport: http(),
+ * })
+ *
+ * const hash = await sendEip712Transaction(client, {
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * })
+ */
+export async function sendEip712Transaction<
+  chain extends ChainEIP712 | undefined,
+  account extends Account | undefined,
+  const request extends SendTransactionRequest<chain, chainOverride>,
+  chainOverride extends ChainEIP712 | undefined = undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: SendEip712TransactionParameters<
+    chain,
+    account,
+    chainOverride,
+    request
+  >,
+): Promise<SendEip712TransactionReturnType> {
+  const {
+    account: account_ = client.account,
+    chain = client.chain,
+    ...rest
+  } = parameters;
+
+  if (!account_)
+    throw new Error("Account not found.");
+  const account = parseAccount(account_);
+
+  assertEip712Request(parameters);
+
+  const request = await getAction(
+    client,
+    prepareTransactionRequest,
+    "prepareTransactionRequest",
+  )({
+    account,
+    chain,
+    nonceManager: account.nonceManager,
+    ...rest,
+  } as any);
+
+  const serializer = chain?.serializers?.transaction;
+  const serializedTransaction = (await account.signTransaction!(request, {
+    serializer,
+  })) as Hash;
+
+  return await getAction(
+    client,
+    sendRawTransaction,
+    "sendRawTransaction",
+  )({
+    serializedTransaction,
+  });
+}
+
+/**
+ * Retrieves and returns an action from the client (if exists), and falls
+ * back to the tree-shakable action.
+ *
+ * Useful for extracting overridden actions from a client (ie. if a consumer
+ * wants to override the `sendTransaction` implementation).
+ */
+export function getAction<
+  transport extends Transport,
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  rpcSchema extends RpcSchema | undefined,
+  extended extends { [key: string]: unknown },
+  client extends Client<transport, chain, account, rpcSchema, extended>,
+  parameters,
+  returnType,
+>(
+  client: client,
+  actionFn: (_: any, parameters: parameters) => returnType,
+  // cspell:ignore minifiers
+  // Some minifiers drop `Function.prototype.name`, or replace it with short letters,
+  // meaning that `actionFn.name` will not always work. For that case, the consumer
+  // needs to pass the name explicitly.
+  name: keyof PublicActions | keyof WalletActions | (string & {}),
+): (parameters: parameters) => returnType {
+  const action_implicit = client[actionFn.name];
+  if (typeof action_implicit === "function")
+    return action_implicit as (params: parameters) => returnType;
+
+  const action_explicit = client[name];
+  if (typeof action_explicit === "function")
+    return action_explicit as (params: parameters) => returnType;
+
+  return (params) => actionFn(client, params);
+}
+
+type AssertEip712RequestParameters = ExactPartial<
+  SendTransactionParameters<typeof zksync>
+>;
+
+/** @internal */
+export type AssertEip712RequestErrorType =
+  | InvalidEip712TransactionErrorType
+  | AssertRequestErrorType;
+
+export function assertEip712Request(args: AssertEip712RequestParameters) {
+  if (!isEIP712Transaction(args as any))
+    throw new InvalidEip712TransactionError();
+  assertRequest(args as any);
+}