@cowprotocol/sdk-viem-adapter 0.2.0-beta.0 → 0.2.0

package/README.md

@@ -24,15 +24,17 @@ pnpm add @cowprotocol/sdk-viem-adapter
 
 ```typescript
 import { ViemAdapter } from '@cowprotocol/sdk-viem-adapter'
-import { http, createWalletClient, privateKeyToAccount } from 'viem'
+import { http, createPublicClient, privateKeyToAccount } from 'viem'
 import { sepolia } from 'viem/chains'
 
 // Create account and transport
 const account = privateKeyToAccount('YOUR_PRIVATE_KEY' as `0x${string}`)
 const transport = http('YOUR_RPC_URL')
+const provider = createPublicClient({ chain: sepolia, transport })
 
 // Initialize the adapter
-const adapter = new ViemAdapter({ chain: sepolia, transport, account })
+// You also can set `walletClient` instead of `signer` using `useWalletClient` from wagmi
+const adapter = new ViemAdapter({ provider, signer: account })
 ```
 
 ### Using with CoW SDK
@@ -40,13 +42,15 @@ const adapter = new ViemAdapter({ chain: sepolia, transport, account })
 ```typescript
 import { CowSdk, SupportedChainId } from '@cowprotocol/cow-sdk'
 import { ViemAdapter } from '@cowprotocol/sdk-viem-adapter'
-import { http, privateKeyToAccount } from 'viem'
+import { http, createPublicClient, privateKeyToAccount } from 'viem'
 import { sepolia } from 'viem/chains'
 
 // Configure the adapter
 const account = privateKeyToAccount('YOUR_PRIVATE_KEY' as `0x${string}`)
 const transport = http('YOUR_RPC_URL')
-const adapter = new ViemAdapter({ chain: sepolia, transport, account })
+const provider = createPublicClient({ chain: sepolia, transport })
+// You also can set `walletClient` instead of `signer` using `useWalletClient` from wagmi
+const adapter = new ViemAdapter({ provider, signer: account })
 
 // Initialize the unified SDK
 const sdk = new CowSdk({
@@ -72,12 +76,13 @@ const orders = await sdk.orderBook.getOrders({ owner: address })
 ```typescript
 import { TradingSdk } from '@cowprotocol/sdk-trading'
 import { ViemAdapter } from '@cowprotocol/sdk-viem-adapter'
-import { http, privateKeyToAccount } from 'viem'
+import { http, createPublicClient, privateKeyToAccount } from 'viem'
 import { sepolia } from 'viem/chains'
 
 const account = privateKeyToAccount('YOUR_PRIVATE_KEY' as `0x${string}`)
 const transport = http('YOUR_RPC_URL')
-const adapter = new ViemAdapter({ chain: sepolia, transport, account })
+const provider = createPublicClient({ chain: sepolia, transport })
+const adapter = new ViemAdapter({ provider, signer: account })
 
 const trading = new TradingSdk({ appCode: 'YOUR_APP_CODE' }, { chainId: SupportedChainId.SEPOLIA }, adapter)
 
@@ -89,14 +94,13 @@ const orderId = await trading.postSwapOrder(parameters)
 ### Constructor
 
 ```typescript
-new ViemAdapter({ chain, transport, account })
+new ViemAdapter({ provider, signer })
 ```
 
 #### Parameters
 
-- `chain` - A viem chain configuration
-- `transport` - A viem transport instance
-- `account` - A viem account instance
+- `provider` - A viem PublicClient instance
+- `signer` - A viem account instance or private key
 
 ### Methods
 

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import * as viem from 'viem';
-import { Abi, Address, Hex, TypedDataDomain, PublicClient, WalletClient, Account, Transport, TypedDataParameter, BlockTag, Block } from 'viem';
-import { GenericContractInterface, Log, AdapterUtils, AbstractSigner, TransactionParams, TransactionResponse, AdapterTypes, PrivateKey, AbstractProviderAdapter, TransactionReceipt, GenericContract } from '@cowprotocol/sdk-common';
+import { Abi, Address, Hex, PublicClient, WalletClient, Account, Transport, TypedDataDomain as TypedDataDomain$1, TypedDataParameter, BlockTag, Block } from 'viem';
+import { GenericContractInterface, ContractValue, Log, AdapterUtils, TypedDataDomain, ParamType, AbstractSigner, TransactionParams, TransactionResponse, AdapterTypes, PrivateKey, AbstractProviderAdapter, TransactionReceipt, GenericContract } from '@cowprotocol/sdk-common';
 
 /**
  * Interface wrapper that makes viem interfaces behave exactly like ethers v5 interfaces
@@ -20,7 +20,7 @@ declare class ViemInterfaceWrapper implements GenericContractInterface {
     /**
      * Encode function data using viem
      */
