@polymarket/relayer-client 1.0.18 → 2.0.0

package/README.md

@@ -1 +1,31 @@
 ## relayer-client
+
+### Install
+
+```bash
+npm install @polymarket/relayer-client
+```
+
+### Usage
+
+```ts
+import { ethers } from "ethers";
+import { createWalletClient, Hex, http } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { RelayClient } from "@polymarket/relayer-client";
+
+const relayerUrl = `${process.env.POLYMARKET_RELAYER_URL}`;
+const chainId = parseInt(`${process.env.CHAIN_ID}`);
+
+// Ethers
+const provider = new ethers.providers.JsonRpcProvider(`${process.env.RPC_URL}`);
+const pk = new ethers.Wallet(`${process.env.PK}`);
+const wallet = pk.connect(provider);
+
+// Viem
+const pk = privateKeyToAccount(`${process.env.PK}` as Hex);
+const wallet = createWalletClient({account: pk, chain: polygon, transport: http(`${process.env.RPC_URL}`)});
+
+// Initialize Relay Client
+const client = new RelayClient(relayerUrl, chainId, wallet);
+```

package/dist/auth/handler.js

@@ -1,10 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthHandler = void 0;
-const tslib_1 = require("tslib");
 const http_helpers_1 = require("../http-helpers");
 const POLYMARKET_COOKIE_NAME = "polymarket";
 class AuthHandler {
+    url;
+    httpClient;
+    token;
+    cookie;
     constructor(httpClient, args) {
         if (args.authUrl == undefined || args.authToken == undefined) {
             throw new Error("invalid authorization arguments");
@@ -17,33 +20,29 @@ class AuthHandler {
      * Logs in to the auth url
      * Extracts polymarket session cookies from the auth response header and cache it locally.
      */
-    login() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            if (this.cookie == undefined) {
-                // Logging in will set the session cookies on the httpClient
-                const resp = yield this.httpClient.send(`${this.url}/login`, http_helpers_1.GET, { Authorization: `Bearer ${this.token}` });
-                const cookies = resp.headers['set-cookie'];
-                let aggregatedCookie = "";
-                for (const cookie of cookies) {
-                    if (cookie.includes(POLYMARKET_COOKIE_NAME)) {
-                        aggregatedCookie += `${cookie}; `;
-                    }
+    async login() {
+        if (this.cookie == undefined) {
+            // Logging in will set the session cookies on the httpClient
+            const resp = await this.httpClient.send(`${this.url}/login/internal`, http_helpers_1.GET, { Authorization: `Bearer ${this.token}` });
+            const cookies = resp.headers['set-cookie'];
+            let aggregatedCookie = "";
+            for (const cookie of cookies) {
+                if (cookie.includes(POLYMARKET_COOKIE_NAME)) {
+                    aggregatedCookie += `${cookie}; `;
                 }
-                if (aggregatedCookie != "") {
-                    this.cookie = aggregatedCookie;
-                }
-                console.log(`Successfully logged in!`);
             }
-        });
-    }
-    getPolymarketCookies() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            if (this.cookie == undefined) {
-                console.log("Authorization not set, logging in...");
-                yield this.login();
+            if (aggregatedCookie != "") {
+                this.cookie = aggregatedCookie;
             }
-            return this.cookie;
-        });
+            console.log(`Successfully logged in!`);
+        }
+    }
+    async getPolymarketCookies() {
+        if (this.cookie == undefined) {
+            console.log("Authorization not set, logging in...");
+            await this.login();
+        }
+        return this.cookie;
     }
 }
 exports.AuthHandler = AuthHandler;

package/dist/builder/create.d.ts

@@ -1,3 +1,4 @@
 import { SafeCreateTransactionArgs, TransactionRequest } from "../types";
-import { SignerAdapter } from "../signeradapter";
-export declare function buildSafeCreateTransactionRequest(signer: SignerAdapter, args: SafeCreateTransactionArgs): Promise<TransactionRequest>;
+import { IAbstractSigner } from "@polymarket/abstract-signer";
+import { SafeContractConfig } from "../config";
+export declare function buildSafeCreateTransactionRequest(signer: IAbstractSigner, safeContractConfig: SafeContractConfig, args: SafeCreateTransactionArgs): Promise<TransactionRequest>;

package/dist/builder/create.js

@@ -1,54 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildSafeCreateTransactionRequest = buildSafeCreateTransactionRequest;
-const tslib_1 = require("tslib");
-const ethers_1 = require("ethers");
 const types_1 = require("../types");
 const constants_1 = require("../constants");
-const utils_1 = require("./utils");
-function createSafeCreateSignature(signer, chainId, paymentToken, payment, paymentReceiver) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const domain = {
-            name: constants_1.SAFE_FACTORY_NAME,
-            chainId: ethers_1.BigNumber.from(chainId).toHexString(),
-            verifyingContract: constants_1.SAFE_FACTORY_ADDRESS,
-        };
-        const types = {
-            CreateProxy: [
-                { name: "paymentToken", type: "address" },
-                { name: "payment", type: "uint256" },
-                { name: "paymentReceiver", type: "address" },
-            ],
-        };
-        const values = {
-            paymentToken,
-            payment: ethers_1.BigNumber.from(payment),
-            paymentReceiver,
-        };
-        return signer.signTypedData(domain, types, values);
-    });
+const derive_1 = require("./derive");
+async function createSafeCreateSignature(signer, safeFactory, chainId, paymentToken, payment, paymentReceiver) {
+    const domain = {
+        name: constants_1.SAFE_FACTORY_NAME,
+        chainId: BigInt(chainId),
+        verifyingContract: safeFactory,
+    };
+    const types = {
+        CreateProxy: [
+            { name: "paymentToken", type: "address" },
+            { name: "payment", type: "uint256" },
+            { name: "paymentReceiver", type: "address" },
+        ],
+    };
+    const values = {
+        paymentToken,
+        payment: BigInt(payment),
+        paymentReceiver,
+    };
+    const sig = await signer.signTypedData(domain, types, values, "CreateProxy");
+    console.log(`Sig: ${sig}`);
+    return sig;
 }
