@polymarket/relayer-client 3.0.0 → 4.1.0

package/dist/client.js

@@ -1,16 +1,16 @@
 import { isBrowser } from "browser-or-node";
 import { zeroAddress } from "viem";
-import { createAbstractSigner } from "@polymarket/abstract-signer";
-import { GET, POST, HttpClient, } from "./http-helpers/index.js";
-import { TransactionType } from "./types.js";
-import { GET_ADDRESS, GET_NONCE, GET_RELAY_PAYLOAD, GET_TRANSACTION, SUBMIT_TRANSACTION, } from "./endpoints.js";
-import { buildProxyTransactionRequest, buildSafeTransactionRequest, buildSafeCreateTransactionRequest, } from "./builder/index.js";
-import { encodeProxyTransactionData } from "./encode/index.js";
 import { AuthHandler } from "./auth/handler.js";
-import { sleep } from "./utils/index.js";
+import { buildProxyTransactionRequest, buildSafeCreateTransactionRequest, buildSafeTransactionRequest, } from "./builder/index.js";
+import { getContractConfig } from "./config/index.js";
+import { encodeProxyTransactionData } from "./encode/index.js";
+import { GET_ADDRESS, GET_NONCE, GET_RELAY_PAYLOAD, GET_TRANSACTION, SUBMIT_TRANSACTION, } from "./endpoints.js";
+import { GET, HttpClient, POST } from "./http-helpers/index.js";
 import { executeManualTransactions } from "./manual/index.js";
 import { ClientRelayerTransactionResponse } from "./response/index.js";