-    encodeFunctionData(name: string, args: unknown[]): string;
+    encodeFunctionData(name: string, args: ContractValue[]): string;
     parseLog(event: Log): {
         args: unknown;
     } | null;
@@ -37,21 +37,7 @@ declare class ViemInterfaceWrapper implements GenericContractInterface {
      * Get ABI
      */
     get abi(): any[];
-    decodeFunctionData(functionName: string, data: string): unknown[];
-}
-
-declare class ViemParamType {
-    name: string;
-    type: string;
-    baseType: string;
-    indexed: boolean;
-    components: ViemParamType[];
-    arrayLength: number;
-    arrayChildren: ViemParamType | null;
-    constructor(type: string);
-    private normalizeType;
-    private parseBaseType;
-    private getArrayElementType;
+    decodeFunctionData(functionName: string, data: string): ContractValue[];
 }
 
 declare class ViemUtils implements AdapterUtils {
@@ -66,17 +52,19 @@ declare class ViemUtils implements AdapterUtils {
     hexZeroPad(value: Hex, length: number): string;
     arrayify(hexString: string): Uint8Array;
     hexlify(value: `0x${string}` | Uint8Array): string;
-    solidityPack(types: string[], values: unknown[]): string;
+    solidityPack(types: string[], values: ContractValue[]): string;
     hashTypedData(domain: TypedDataDomain, types: Record<string, unknown>, data: Record<string, unknown>): string;
     getChecksumAddress(address: Address): Address;
     encodeAbi(types: {
         type: string;
         name: string;
-    }[] | string[], values: unknown[]): `0x${string}`;
-    decodeAbi(types: unknown[], data: `0x${string}`): unknown[];
+    }[] | string[], values: ContractValue[]): `0x${string}`;
+    decodeAbi(types: (string | {
+        type: string;
+        name: string;
+    })[], data: `0x${string}`): unknown[];
     id(text: string): `0x${string}`;
     toBigIntish(value: `0x${string}` | string | number): bigint;