-function buildSafeCreateTransactionRequest(signer, args) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const sig = yield createSafeCreateSignature(signer, args.chainId, args.paymentToken, args.payment, args.paymentReceiver);
-        const sigParams = {
-            paymentToken: args.paymentToken,
-            payment: args.payment,
-            paymentReceiver: args.paymentReceiver,
-        };
-        const safeAddress = (0, utils_1.deriveSafe)(args.from);
-        const request = {
-            from: args.from,
-            to: constants_1.SAFE_FACTORY_ADDRESS,
-            // Note: obviously the safe here does not exist yet but useful to have this data in the db
-            proxyWallet: safeAddress,
-            data: "0x",
-            signature: sig,
-            signatureParams: sigParams,
-            type: types_1.TransactionType.SAFE_CREATE,
-        };
-        console.log(`Created a SAFE-CREATE Transaction:`);
-        console.log(request);
-        return request;
-    });
+async function buildSafeCreateTransactionRequest(signer, safeContractConfig, args) {
+    const safeFactory = safeContractConfig.SafeFactory;
+    const sig = await createSafeCreateSignature(signer, safeFactory, args.chainId, args.paymentToken, args.payment, args.paymentReceiver);
+    const sigParams = {
+        paymentToken: args.paymentToken,
+        payment: args.payment,
+        paymentReceiver: args.paymentReceiver,
+    };
+    const safeAddress = (0, derive_1.deriveSafe)(args.from, safeFactory);
+    const request = {
+        from: args.from,
+        to: safeFactory,
+        // Note: obviously the safe here does not exist yet but useful to have this data in the db
+        proxyWallet: safeAddress,
+        data: "0x",
+        signature: sig,
+        signatureParams: sigParams,
+        type: types_1.TransactionType.SAFE_CREATE,
+    };
+    console.log(`Created a SAFE-CREATE Transaction:`);
+    console.log(request);
+    return request;
 }

package/dist/builder/derive.d.ts

@@ -0,0 +1,2 @@
+export declare const deriveProxyWallet: (address: string, proxyFactory: string) => string;
+export declare const deriveSafe: (address: string, safeFactory: string) => string;

package/dist/builder/derive.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveSafe = exports.deriveProxyWallet = void 0;
+const viem_1 = require("viem");
+const constants_1 = require("../constants");
+const deriveProxyWallet = (address, proxyFactory) => {
+    return (0, viem_1.getCreate2Address)({
+        bytecodeHash: constants_1.PROXY_INIT_CODE_HASH,
+        from: proxyFactory,
+        salt: (0, viem_1.keccak256)((0, viem_1.encodePacked)(["address"], [address]))
+    });
+};
+exports.deriveProxyWallet = deriveProxyWallet;
+const deriveSafe = (address, safeFactory) => {
+    return (0, viem_1.getCreate2Address)({
+        bytecodeHash: constants_1.SAFE_INIT_CODE_HASH,
+        from: safeFactory,
+        salt: (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([{ name: 'address', type: 'address' }], [address]))
+    });
+};
+exports.deriveSafe = deriveSafe;