-import { getContractConfig } from "./config/index.js";
+import { createViemSigner } from "./signer/index.js";
+import { TransactionType, } from "./types.js";
+import { sleep } from "./utils/index.js";
 export class RelayClient {
     relayerUrl;
     chainId;
@@ -23,8 +23,8 @@ export class RelayClient {
         this.chainId = chainId;
         this.contractConfig = getContractConfig(chainId);
         this.httpClient = new HttpClient();
-        if (signer != undefined) {
-            this.signer = createAbstractSigner(chainId, signer);
+        if (signer !== undefined) {
+            this.signer = createViemSigner(chainId, signer);
         }
         if (authArgs !== undefined) {
             this.authHandler = new AuthHandler(this.httpClient, authArgs);
@@ -46,7 +46,7 @@ export class RelayClient {
         return this.send(`${this.relayerUrl}${GET_TRANSACTION}s`, GET);
     }
     async executeProxyTransactions(txns, metadata) {
-        if (this.signer == undefined) {
+        if (this.signer === undefined) {
             throw new Error("missing signer");
         }
         const start = Date.now();
@@ -66,7 +66,7 @@ export class RelayClient {
         return new ClientRelayerTransactionResponse(resp.transactionID, resp.state, resp.transactionHash, this);
     }
     async executeSafeTransactions(txns, metadata) {
-        if (this.signer == undefined) {
+        if (this.signer === undefined) {
             throw new Error("missing signer");
         }
         const start = Date.now();
@@ -85,16 +85,16 @@ export class RelayClient {
         return new ClientRelayerTransactionResponse(resp.transactionID, resp.state, resp.transactionHash, this);
     }
     async executeManualTransactions(txns, overrides) {
-        if (overrides == undefined) {
+        if (overrides === undefined) {
             overrides = {};
         }
-        if (this.signer == undefined) {
+        if (this.signer === undefined) {
             throw new Error("missing signer");
         }
         return executeManualTransactions(this.signer, this.contractConfig.SafeContracts, txns, overrides);
     }
     async deploySafe() {
-        if (this.signer == undefined) {
+        if (this.signer === undefined) {
             throw new Error("missing signer");
         }
         const start = Date.now();
@@ -126,9 +126,9 @@ export class RelayClient {
      */
     async pollUntilState(transactionId, states, failState, maxPolls, pollFrequency) {
         console.log(`Waiting for transaction ${transactionId} matching states: ${states}...`);
-        const maxPollCount = maxPolls != undefined ? maxPolls : 10;
+        const maxPollCount = maxPolls !== undefined ? maxPolls : 10;
         let pollFreq = 2000; // Default to polling every 2 seconds
-        if (pollFrequency != undefined) {
+        if (pollFrequency !== undefined) {
             if (pollFrequency >= 1000) {
                 pollFreq = pollFrequency;
             }
@@ -141,7 +141,7 @@ export class RelayClient {
                 if (states.includes(txn.state)) {
                     return txn;
                 }
-                if (failState != undefined && txn.state == failState) {
+                if (failState !== undefined && txn.state === failState) {
                     // Return undefined if txn reaches the fail state
                     return undefined;
                 }
@@ -160,11 +160,11 @@ export class RelayClient {
         // Needed only for local testing
         if (!isBrowser && this.authHandler !== undefined) {
             const cookie = await this.authHandler.getPolymarketCookies();
-            if (headers != undefined) {
-                headers["Cookie"] = cookie;
+            if (headers !== undefined) {
+                headers.Cookie = cookie;
             }
             else {
-                headers = { "Cookie": cookie };
+                headers = { Cookie: cookie };
             }
         }
         const resp = await this.httpClient.send(endpoint, method, headers, data, params);

package/dist/config/index.js

@@ -1,23 +1,22 @@
-;
 const AMOY = {
     ProxyContracts: {
         ProxyFactory: "",
-        RelayHub: ""
+        RelayHub: "",
     },
     SafeContracts: {
         SafeFactory: "",
         SafeMultisend: "",
-    }
+    },
 };
 const POL = {
     ProxyContracts: {
         ProxyFactory: "0xaB45c5A4B0c941a2F231C04C3f49182e1A254052",
-        RelayHub: "0xD216153c06E857cD7f72665E0aF1d7D82172F494"
+        RelayHub: "0xD216153c06E857cD7f72665E0aF1d7D82172F494",
     },
     SafeContracts: {
         SafeFactory: "0xaacFeEa03eb1561C4e67d661e40682Bd20E3541b",
         SafeMultisend: "0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761",
-    }
+    },
 };
 export const getContractConfig = (chainId) => {
     switch (chainId) {

package/dist/encode/proxy.d.ts

@@ -1,2 +1,2 @@
-import { ProxyTransaction } from "../types.ts";
+import type { ProxyTransaction } from "../types.ts";
 export declare function encodeProxyTransactionData(txns: ProxyTransaction[]): string;

package/dist/encode/proxy.js

@@ -1,8 +1,8 @@
-import { proxyWalletFactory } from "../abis/index.js";
 import { encodeFunctionData, prepareEncodeFunctionData } from "viem";
+import { proxyWalletFactory } from "../abis/index.js";
 const proxy = prepareEncodeFunctionData({
     abi: proxyWalletFactory,
-    functionName: 'proxy',
+    functionName: "proxy",
 });
 export function encodeProxyTransactionData(txns) {
     return encodeFunctionData({

package/dist/encode/safe.d.ts

@@ -1,2 +1,2 @@
-import { SafeTransaction } from "../types.ts";
+import { type SafeTransaction } from "../types.ts";
 export declare const createSafeMultisendTransaction: (txns: SafeTransaction[], safeMultisendAddress: string) => SafeTransaction;

package/dist/encode/safe.js

@@ -1,4 +1,4 @@
-import { concatHex, encodeFunctionData, encodePacked, prepareEncodeFunctionData, size } from "viem";
+import { concatHex, encodeFunctionData, encodePacked, prepareEncodeFunctionData, size, } from "viem";
 import { multisendAbi } from "../abis/index.js";
 import { OperationType } from "../types.js";
 const multisend = prepareEncodeFunctionData({
@@ -7,7 +7,13 @@ const multisend = prepareEncodeFunctionData({
 });
 export const createSafeMultisendTransaction = (txns, safeMultisendAddress) => {
     const args = [
-        concatHex(txns.map(tx => encodePacked(["uint8", "address", "uint256", "uint256", "bytes"], [tx.operation, tx.to, BigInt(tx.value), BigInt(size(tx.data)), tx.data]))),
+        concatHex(txns.map(tx => encodePacked(["uint8", "address", "uint256", "uint256", "bytes"], [
+            tx.operation,
+            tx.to,
+            BigInt(tx.value),
+            BigInt(size(tx.data)),
+            tx.data,
+        ]))),
     ];
     const data = encodeFunctionData({ ...multisend, args: args });
     return {

package/dist/http-helpers/index.d.ts

@@ -1,4 +1,4 @@
-import { AxiosInstance, AxiosResponse, Method } from "axios";
+import { type AxiosInstance, type AxiosResponse, type Method } from "axios";
 export declare const GET = "GET";
 export declare const POST = "POST";
 export declare const DELETE = "DELETE";

package/dist/http-helpers/index.js

@@ -9,7 +9,7 @@ export class HttpClient {
         this.instance = axios.create({ withCredentials: true });
     }
     async send(endpoint, method, headers, data, params) {
-        if (headers != undefined) {
+        if (headers !== undefined) {
             headers["Access-Control-Allow-Credentials"] = true;
         }
         try {
@@ -18,7 +18,7 @@ export class HttpClient {
                 url: endpoint,
                 headers,
                 data,
-                params
+                params,
             });
             return resp;
         }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export * from "./client.ts";
 export * from "./encode/index.ts";
-export * from "./types.ts";
 export * from "./response/index.ts";
+export * from "./types.ts";

package/dist/index.js

@@ -1,4 +1,4 @@
 export * from "./client.js";
 export * from "./encode/index.js";
-export * from "./types.js";
 export * from "./response/index.js";
+export * from "./types.js";

package/dist/manual/index.d.ts

@@ -1,5 +1,5 @@
-import { IAbstractSigner } from "@polymarket/abstract-signer";
-import { SafeContractConfig } from "../config/index.ts";
-import { SafeTransaction, ManualOverrides } from "../types.ts";
+import type { SafeContractConfig } from "../config/index.ts";
 import { ManualTransactionResponse } from "../response/index.ts";
-export declare function executeManualTransactions(signer: IAbstractSigner, safeContractConfig: SafeContractConfig, transactions: SafeTransaction[], overrides: ManualOverrides): Promise<ManualTransactionResponse>;
+import type { RelayerSigner } from "../signer/index.ts";
+import type { ManualOverrides, SafeTransaction } from "../types.ts";
+export declare function executeManualTransactions(signer: RelayerSigner, safeContractConfig: SafeContractConfig, transactions: SafeTransaction[], overrides: ManualOverrides): Promise<ManualTransactionResponse>;

package/dist/manual/index.js

@@ -1,11 +1,10 @@
-import { encodePacked, hexToBigInt, zeroAddress } from "viem";
-import { encodeFunctionData, prepareEncodeFunctionData } from "viem";
+import { encodeFunctionData, encodePacked, hexToBigInt, prepareEncodeFunctionData, zeroAddress, } from "viem";
 import { safeAbi } from "../abis/index.js";
 import { aggregateTransaction, deriveSafe } from "../builder/index.js";
 import { ManualTransactionResponse } from "../response/index.js";
 const safeExecTransaction = prepareEncodeFunctionData({
     abi: safeAbi,
-    functionName: 'execTransaction',
+    functionName: "execTransaction",
 });
 export async function executeManualTransactions(signer, safeContractConfig, transactions, overrides) {
     const from = await signer.getAddress();
@@ -13,7 +12,9 @@ export async function executeManualTransactions(signer, safeContractConfig, tran
     const sig = encodePacked(["uint256", "uint256", "uint8"], [BigInt(hexToBigInt(from)), BigInt(0), 1]);
     const safeAddress = deriveSafe(from, safeContractConfig.SafeFactory);
     // calldata
-    const data = encodeFunctionData({ ...safeExecTransaction, args: [
+    const data = encodeFunctionData({
+        ...safeExecTransaction,
+        args: [
             aggTxn.to,
             aggTxn.value,
             aggTxn.data,
@@ -24,8 +25,9 @@ export async function executeManualTransactions(signer, safeContractConfig, tran
             zeroAddress,
             zeroAddress,
             sig,
-        ] });
-    if (overrides.gasLimit == undefined) {
+        ],
+    });
+    if (overrides.gasLimit === undefined) {
         const gasLimit = await signer.estimateGas({
             to: safeAddress,
             data: data,

package/dist/response/index.d.ts

@@ -1,5 +1,5 @@
-import { RelayClient } from "../client.ts";
-import { IManualTransactionResponse, RelayerTransaction, RelayerTransactionResponse } from "../types.ts";
+import type { RelayClient } from "../client.ts";
+import { type IManualTransactionResponse, type RelayerTransaction, type RelayerTransactionResponse } from "../types.ts";
 export declare class ClientRelayerTransactionResponse implements RelayerTransactionResponse {
     readonly client: RelayClient;
     readonly transactionID: string;

package/dist/response/index.js

@@ -1,4 +1,4 @@
-import { RelayerTransactionState } from "../types.js";
+import { RelayerTransactionState, } from "../types.js";
 export class ClientRelayerTransactionResponse {
     client;
     transactionID;
@@ -16,10 +16,7 @@ export class ClientRelayerTransactionResponse {
         return this.client.getTransaction(this.transactionID);
     }
     async wait() {
-        return this.client.pollUntilState(this.transactionID, [
-            RelayerTransactionState.STATE_MINED,
-            RelayerTransactionState.STATE_CONFIRMED,
-        ], RelayerTransactionState.STATE_FAILED, 30);
+        return this.client.pollUntilState(this.transactionID, [RelayerTransactionState.STATE_MINED, RelayerTransactionState.STATE_CONFIRMED], RelayerTransactionState.STATE_FAILED, 30);
     }
 }
 export class ManualTransactionResponse {

package/dist/signer/index.d.ts

@@ -0,0 +1,26 @@
+import { type WalletClient } from "viem";
+type TypedDataDomain = Record<string, unknown>;
+type TypedDataTypes = Record<string, Array<{
+    name: string;
+    type: string;
+}>>;
+type TypedDataValue = Record<string, unknown>;
+export interface Transaction {
+    from?: string;
+    to?: string;
+    nonce?: number;
+    gasLimit?: bigint;
+    gasPrice?: bigint;
+    data?: string;
+    value?: bigint;
+}
+export interface RelayerSigner {
+    signMessage(message: string): Promise<string>;
+    signTypedData(domain: TypedDataDomain, types: TypedDataTypes, value: TypedDataValue, primaryType?: string): Promise<string>;
+    getAddress(): Promise<string>;
+    estimateGas(tx: Transaction): Promise<bigint>;
+    sendTransaction(tx: Transaction): Promise<string>;
+    waitTillMined(txHash: string): Promise<unknown>;
+}
+export declare function createViemSigner(chainId: number, walletClient: WalletClient): RelayerSigner;
+export {};

package/dist/signer/index.js

@@ -0,0 +1,109 @@
+import { createPublicClient, toBytes, } from "viem";
+import { polygon, polygonAmoy } from "viem/chains";
+function chainIdToChain(chainId) {
+    switch (chainId) {
+        case 137:
+            return polygon;
+        case 80002:
+            return polygonAmoy;
+        default:
+            throw new Error(`unsupported chainId ${chainId}`);
+    }
+}
+async function getWalletClientAddress(walletClient) {
+    const accountAddress = walletClient.account?.address;
+    if (typeof accountAddress === "string" && accountAddress.length > 0) {
+        return accountAddress;
+    }
+    try {
+        const [address] = await walletClient.getAddresses();
+        if (typeof address === "string" && address.length > 0) {
+            return address;
+        }
+    }
+    catch {
+        // Fall back to requestAddresses for wallets that require user interaction.
+    }
+    const [requestedAddress] = await walletClient.requestAddresses();
+    if (typeof requestedAddress === "string" && requestedAddress.length > 0) {
+        return requestedAddress;
+    }
+    throw new Error("wallet client is missing account address");
+}
+async function getWalletClientAccount(walletClient) {
+    if (walletClient.account !== undefined) {
+        return walletClient.account;
+    }
+    return getWalletClientAddress(walletClient);
+}
+export function createViemSigner(chainId, walletClient) {
+    if (walletClient.chain !== undefined && walletClient.chain.id !== chainId) {
+        throw new Error("wallet client chain id does not match chain id");
+    }
+    const chain = walletClient.chain ?? chainIdToChain(chainId);
+    const walletTransport = walletClient.transport;
+    const transport = () => ({
+        config: walletTransport.config,
+        name: walletTransport.name,
+        request: walletTransport.request,
+        type: walletTransport.type,
+        value: walletTransport.value,
+    });
+    const publicClient = createPublicClient({
+        chain,
+        transport,
+    });
+    return {
+        async signMessage(message) {
+            const account = await getWalletClientAccount(walletClient);
+            return walletClient.signMessage({
+                account,
+                message: { raw: toBytes(message) },
+            });
+        },
+        async signTypedData(domain, types, value, primaryType) {
+            if (primaryType === undefined) {
+                throw new Error("primaryType is required in viem signers");
+            }
+            const account = await getWalletClientAccount(walletClient);
+            return walletClient.signTypedData({
+                account,
+                domain,
+                types,
+                primaryType,
+                message: value,
+            });
+        },
+        async getAddress() {
+            return getWalletClientAddress(walletClient);
+        },
+        async estimateGas(tx) {
+            const account = tx.from ?? (await getWalletClientAddress(walletClient));
+            return publicClient.estimateGas({
+                account: account,
+                to: tx.to,
+                data: tx.data,
+                value: tx.value,
+                nonce: tx.nonce,
+            });
+        },
+        async sendTransaction(tx) {
+            const account = await getWalletClientAccount(walletClient);
+            return walletClient.sendTransaction({
+                account,
+                chain,
+                to: tx.to,
+                data: tx.data,
+                value: tx.value,
+                gas: tx.gasLimit,
+                gasPrice: tx.gasPrice,
+                nonce: tx.nonce,
+            });
+        },
+        async waitTillMined(txHash) {
+            return publicClient.waitForTransactionReceipt({
+                hash: txHash,
+            });
+        },
+    };
+}

package/dist/types.js

@@ -25,4 +25,3 @@ export var RelayerTransactionState;
     RelayerTransactionState["STATE_CONFIRMED"] = "STATE_CONFIRMED";
     RelayerTransactionState["STATE_FAILED"] = "STATE_FAILED";
 })(RelayerTransactionState || (RelayerTransactionState = {}));
-;

package/dist/utils/index.js

@@ -1,7 +1,7 @@
 import { encodePacked, hexToBigInt } from "viem";
 export function splitAndPackSig(sig) {
     const splitSig = splitSignature(sig);
-    const packedSig = encodePacked(["uint256", "uint256", "uint8"], [BigInt(splitSig.r), BigInt(splitSig.s), parseInt(splitSig.v)]);
+    const packedSig = encodePacked(["uint256", "uint256", "uint8"], [BigInt(splitSig.r), BigInt(splitSig.s), parseInt(splitSig.v, 10)]);
     return packedSig;
 }
 function splitSignature(sig) {
@@ -20,9 +20,9 @@ function splitSignature(sig) {
     }
     sig = sig.slice(0, -2) + sigV.toString(16);
     return {
-        r: hexToBigInt('0x' + sig.slice(2, 66)).toString(),
-        s: hexToBigInt('0x' + sig.slice(66, 130)).toString(),
-        v: hexToBigInt('0x' + sig.slice(130, 132)).toString(),
+        r: hexToBigInt(`0x${sig.slice(2, 66)}`).toString(),
+        s: hexToBigInt(`0x${sig.slice(66, 130)}`).toString(),
+        v: hexToBigInt(`0x${sig.slice(130, 132)}`).toString(),
     };
 }
 export function sleep(ms) {

package/package.json

@@ -1,46 +1,39 @@
 {
     "name": "@polymarket/relayer-client",
     "description": "Client for Polymarket relayers",
-    "version": "3.0.0",
+    "version": "4.1.0",
     "type": "module",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        }
+    },
     "files": [
         "/dist"
     ],
     "sideEffects": false,
     "scripts": {
-        "build": "make build",
+        "build": "tsc --project tsconfig.production.json",
+        "check": "biome check .",
         "clean": "rm -rf ./dist",
-        "test": "make test"
+        "format": "biome format --write .",
+        "test": "vitest run"
     },
     "devDependencies": {
-        "@types/chai": "5.2.2",
-        "@types/mocha": "10.0.10",
-        "@types/node": "^18.7.18",
+        "@biomejs/biome": "2.4.5",
+        "@types/node": "^22.13.10",
         "@types/ws": "^8.5.3",
-        "chai": "5.2.0",
-        "dotenv": "^16.0.2",
-        "esm": "^3.2.25",
-        "jsdom": "^20.0.0",
-        "jsdom-global": "^3.0.2",
-        "mocha": "9.2.2",
-        "path": "^0.12.7",
-        "prettier": "^2.7.1",
-        "ts-node": "^9.1.1",
-        "tsconfig-paths": "^4.2.0",
-        "tslib": "^2.8.1",
-        "tsx": "^4.20.3",
-        "typescript": "^5.8.3",
+        "dotenv": "^17.3.1",
+        "typescript": "^5.9.3",
+        "vitest": "^4.0.18",
         "ws": "^8.11.0"
     },
     "dependencies": {
-        "@ethersproject/providers": "5.7.2",
-        "@ethersproject/wallet": "5.7.0",
-        "@polymarket/abstract-signer": "0.0.8",
         "axios": "^1.13.2",
         "browser-or-node": "^3.0.0",
-        "ethers": "5.7.2",
-        "viem": "^2.31.4"
+        "viem": "^2.47.0"
     }
 }