-    newBigintish(value: number | string): bigint;
     hexDataSlice(data: `0x${string}`, offset: number, endOffset?: number): `0x${string}`;
     joinSignature(signature: {
         r: string;
@@ -93,13 +81,7 @@ declare class ViemUtils implements AdapterUtils {
         name: string;
         type: string;
     }>>, value: Record<string, unknown>, signature: `0x${string}`): Promise<`0x${string}`>;
-    encodeFunction(abi: Array<{
-        name: string;
-        inputs: Array<{
-            type: string;
-        }>;
-        type: string;
-    }>, functionName: string, args: unknown[]): string;
+    encodeFunction(abi: Abi, functionName: string, args: ContractValue[]): string;
     decodeFunctionData(abi: Array<{
         name: string;
         inputs: Array<{
@@ -108,18 +90,21 @@ declare class ViemUtils implements AdapterUtils {
         type: string;
     }>, functionName: string, data: string): any;
     toNumber(value: bigint): number;
-    solidityKeccak256(types: unknown[], values: unknown[]): `0x${string}`;
+    solidityKeccak256(types: (string | {
+        type: string;
+        name: string;
+    })[], values: ContractValue[]): string;
     createInterface(abi: string[] | any): ViemInterfaceWrapper;
     hashDomain(domain: TypedDataDomain): string;
-    grantRequiredRoles(authorizerAddress: string, authorizerAbi: Abi, vaultAddress: string, vaultRelayerAddress: string, contractCall: (address: string, abi: Abi, functionName: string, args: unknown[]) => Promise<void>): Promise<void>;
-    readStorage(baseAddress: Address, baseAbi: Abi, readerAddress: Address, readerAbi: Abi, client: PublicClient, method: string, parameters: unknown[]): Promise<unknown>;
+    grantRequiredRoles(authorizerAddress: string, authorizerAbi: Abi, vaultAddress: string, vaultRelayerAddress: string, contractCall: (address: string, abi: Abi, functionName: string, args: ContractValue[]) => Promise<void>): Promise<void>;
+    readStorage(baseAddress: Address, baseAbi: Abi, readerAddress: Address, readerAbi: Abi, client: PublicClient, method: string, parameters: ContractValue[]): Promise<unknown>;
     randomBytes(length: number): string;
     isAddress(address: string): boolean;
     isHexString(value: string): boolean;
     hexDataLength(data: string): number;
     parseUnits(value: string, decimals: number): bigint;
-    getParamType(type: string): ViemParamType;
-    getParamTypeFromString(type: string): ViemParamType;
+    getParamType(type: string): ParamType;
+    getParamTypeFromString(type: string): ParamType;
     isInterface(value: any): boolean;
 }
 
@@ -133,7 +118,7 @@ declare class ViemSignerAdapter extends AbstractSigner<PublicClient> {
     getAddress(): Promise<string>;
     signMessage(message: string | Uint8Array): Promise<string>;
     signTransaction(txParams: TransactionParams): Promise<string>;
-    signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataParameter>, value: Record<string, unknown>): Promise<string>;
+    signTypedData(domain: TypedDataDomain$1, types: Record<string, TypedDataParameter>, value: Record<string, unknown>): Promise<string>;
     sendTransaction(txParams: TransactionParams): Promise<TransactionResponse>;
     estimateGas(txParams: TransactionParams): Promise<bigint>;
     private _formatTxParams;
@@ -144,8 +129,8 @@ declare class ViemSignerAdapter extends AbstractSigner<PublicClient> {
  */
 declare class TypedDataVersionedSigner extends ViemSignerAdapter {
     protected getTypedDataVersion(): string;
-    signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataParameter>, value: Record<string, unknown>): Promise<string>;
-    protected modifyDomain(domain: TypedDataDomain): TypedDataDomain;
+    signTypedData(domain: TypedDataDomain$1, types: Record<string, TypedDataParameter>, value: Record<string, unknown>): Promise<string>;
+    protected modifyDomain(domain: TypedDataDomain$1): TypedDataDomain$1;
 }
 /**
  * Signer for EIP-712 typed data version 3
@@ -153,7 +138,7 @@ declare class TypedDataVersionedSigner extends ViemSignerAdapter {
  */
 declare class TypedDataV3Signer extends TypedDataVersionedSigner {
     protected getTypedDataVersion(): string;
-    signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataParameter>, value: Record<string, unknown>): Promise<string>;
+    signTypedData(domain: TypedDataDomain$1, types: Record<string, TypedDataParameter>, value: Record<string, unknown>): Promise<string>;
 }
 /**
  * Signer for EIP-712 typed data version 4 with integer chain ID handling
@@ -161,24 +146,21 @@ declare class TypedDataV3Signer extends TypedDataVersionedSigner {
  */
 declare class IntChainIdTypedDataV4Signer extends TypedDataVersionedSigner {
     protected getTypedDataVersion(): string;
-    protected modifyDomain(domain: TypedDataDomain): TypedDataDomain;
-    signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataParameter>, value: Record<string, unknown>): Promise<string>;
+    protected modifyDomain(domain: TypedDataDomain$1): TypedDataDomain$1;
+    signTypedData(domain: TypedDataDomain$1, types: Record<string, TypedDataParameter>, value: Record<string, unknown>): Promise<string>;
 }
 
 interface ViemTypes extends AdapterTypes {
     Abi: Abi;
-    Address: Address;
     Bytes: `0x${string}`;
-    BigIntish: bigint;
-    ContractInterface: unknown;
+    ContractInterface: Abi;
     Provider: PublicClient;
     Signer: WalletClient;
-    TypedDataDomain: TypedDataDomain;
-    TypedDataTypes: Record<string, unknown>;
 }
 interface ViemAdapterOptions {
     provider: PublicClient;
     signer?: Account | PrivateKey;
+    walletClient?: WalletClient;
 }
 declare class ViemAdapter extends AbstractProviderAdapter<ViemTypes> {
     private _publicClient;
@@ -204,7 +186,7 @@ declare class ViemAdapter extends AbstractProviderAdapter<ViemTypes> {
         address: string;
         abi: Abi;
         functionName: string;
-        args?: unknown[];
+        args?: ContractValue[];
     }, provider?: PublicClient): Promise<unknown>;
     getBlock(blockTag: BlockTag, provider?: PublicClient): Promise<Block>;
     getContract(address: string, abi: Abi): GenericContract;

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as viem from 'viem';
-import { Abi, Address, Hex, TypedDataDomain, PublicClient, WalletClient, Account, Transport, TypedDataParameter, BlockTag, Block } from 'viem';
-import { GenericContractInterface, Log, AdapterUtils, AbstractSigner, TransactionParams, TransactionResponse, AdapterTypes, PrivateKey, AbstractProviderAdapter, TransactionReceipt, GenericContract } from '@cowprotocol/sdk-common';
+import { Abi, Address, Hex, PublicClient, WalletClient, Account, Transport, TypedDataDomain as TypedDataDomain$1, TypedDataParameter, BlockTag, Block } from 'viem';
+import { GenericContractInterface, ContractValue, Log, AdapterUtils, TypedDataDomain, ParamType, AbstractSigner, TransactionParams, TransactionResponse, AdapterTypes, PrivateKey, AbstractProviderAdapter, TransactionReceipt, GenericContract } from '@cowprotocol/sdk-common';
 
 /**
  * Interface wrapper that makes viem interfaces behave exactly like ethers v5 interfaces
@@ -20,7 +20,7 @@ declare class ViemInterfaceWrapper implements GenericContractInterface {
     /**
      * Encode function data using viem
      */