package/dist/builder/index.d.ts

@@ -1,4 +1,4 @@
 export * from "./proxy";
 export * from "./safe";
 export * from "./create";
-export * from "./utils";
+export * from "./derive";

package/dist/builder/index.js

@@ -4,4 +4,4 @@ const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./proxy"), exports);
 tslib_1.__exportStar(require("./safe"), exports);
 tslib_1.__exportStar(require("./create"), exports);
-tslib_1.__exportStar(require("./utils"), exports);
+tslib_1.__exportStar(require("./derive"), exports);

package/dist/builder/proxy.d.ts

@@ -1,3 +1,4 @@
+import { IAbstractSigner } from "@polymarket/abstract-signer";
 import { ProxyTransactionArgs, TransactionRequest } from "../types";
-import { SignerAdapter } from "../signeradapter";
-export declare function buildProxyTransactionRequest(signer: SignerAdapter, args: ProxyTransactionArgs, metadata?: string): Promise<TransactionRequest>;
+import { ProxyContractConfig } from "../config";
+export declare function buildProxyTransactionRequest(signer: IAbstractSigner, args: ProxyTransactionArgs, proxyContractConfig: ProxyContractConfig, metadata?: string): Promise<TransactionRequest>;

package/dist/builder/proxy.js

@@ -1,92 +1,73 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildProxyTransactionRequest = buildProxyTransactionRequest;
-const tslib_1 = require("tslib");
-const web3_utils_1 = tslib_1.__importDefault(require("web3-utils"));
-const constants_1 = require("../constants");
+const viem_1 = require("viem");
 const types_1 = require("../types");
-const utils_1 = require("./utils");
-const ethers_1 = require("ethers");
-const utils_2 = require("ethers/lib/utils");
-const relayPrefix = "rlx:";
-const zeroPad = "0000000000000000000000000000000000000000000000000000000000000000";
-function padTo64(_hex) {
-    let hex = _hex;
-    if (hex.length < 64) {
-        hex = (zeroPad + hex).slice(-64);
-    }
-    return hex;
-}
-function removeHexPrefix(hex) {
-    return hex.replace(/^0x/, "");
-}
-function toUint256NoPrefix(hexString) {
-    return padTo64(removeHexPrefix(hexString));
-}
-function bytesToHexNoPrefix(bytes) {
-    let hex = removeHexPrefix(web3_utils_1.default.toHex(bytes));
-    if (hex.length % 2 !== 0) {
-        hex = "0" + hex;
-    }
-    return hex;
-}
+const derive_1 = require("./derive");
 function createStructHash(from, to, data, txFee, gasPrice, gasLimit, nonce, relayHubAddress, relayAddress) {
-    const txhstr = bytesToHexNoPrefix(data);
-    const dataToHash = Buffer.from(relayPrefix).toString("hex") +
-        removeHexPrefix(from) +
-        removeHexPrefix(to) +
-        txhstr +
-        toUint256NoPrefix(ethers_1.BigNumber.from(txFee).toHexString()) +
-        toUint256NoPrefix(ethers_1.BigNumber.from(gasPrice).toHexString()) +
-        toUint256NoPrefix(ethers_1.BigNumber.from(gasLimit).toHexString()) +
-        toUint256NoPrefix(ethers_1.BigNumber.from(nonce).toHexString()) +
-        removeHexPrefix(relayHubAddress) +
-        removeHexPrefix(relayAddress);
-    return (0, utils_2.keccak256)("0x" + dataToHash);
+    const relayHubPrefix = (0, viem_1.toHex)("rlx:");
+    const encodedFrom = from;
+    const encodedTo = to;
+    const encodedData = data;
+    const encodedTxFee = (0, viem_1.toHex)(BigInt(txFee), { size: 32 });
+    const encodedGasPrice = (0, viem_1.toHex)(BigInt(gasPrice), { size: 32 });
+    const encodedGasLimit = (0, viem_1.toHex)(BigInt(gasLimit), { size: 32 });
+    const encodedNonce = (0, viem_1.toHex)(BigInt(nonce), { size: 32 });
+    const encodedRelayHubAddress = relayHubAddress;
+    const encodedRelayAddress = relayAddress;
+    const dataToHash = (0, viem_1.concat)([
+        relayHubPrefix,
+        encodedFrom,
+        encodedTo,
+        encodedData,
+        encodedTxFee,
+        encodedGasPrice,
+        encodedGasLimit,
+        encodedNonce,
+        encodedRelayHubAddress,
+        encodedRelayAddress,
+    ]);
+    return (0, viem_1.keccak256)(dataToHash);
 }