-    encodeFunctionData(name: string, args: unknown[]): string;
+    encodeFunctionData(name: string, args: ContractValue[]): string;
     parseLog(event: Log): {
         args: unknown;
     } | null;
@@ -37,21 +37,7 @@ declare class ViemInterfaceWrapper implements GenericContractInterface {
      * Get ABI
      */
     get abi(): any[];
-    decodeFunctionData(functionName: string, data: string): unknown[];
-}
-
-declare class ViemParamType {
-    name: string;
-    type: string;
-    baseType: string;
-    indexed: boolean;
-    components: ViemParamType[];
-    arrayLength: number;
-    arrayChildren: ViemParamType | null;
-    constructor(type: string);
-    private normalizeType;
-    private parseBaseType;
-    private getArrayElementType;
+    decodeFunctionData(functionName: string, data: string): ContractValue[];
 }
 
 declare class ViemUtils implements AdapterUtils {
@@ -66,17 +52,19 @@ declare class ViemUtils implements AdapterUtils {
     hexZeroPad(value: Hex, length: number): string;
     arrayify(hexString: string): Uint8Array;
     hexlify(value: `0x${string}` | Uint8Array): string;
-    solidityPack(types: string[], values: unknown[]): string;
+    solidityPack(types: string[], values: ContractValue[]): string;
     hashTypedData(domain: TypedDataDomain, types: Record<string, unknown>, data: Record<string, unknown>): string;
     getChecksumAddress(address: Address): Address;
     encodeAbi(types: {
         type: string;
         name: string;
-    }[] | string[], values: unknown[]): `0x${string}`;
-    decodeAbi(types: unknown[], data: `0x${string}`): unknown[];
+    }[] | string[], values: ContractValue[]): `0x${string}`;
+    decodeAbi(types: (string | {
+        type: string;
+        name: string;
+    })[], data: `0x${string}`): unknown[];
     id(text: string): `0x${string}`;
     toBigIntish(value: `0x${string}` | string | number): bigint;