-function createProxySignature(signer, structHash) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        return signer.signMessage(structHash);
-    });
+async function createProxySignature(signer, structHash) {
+    return signer.signMessage(structHash);
 }
-function buildProxyTransactionRequest(signer, args, metadata) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const to = constants_1.PROXY_WALLET_FACTORY_ADDRESS;
-        const proxy = (0, utils_1.deriveProxyWallet)(args.from);
-        const relayerFee = "0";
-        const relayHub = constants_1.RELAY_HUB_ADDRESS;
-        const provider = yield signer.getProvider();
-        const gasLimit = yield provider.estimateGas({
-            from: args.from,
-            to: to,
-            data: args.data,
-        });
-        const gasLimitStr = gasLimit.toString();
-        const sigParams = {
-            gasPrice: args.gasPrice,
-            gasLimit: gasLimitStr,
-            relayerFee: relayerFee,
-            relayHub: constants_1.RELAY_HUB_ADDRESS,
-            relay: args.relay,
-        };
-        const txHash = createStructHash(args.from, to, args.data, relayerFee, args.gasPrice, gasLimitStr, args.nonce, relayHub, args.relay);
-        const sig = yield createProxySignature(signer, txHash);
-        if (metadata == undefined) {
-            metadata = "";
-        }
-        const req = {
-            from: args.from,
-            to: to,
-            proxyWallet: proxy,
-            data: args.data,
-            nonce: args.nonce,
-            signature: sig,
-            signatureParams: sigParams,
-            type: types_1.TransactionType.PROXY,
-            metadata: metadata,
-        };
-        console.log(`Created Proxy Transaction Request:`);
-        console.log(req);
-        return req;
+async function buildProxyTransactionRequest(signer, args, proxyContractConfig, metadata) {
+    const proxyWalletFactory = proxyContractConfig.ProxyFactory;
+    const to = proxyWalletFactory;
+    const proxy = (0, derive_1.deriveProxyWallet)(args.from, proxyWalletFactory);
+    const relayerFee = "0";
+    const relayHub = proxyContractConfig.RelayHub;
+    const gasLimit = args.gasLimit ? args.gasLimit : await signer.estimateGas({
+        from: args.from,
+        to: to,
+        data: args.data,
     });
+    const gasLimitStr = gasLimit.toString();
+    const sigParams = {
+        gasPrice: args.gasPrice,
+        gasLimit: gasLimitStr,
+        relayerFee: relayerFee,
+        relayHub: relayHub,
+        relay: args.relay,
+    };
+    const txHash = createStructHash(args.from, to, args.data, relayerFee, args.gasPrice, gasLimitStr, args.nonce, relayHub, args.relay);
+    const sig = await createProxySignature(signer, txHash);
+    if (metadata == undefined) {
+        metadata = "";
+    }
+    const req = {
+        from: args.from,
+        to: to,
+        proxyWallet: proxy,
+        data: args.data,
+        nonce: args.nonce,
+        signature: sig,
+        signatureParams: sigParams,
+        type: types_1.TransactionType.PROXY,
+        metadata: metadata,
+    };
+    console.log(`Created Proxy Transaction Request:`);
+    console.log(req);
+    return req;
 }

package/dist/builder/safe.d.ts

@@ -1,4 +1,5 @@
+import { IAbstractSigner } from "@polymarket/abstract-signer";
 import { SafeTransaction, SafeTransactionArgs, TransactionRequest } from "../types";
-import { SignerAdapter } from "../signeradapter";
-export declare function aggregateTransaction(txns: SafeTransaction[]): SafeTransaction;
-export declare function buildSafeTransactionRequest(signer: SignerAdapter, args: SafeTransactionArgs, metadata?: string): Promise<TransactionRequest>;
+import { SafeContractConfig } from "../config";
+export declare function aggregateTransaction(txns: SafeTransaction[], safeMultisend: string): SafeTransaction;
+export declare function buildSafeTransactionRequest(signer: IAbstractSigner, args: SafeTransactionArgs, safeContractConfig: SafeContractConfig, metadata?: string): Promise<TransactionRequest>;

package/dist/builder/safe.js

@@ -2,38 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.aggregateTransaction = aggregateTransaction;
 exports.buildSafeTransactionRequest = buildSafeTransactionRequest;
-const tslib_1 = require("tslib");
+const viem_1 = require("viem");
 const types_1 = require("../types");
-const utils_1 = require("./utils");
-const ethers_1 = require("ethers");
-const utils_2 = require("ethers/lib/utils");
+const derive_1 = require("./derive");
 const safe_1 = require("../encode/safe");
-const utils_3 = require("../encode/utils");
-function createSafeSignature(signer, structHash) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        return signer.signMessage(structHash);
-    });
-}
-function splitSignature(sig) {
-    let sigV = parseInt(sig.slice(-2), 16);
-    switch (sigV) {
-        case 0:
-        case 1:
-            sigV += 31;
-            break;
-        case 27:
-        case 28:
-            sigV += 4;
-            break;
-        default:
-            throw new Error("Invalid signature");
-    }
-    sig = sig.slice(0, -2) + sigV.toString(16);
-    return {
-        r: ethers_1.BigNumber.from("0x" + sig.slice(2, 66)).toString(),
-        s: ethers_1.BigNumber.from("0x" + sig.slice(66, 130)).toString(),
-        v: ethers_1.BigNumber.from("0x" + sig.slice(130, 132)).toString(),
-    };
+const utils_1 = require("../utils");
+async function createSafeSignature(signer, structHash) {
+    return signer.signMessage(structHash);
 }
 function createStructHash(chainId, safe, to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, nonce) {
     const domain = {
@@ -69,61 +44,61 @@ function createStructHash(chainId, safe, to, value, data, operation, safeTxGas,
         refundReceiver: refundReceiver,
         nonce: nonce,
     };
-    const structHash = utils_2._TypedDataEncoder.hash(domain, types, values);
-    console.log(`Safe Struct Hash: ${structHash}`);
+    // // viem hashTypedData
+    // const structHash = _TypedDataEncoder.hash(domain, types, values);
+    const structHash = (0, viem_1.hashTypedData)({ primaryType: "SafeTx", domain: domain, types: types, message: values });
     return structHash;
 }
-function aggregateTransaction(txns) {
+function aggregateTransaction(txns, safeMultisend) {
     let transaction;
     if (txns.length == 1) {
         transaction = txns[0];
     }
     else {
-        transaction = (0, safe_1.createSafeMultisendTransaction)(txns);
+        transaction = (0, safe_1.createSafeMultisendTransaction)(txns, safeMultisend);
     }
     return transaction;
 }
-function buildSafeTransactionRequest(signer, args, metadata) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const transaction = aggregateTransaction(args.transactions);
-        const safeTxnGas = "0";
-        const baseGas = "0";
-        const gasPrice = "0";
-        const gasToken = ethers_1.ethers.constants.AddressZero;
-        const refundReceiver = ethers_1.ethers.constants.AddressZero;
-        const safeAddress = (0, utils_1.deriveSafe)(args.from);
-        // Generate the struct hash
-        // NOTE: this includes a client side optimization over the current relayers
-        // Generates struct hash locally instead of going across the network using the RPC call
-        const structHash = createStructHash(args.chainId, safeAddress, transaction.to, transaction.value, transaction.data, transaction.operation, safeTxnGas, baseGas, gasPrice, gasToken, refundReceiver, args.nonce);
-        const sig = yield createSafeSignature(signer, structHash);
-        // Split the sig then pack it into Gnosis accepted rsv format
-        const splitSig = splitSignature(sig);
-        const packedSig = (0, utils_3.abiEncodePacked)({ type: "uint256", value: splitSig.r }, { type: "uint256", value: splitSig.s }, { type: "uint8", value: splitSig.v });
-        const sigParams = {
-            gasPrice,
-            operation: `${transaction.operation}`,
-            safeTxnGas,
-            baseGas,
-            gasToken,
-            refundReceiver,
-        };
-        if (metadata == undefined) {
-            metadata = "";
-        }
-        const req = {
-            from: args.from,
-            to: transaction.to,
-            proxyWallet: safeAddress,
-            data: transaction.data,
-            nonce: args.nonce,
-            signature: packedSig,
-            signatureParams: sigParams,
-            type: types_1.TransactionType.SAFE,
-            metadata: metadata,
-        };
-        console.log(`Created Safe Transaction Request: `);
-        console.log(req);
-        return req;
-    });
+async function buildSafeTransactionRequest(signer, args, safeContractConfig, metadata) {
+    const safeFactory = safeContractConfig.SafeFactory;
+    const safeMultisend = safeContractConfig.SafeMultisend;
+    const transaction = aggregateTransaction(args.transactions, safeMultisend);
+    const safeTxnGas = "0";
+    const baseGas = "0";
+    const gasPrice = "0";
+    const gasToken = viem_1.zeroAddress;
+    const refundReceiver = viem_1.zeroAddress;
+    const safeAddress = (0, derive_1.deriveSafe)(args.from, safeFactory);
+    // Generate the struct hash
+    // NOTE: this includes a client side optimization over the current relayers
+    // Generates struct hash locally instead of going across the network using the RPC call
+    const structHash = createStructHash(args.chainId, safeAddress, transaction.to, transaction.value, transaction.data, transaction.operation, safeTxnGas, baseGas, gasPrice, gasToken, refundReceiver, args.nonce);
+    const sig = await createSafeSignature(signer, structHash);
+    // Split the sig then pack it into Gnosis accepted rsv format
+    const packedSig = (0, utils_1.splitAndPackSig)(sig);
+    const sigParams = {
+        gasPrice,
+        operation: `${transaction.operation}`,
+        safeTxnGas,
+        baseGas,
+        gasToken,
+        refundReceiver,
+    };
+    if (metadata == undefined) {
+        metadata = "";
+    }
+    const req = {
+        from: args.from,
+        to: transaction.to,
+        proxyWallet: safeAddress,
+        data: transaction.data,
+        nonce: args.nonce,
+        signature: packedSig,
+        signatureParams: sigParams,
+        type: types_1.TransactionType.SAFE,
+        metadata: metadata,
+    };
+    console.log(`Created Safe Transaction Request: `);
+    console.log(req);
+    return req;
 }

package/dist/client.d.ts

@@ -1,17 +1,19 @@
-import { Provider, TransactionResponse } from "@ethersproject/providers";
+import { Wallet } from "@ethersproject/wallet";
+import { JsonRpcSigner } from "@ethersproject/providers";
+import { WalletClient } from "viem";
+import { IAbstractSigner } from "@polymarket/abstract-signer";
 import { HttpClient } from "./http-helpers";
-import { AddressPayload, AuthArgs, ManualOverrides, NoncePayload, ProxyTransaction, RelayerTransaction, RelayerTransactionResponse, RelayPayload, SafeTransaction } from "./types";
+import { AddressPayload, AuthArgs, IManualTransactionResponse, ManualOverrides, NoncePayload, ProxyTransaction, RelayerTransaction, RelayerTransactionResponse, RelayPayload, SafeTransaction } from "./types";
 import { AuthHandler } from "./auth";
-import { ViemTransactionResponse } from "./response";
-import { SignerAdapter } from "./signeradapter";
+import { ContractConfig } from "./config";
 export declare class RelayClient {
     readonly relayerUrl: string;
     readonly chainId: number;
+    readonly contractConfig: ContractConfig;
     readonly httpClient: HttpClient;
-    readonly signer?: SignerAdapter;
-    readonly provider?: Provider;
+    readonly signer?: IAbstractSigner;
     readonly authHandler?: AuthHandler;
-    constructor(relayerUrl: string, chainId: number, signer?: SignerAdapter, authArgs?: AuthArgs);
+    constructor(relayerUrl: string, chainId: number, signer?: Wallet | JsonRpcSigner | WalletClient, authArgs?: AuthArgs);
     getRelayAddress(): Promise<AddressPayload>;
     getNonce(signerAddress: string, signerType: string): Promise<NoncePayload>;
     getRelayPayload(signerAddress: string, signerType: string): Promise<RelayPayload>;
@@ -19,7 +21,7 @@ export declare class RelayClient {
     getTransactions(): Promise<RelayerTransaction[]>;
     executeProxyTransactions(txns: ProxyTransaction[], metadata?: string): Promise<RelayerTransactionResponse>;
     executeSafeTransactions(txns: SafeTransaction[], metadata?: string): Promise<RelayerTransactionResponse>;
-    executeManualTransactions(txns: SafeTransaction[], overrides?: ManualOverrides): Promise<TransactionResponse | ViemTransactionResponse>;
+    executeManualTransactions(txns: SafeTransaction[], overrides?: ManualOverrides): Promise<IManualTransactionResponse>;
     deploySafe(): Promise<RelayerTransactionResponse>;
     /**
      * Periodically polls the transaction id until it reaches a desired state