-    newBigintish(value: number | string): bigint;
     hexDataSlice(data: `0x${string}`, offset: number, endOffset?: number): `0x${string}`;
     joinSignature(signature: {
         r: string;
@@ -93,13 +81,7 @@ declare class ViemUtils implements AdapterUtils {
         name: string;
         type: string;
     }>>, value: Record<string, unknown>, signature: `0x${string}`): Promise<`0x${string}`>;
-    encodeFunction(abi: Array<{
-        name: string;
-        inputs: Array<{
-            type: string;
-        }>;
-        type: string;
-    }>, functionName: string, args: unknown[]): string;
+    encodeFunction(abi: Abi, functionName: string, args: ContractValue[]): string;
     decodeFunctionData(abi: Array<{
         name: string;
         inputs: Array<{
@@ -108,18 +90,21 @@ declare class ViemUtils implements AdapterUtils {
         type: string;
     }>, functionName: string, data: string): any;
     toNumber(value: bigint): number;
-    solidityKeccak256(types: unknown[], values: unknown[]): `0x${string}`;
+    solidityKeccak256(types: (string | {
+        type: string;
+        name: string;
+    })[], values: ContractValue[]): string;
     createInterface(abi: string[] | any): ViemInterfaceWrapper;
     hashDomain(domain: TypedDataDomain): string;
-    grantRequiredRoles(authorizerAddress: string, authorizerAbi: Abi, vaultAddress: string, vaultRelayerAddress: string, contractCall: (address: string, abi: Abi, functionName: string, args: unknown[]) => Promise<void>): Promise<void>;
-    readStorage(baseAddress: Address, baseAbi: Abi, readerAddress: Address, readerAbi: Abi, client: PublicClient, method: string, parameters: unknown[]): Promise<unknown>;
+    grantRequiredRoles(authorizerAddress: string, authorizerAbi: Abi, vaultAddress: string, vaultRelayerAddress: string, contractCall: (address: string, abi: Abi, functionName: string, args: ContractValue[]) => Promise<void>): Promise<void>;
+    readStorage(baseAddress: Address, baseAbi: Abi, readerAddress: Address, readerAbi: Abi, client: PublicClient, method: string, parameters: ContractValue[]): Promise<unknown>;
     randomBytes(length: number): string;
     isAddress(address: string): boolean;
     isHexString(value: string): boolean;
     hexDataLength(data: string): number;
     parseUnits(value: string, decimals: number): bigint;
-    getParamType(type: string): ViemParamType;
-    getParamTypeFromString(type: string): ViemParamType;
+    getParamType(type: string): ParamType;
+    getParamTypeFromString(type: string): ParamType;
     isInterface(value: any): boolean;
 }
 
@@ -133,7 +118,7 @@ declare class ViemSignerAdapter extends AbstractSigner<PublicClient> {
     getAddress(): Promise<string>;
     signMessage(message: string | Uint8Array): Promise<string>;
     signTransaction(txParams: TransactionParams): Promise<string>;
-    signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataParameter>, value: Record<string, unknown>): Promise<string>;
+    signTypedData(domain: TypedDataDomain$1, types: Record<string, TypedDataParameter>, value: Record<string, unknown>): Promise<string>;
     sendTransaction(txParams: TransactionParams): Promise<TransactionResponse>;
     estimateGas(txParams: TransactionParams): Promise<bigint>;
     private _formatTxParams;
@@ -144,8 +129,8 @@ declare class ViemSignerAdapter extends AbstractSigner<PublicClient> {
  */
 declare class TypedDataVersionedSigner extends ViemSignerAdapter {
     protected getTypedDataVersion(): string;
-    signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataParameter>, value: Record<string, unknown>): Promise<string>;
-    protected modifyDomain(domain: TypedDataDomain): TypedDataDomain;
+    signTypedData(domain: TypedDataDomain$1, types: Record<string, TypedDataParameter>, value: Record<string, unknown>): Promise<string>;
+    protected modifyDomain(domain: TypedDataDomain$1): TypedDataDomain$1;
 }
 /**
  * Signer for EIP-712 typed data version 3
@@ -153,7 +138,7 @@ declare class TypedDataVersionedSigner extends ViemSignerAdapter {
  */
 declare class TypedDataV3Signer extends TypedDataVersionedSigner {
     protected getTypedDataVersion(): string;
-    signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataParameter>, value: Record<string, unknown>): Promise<string>;
+    signTypedData(domain: TypedDataDomain$1, types: Record<string, TypedDataParameter>, value: Record<string, unknown>): Promise<string>;
 }
 /**
  * Signer for EIP-712 typed data version 4 with integer chain ID handling
@@ -161,24 +146,21 @@ declare class TypedDataV3Signer extends TypedDataVersionedSigner {
  */
 declare class IntChainIdTypedDataV4Signer extends TypedDataVersionedSigner {
     protected getTypedDataVersion(): string;
-    protected modifyDomain(domain: TypedDataDomain): TypedDataDomain;
-    signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataParameter>, value: Record<string, unknown>): Promise<string>;
+    protected modifyDomain(domain: TypedDataDomain$1): TypedDataDomain$1;
+    signTypedData(domain: TypedDataDomain$1, types: Record<string, TypedDataParameter>, value: Record<string, unknown>): Promise<string>;
 }
 
 interface ViemTypes extends AdapterTypes {
     Abi: Abi;
-    Address: Address;
     Bytes: `0x${string}`;
-    BigIntish: bigint;
-    ContractInterface: unknown;
+    ContractInterface: Abi;
     Provider: PublicClient;
     Signer: WalletClient;
-    TypedDataDomain: TypedDataDomain;
-    TypedDataTypes: Record<string, unknown>;
 }
 interface ViemAdapterOptions {
     provider: PublicClient;
     signer?: Account | PrivateKey;
+    walletClient?: WalletClient;
 }
 declare class ViemAdapter extends AbstractProviderAdapter<ViemTypes> {
     private _publicClient;
@@ -204,7 +186,7 @@ declare class ViemAdapter extends AbstractProviderAdapter<ViemTypes> {
         address: string;
         abi: Abi;
         functionName: string;
-        args?: unknown[];
+        args?: ContractValue[];
     }, provider?: PublicClient): Promise<unknown>;
     getBlock(blockTag: BlockTag, provider?: PublicClient): Promise<Block>;
     getContract(address: string, abi: Abi): GenericContract;

package/dist/index.js

@@ -309,8 +309,9 @@ var ViemUtils = class {
     if (!primaryType) {
       throw new Error("No primary type found in types");
     }
+    const domainTypedDataDomain = domain;
     return (0, import_viem2.hashTypedData)({
-      domain,
+      domain: domainTypedDataDomain,
       types,
       primaryType,
       message: data
@@ -334,7 +335,7 @@ var ViemUtils = class {
     return (0, import_viem2.decodeAbiParameters)(types, data);
   }
   id(text) {
-    return (0, import_viem2.keccak256)((0, import_viem2.stringToHex)(text));
+    return (0, import_viem2.keccak256)((0, import_viem2.toBytes)(text));
   }
   toBigIntish(value) {
     if (typeof value === "number")
@@ -346,9 +347,6 @@ var ViemUtils = class {
     }
     return (0, import_viem2.hexToBigInt)(value);
   }
-  newBigintish(value) {
-    return BigInt(value);
-  }
   hexDataSlice(data, offset, endOffset) {
     return (0, import_viem2.sliceHex)(data, offset, endOffset);
   }
@@ -381,8 +379,9 @@ var ViemUtils = class {
     if (!primaryType) {
       throw new Error("No primary type found in types");
     }
+    const domainTypedDataDomain = domain;
     return (0, import_viem2.recoverTypedDataAddress)({
-      domain,
+      domain: domainTypedDataDomain,
       types,
       primaryType,
       message: value,
@@ -431,11 +430,12 @@ var ViemUtils = class {
     return new ViemInterfaceWrapper(abi);
   }
   hashDomain(domain) {
+    const domainTypedDataDomain = domain;
     const EIP712_DOMAIN_TYPEHASH = (0, import_viem2.keccak256)(
       (0, import_viem2.toHex)("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
     );
-    const nameHash = domain.name ? (0, import_viem2.keccak256)((0, import_viem2.toHex)(domain.name)) : "0x0000000000000000000000000000000000000000000000000000000000000000";
-    const versionHash = domain.version ? (0, import_viem2.keccak256)((0, import_viem2.toHex)(domain.version)) : "0x0000000000000000000000000000000000000000000000000000000000000000";
+    const nameHash = domainTypedDataDomain.name ? (0, import_viem2.keccak256)((0, import_viem2.toHex)(domainTypedDataDomain.name)) : "0x0000000000000000000000000000000000000000000000000000000000000000";
+    const versionHash = domainTypedDataDomain.version ? (0, import_viem2.keccak256)((0, import_viem2.toHex)(domainTypedDataDomain.version)) : "0x0000000000000000000000000000000000000000000000000000000000000000";
     const encodedDomain = (0, import_viem2.encodeAbiParameters)(
       [
         { type: "bytes32" },
@@ -453,8 +453,8 @@ var ViemUtils = class {
         EIP712_DOMAIN_TYPEHASH,
         nameHash,
         versionHash,
-        BigInt(domain.chainId || 0),
-        domain.verifyingContract || "0x0000000000000000000000000000000000000000"
+        BigInt(domainTypedDataDomain.chainId || 0),
+        domainTypedDataDomain.verifyingContract || "0x0000000000000000000000000000000000000000"
       ]
     );
     return (0, import_viem2.keccak256)(encodedDomain);
@@ -605,6 +605,8 @@ var ViemSignerAdapter = class extends import_sdk_common3.AbstractSigner {
           confirmations
         });
         return {
+          from: receipt.from,
+          to: receipt.to,
           transactionHash: receipt.transactionHash,
           blockNumber: BigInt(receipt.blockNumber),
           blockHash: receipt.blockHash,
@@ -729,6 +731,12 @@ var ViemAdapter = class extends import_sdk_common4.AbstractProviderAdapter {
     if (options.signer) {
       this.setSigner(options.signer);
     }
+    if (options.walletClient) {
+      this._walletClient = options.walletClient;
+      const signerAdapter = new ViemSignerAdapter(this._walletClient);
+      signerAdapter.connect(this._publicClient);
+      this._signerAdapter = signerAdapter;
+    }
     this.utils = new ViemUtils();
   }
   get signer() {

package/dist/index.mjs

@@ -14,7 +14,9 @@ import {
 } from "@cowprotocol/sdk-common";
 
 // src/ViemUtils.ts
-import { CowError as CowError2 } from "@cowprotocol/sdk-common";
+import {
+  CowError as CowError2
+} from "@cowprotocol/sdk-common";
 import {
   encodeDeployData,
   getCreate2Address,
@@ -28,7 +30,6 @@ import {
   getAddress,
   encodeAbiParameters,
   decodeAbiParameters as decodeAbiParameters2,
-  stringToHex,
   hexToBigInt,
   slice,
   parseAbi as parseAbi2,
@@ -42,7 +43,8 @@ import {
   isAddress,
   isHex,
   parseUnits,
-  sliceHex
+  sliceHex,
+  toBytes
 } from "viem";
 
 // src/ViemInterfaceWrapper.ts
@@ -328,8 +330,9 @@ var ViemUtils = class {
     if (!primaryType) {
       throw new Error("No primary type found in types");
     }
+    const domainTypedDataDomain = domain;
     return hashTypedData({
-      domain,
+      domain: domainTypedDataDomain,
       types,
       primaryType,
       message: data
@@ -353,7 +356,7 @@ var ViemUtils = class {
     return decodeAbiParameters2(types, data);
   }
   id(text) {
-    return keccak256(stringToHex(text));
+    return keccak256(toBytes(text));
   }
   toBigIntish(value) {
     if (typeof value === "number")
@@ -365,9 +368,6 @@ var ViemUtils = class {
     }
     return hexToBigInt(value);
   }
-  newBigintish(value) {
-    return BigInt(value);
-  }
   hexDataSlice(data, offset, endOffset) {
     return sliceHex(data, offset, endOffset);
   }
@@ -400,8 +400,9 @@ var ViemUtils = class {
     if (!primaryType) {
       throw new Error("No primary type found in types");
     }
+    const domainTypedDataDomain = domain;
     return recoverTypedDataAddress({
-      domain,
+      domain: domainTypedDataDomain,
       types,
       primaryType,
       message: value,
@@ -450,11 +451,12 @@ var ViemUtils = class {
     return new ViemInterfaceWrapper(abi);
   }
   hashDomain(domain) {
+    const domainTypedDataDomain = domain;
     const EIP712_DOMAIN_TYPEHASH = keccak256(
       toHex("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
     );
-    const nameHash = domain.name ? keccak256(toHex(domain.name)) : "0x0000000000000000000000000000000000000000000000000000000000000000";
-    const versionHash = domain.version ? keccak256(toHex(domain.version)) : "0x0000000000000000000000000000000000000000000000000000000000000000";
+    const nameHash = domainTypedDataDomain.name ? keccak256(toHex(domainTypedDataDomain.name)) : "0x0000000000000000000000000000000000000000000000000000000000000000";
+    const versionHash = domainTypedDataDomain.version ? keccak256(toHex(domainTypedDataDomain.version)) : "0x0000000000000000000000000000000000000000000000000000000000000000";
     const encodedDomain = encodeAbiParameters(
       [
         { type: "bytes32" },
@@ -472,8 +474,8 @@ var ViemUtils = class {
         EIP712_DOMAIN_TYPEHASH,
         nameHash,
         versionHash,
-        BigInt(domain.chainId || 0),
-        domain.verifyingContract || "0x0000000000000000000000000000000000000000"
+        BigInt(domainTypedDataDomain.chainId || 0),
+        domainTypedDataDomain.verifyingContract || "0x0000000000000000000000000000000000000000"
       ]
     );
     return keccak256(encodedDomain);
@@ -627,6 +629,8 @@ var ViemSignerAdapter = class extends AbstractSigner {
           confirmations
         });
         return {
+          from: receipt.from,
+          to: receipt.to,
           transactionHash: receipt.transactionHash,
           blockNumber: BigInt(receipt.blockNumber),
           blockHash: receipt.blockHash,
@@ -751,6 +755,12 @@ var ViemAdapter = class extends AbstractProviderAdapter {
     if (options.signer) {
       this.setSigner(options.signer);
     }
+    if (options.walletClient) {
+      this._walletClient = options.walletClient;
+      const signerAdapter = new ViemSignerAdapter(this._walletClient);
+      signerAdapter.connect(this._publicClient);
+      this._signerAdapter = signerAdapter;
+    }
     this.utils = new ViemUtils();
   }
   get signer() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cowprotocol/sdk-viem-adapter",
-  "version": "0.2.0-beta.0",
+  "version": "0.2.0",
   "description": "Viem adapter for CoW Protocol SDK",
   "main": "dist/index.js",
   "module": "./dist/index.mjs",
@@ -12,24 +12,23 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "tsup src/index.ts --format esm,cjs --dts",
-    "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
-    "lint": "eslint src/**/*.ts",
-    "typecheck": "tsc --noEmit",
-    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist",
-    "prepublishOnly": "npm run build"
-  },
   "dependencies": {
-    "@cowprotocol/sdk-common": "workspace:*"
+    "@cowprotocol/sdk-common": "0.3.0"
   },
   "peerDependencies": {
     "viem": "^2.28.4"
   },
   "devDependencies": {
-    "@cow-sdk/typescript-config": "workspace:*",
     "@types/node": "^20.5.2",
     "tsup": "^7.2.0",
-    "typescript": "^5.2.2"
+    "typescript": "^5.2.2",
+    "@cow-sdk/typescript-config": "0.0.0-beta.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
+    "lint": "eslint src/**/*.ts",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
   }
-}
+}