@polymarket/relayer-client 4.0.0 → 4.1.0

package/dist/client.js

@@ -0,0 +1,173 @@
+import { isBrowser } from "browser-or-node";
+import { zeroAddress } from "viem";
+import { AuthHandler } from "./auth/handler.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 { createViemSigner } from "./signer/index.js";
+import { TransactionType, } from "./types.js";
+import { sleep } from "./utils/index.js";
+export class RelayClient {
+    relayerUrl;
+    chainId;
+    contractConfig;
+    httpClient;
+    signer;
+    authHandler;
+    constructor(relayerUrl, chainId, signer, authArgs) {
+        this.relayerUrl = relayerUrl.endsWith("/") ? relayerUrl.slice(0, -1) : relayerUrl;
+        this.chainId = chainId;
+        this.contractConfig = getContractConfig(chainId);
+        this.httpClient = new HttpClient();
+        if (signer !== undefined) {
+            this.signer = createViemSigner(chainId, signer);
+        }
+        if (authArgs !== undefined) {
+            this.authHandler = new AuthHandler(this.httpClient, authArgs);
+        }
+    }
+    async getRelayAddress() {
+        return this.send(`${this.relayerUrl}${GET_ADDRESS}`, GET);
+    }
+    async getNonce(signerAddress, signerType) {
+        return this.send(`${this.relayerUrl}${GET_NONCE}?address=${signerAddress}&type=${signerType}`, GET);
+    }
+    async getRelayPayload(signerAddress, signerType) {
+        return this.send(`${this.relayerUrl}${GET_RELAY_PAYLOAD}?address=${signerAddress}&type=${signerType}`, GET);
+    }
+    async getTransaction(transactionId) {
+        return this.send(`${this.relayerUrl}${GET_TRANSACTION}?id=${transactionId}`, GET);
+    }
+    async getTransactions() {
+        return this.send(`${this.relayerUrl}${GET_TRANSACTION}s`, GET);
+    }
+    async executeProxyTransactions(txns, metadata) {
+        if (this.signer === undefined) {
+            throw new Error("missing signer");
+        }
+        const start = Date.now();
+        const from = await this.signer.getAddress();
+        const rp = await this.getRelayPayload(from, TransactionType.PROXY);
+        const args = {
+            from: from,
+            gasPrice: "0",
+            data: encodeProxyTransactionData(txns),
+            relay: rp.address,
+            nonce: rp.nonce,
+        };
+        const proxyContractConfig = this.contractConfig.ProxyContracts;
+        const request = await buildProxyTransactionRequest(this.signer, args, proxyContractConfig, metadata);
+        console.log(`Client side proxy request creation took: ${(Date.now() - start) / 1000} seconds`);
+        const resp = await this.submitTransaction(request);
+        return new ClientRelayerTransactionResponse(resp.transactionID, resp.state, resp.transactionHash, this);
+    }
+    async executeSafeTransactions(txns, metadata) {
+        if (this.signer === undefined) {
+            throw new Error("missing signer");
+        }
+        const start = Date.now();
+        const from = await this.signer.getAddress();
+        const noncePayload = await this.getNonce(from, TransactionType.SAFE);
+        const args = {
+            transactions: txns,
+            from,
+            nonce: noncePayload.nonce,
+            chainId: this.chainId,
+        };
+        const safeContractConfig = this.contractConfig.SafeContracts;
+        const request = await buildSafeTransactionRequest(this.signer, args, safeContractConfig, metadata);
+        console.log(`Client side safe request creation took: ${(Date.now() - start) / 1000} seconds`);
+        const resp = await this.submitTransaction(request);
+        return new ClientRelayerTransactionResponse(resp.transactionID, resp.state, resp.transactionHash, this);
+    }
+    async executeManualTransactions(txns, overrides) {
+        if (overrides === undefined) {
+            overrides = {};
+        }
+        if (this.signer === undefined) {
+            throw new Error("missing signer");
+        }
+        return executeManualTransactions(this.signer, this.contractConfig.SafeContracts, txns, overrides);
+    }
+    async deploySafe() {
+        if (this.signer === undefined) {
+            throw new Error("missing signer");
+        }
+        const start = Date.now();
+        const from = await this.signer?.getAddress();
+        const args = {
+            from: from,
+            chainId: this.chainId,
+            paymentToken: zeroAddress,
+            payment: "0",
+            paymentReceiver: zeroAddress,
+        };
+        const safeContractConfig = this.contractConfig.SafeContracts;
+        const request = await buildSafeCreateTransactionRequest(this.signer, safeContractConfig, args);
+        console.log(`Client side deploy request creation took: ${(Date.now() - start) / 1000} seconds`);
+        const resp = await this.submitTransaction(request);
+        return new ClientRelayerTransactionResponse(resp.transactionID, resp.state, resp.transactionHash, this);
+    }
+    /**
+     * Periodically polls the transaction id until it reaches a desired state
+     * Returns the relayer transaction if it does each the desired state
+     * Returns undefined if the transaction hits the failed state
+     * Times out after maxPolls is reached
+     * @param transactionId
+     * @param states
+     * @param failState
+     * @param maxPolls
+     * @param pollFrequency
+     * @returns
+     */
+    async pollUntilState(transactionId, states, failState, maxPolls, pollFrequency) {
+        console.log(`Waiting for transaction ${transactionId} matching states: ${states}...`);
+        const maxPollCount = maxPolls !== undefined ? maxPolls : 10;
+        let pollFreq = 2000; // Default to polling every 2 seconds
+        if (pollFrequency !== undefined) {
+            if (pollFrequency >= 1000) {
+                pollFreq = pollFrequency;
+            }
+        }
+        let pollCount = 0;
+        while (pollCount < maxPollCount) {
+            const txns = await this.getTransaction(transactionId);
+            if (txns.length > 0) {
+                const txn = txns[0];
+                if (states.includes(txn.state)) {
+                    return txn;
+                }
+                if (failState !== undefined && txn.state === failState) {
+                    // Return undefined if txn reaches the fail state
+                    return undefined;
+                }
+            }
+            pollCount++;
+            await sleep(pollFreq);
+        }
+        console.log(`Transaction not found or not in given states, timing out`);
+    }
+    async submitTransaction(req) {
+        return this.send(`${this.relayerUrl}${SUBMIT_TRANSACTION}`, POST, undefined, req);
+    }
+    async send(endpoint, method, headers, data, params) {
+        // Explicitly inject the polymarket session cookies
+        // In prod environments, this will be unnecessary as the browser will have the needed cookies
+        // Needed only for local testing
+        if (!isBrowser && this.authHandler !== undefined) {
+            const cookie = await this.authHandler.getPolymarketCookies();
+            if (headers !== undefined) {
+                headers.Cookie = cookie;
+            }
+            else {
+                headers = { Cookie: cookie };
+            }
+        }
+        const resp = await this.httpClient.send(endpoint, method, headers, data, params);
+        return resp.data;
+    }
+}

package/dist/config/index.d.ts

@@ -0,0 +1,13 @@
+export interface ProxyContractConfig {
+    RelayHub: string;
+    ProxyFactory: string;
+}
+export interface SafeContractConfig {
+    SafeFactory: string;
+    SafeMultisend: string;
+}
+export interface ContractConfig {
+    ProxyContracts: ProxyContractConfig;
+    SafeContracts: SafeContractConfig;
+}
+export declare const getContractConfig: (chainId: number) => ContractConfig;

package/dist/config/index.js

@@ -0,0 +1,30 @@
+const AMOY = {
+    ProxyContracts: {
+        ProxyFactory: "",
+        RelayHub: "",
+    },
+    SafeContracts: {
+        SafeFactory: "",
+        SafeMultisend: "",
+    },
+};
+const POL = {
+    ProxyContracts: {
+        ProxyFactory: "0xaB45c5A4B0c941a2F231C04C3f49182e1A254052",
+        RelayHub: "0xD216153c06E857cD7f72665E0aF1d7D82172F494",
+    },
+    SafeContracts: {
+        SafeFactory: "0xaacFeEa03eb1561C4e67d661e40682Bd20E3541b",
+        SafeMultisend: "0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761",
+    },
+};
+export const getContractConfig = (chainId) => {
+    switch (chainId) {
+        case 137:
+            return POL;
+        case 80002:
+            return AMOY;
+        default:
+            throw new Error("Invalid network");
+    }
+};

package/dist/constants/index.d.ts

@@ -0,0 +1,3 @@
+export declare const PROXY_INIT_CODE_HASH = "0xd21df8dc65880a8606f09fe0ce3df9b8869287ab0b058be05aa9e8af6330a00b";
+export declare const SAFE_INIT_CODE_HASH = "0x2bce2127ff07fb632d16c8347c4ebf501f4841168bed00d9e6ef715ddb6fcecf";
+export declare const SAFE_FACTORY_NAME = "Polymarket Contract Proxy Factory";

package/dist/constants/index.js

@@ -0,0 +1,3 @@
+export const PROXY_INIT_CODE_HASH = "0xd21df8dc65880a8606f09fe0ce3df9b8869287ab0b058be05aa9e8af6330a00b";
+export const SAFE_INIT_CODE_HASH = "0x2bce2127ff07fb632d16c8347c4ebf501f4841168bed00d9e6ef715ddb6fcecf";
+export const SAFE_FACTORY_NAME = "Polymarket Contract Proxy Factory";

package/dist/encode/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./proxy.ts";
+export * from "./safe.ts";

package/dist/encode/index.js

@@ -0,0 +1,2 @@
+export * from "./proxy.js";
+export * from "./safe.js";

package/dist/encode/proxy.d.ts

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

package/dist/encode/proxy.js

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

package/dist/encode/safe.d.ts

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

package/dist/encode/safe.js

@@ -0,0 +1,25 @@
+import { concatHex, encodeFunctionData, encodePacked, prepareEncodeFunctionData, size, } from "viem";
+import { multisendAbi } from "../abis/index.js";
+import { OperationType } from "../types.js";
+const multisend = prepareEncodeFunctionData({
+    abi: multisendAbi,
+    functionName: "multiSend",
+});
+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,
+        ]))),
+    ];
+    const data = encodeFunctionData({ ...multisend, args: args });
+    return {
+        to: safeMultisendAddress,
+        value: "0",
+        data: data,
+        operation: OperationType.DelegateCall,
+    };
+};

package/dist/endpoints.d.ts

@@ -0,0 +1,5 @@
+export declare const GET_ADDRESS = "/address";
+export declare const GET_NONCE = "/nonce";
+export declare const GET_RELAY_PAYLOAD = "/relay-payload";
+export declare const GET_TRANSACTION = "/transaction";
+export declare const SUBMIT_TRANSACTION = "/submit";

package/dist/endpoints.js

@@ -0,0 +1,5 @@
+export const GET_ADDRESS = "/address";
+export const GET_NONCE = "/nonce";
+export const GET_RELAY_PAYLOAD = "/relay-payload";
+export const GET_TRANSACTION = "/transaction";
+export const SUBMIT_TRANSACTION = "/submit";

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

@@ -0,0 +1,10 @@
+import { type AxiosInstance, type AxiosResponse, type Method } from "axios";
+export declare const GET = "GET";
+export declare const POST = "POST";
+export declare const DELETE = "DELETE";
+export declare const PUT = "PUT";
+export declare class HttpClient {
+    readonly instance: AxiosInstance;
+    constructor();
+    send(endpoint: string, method: Method, headers?: any, data?: any, params?: any): Promise<AxiosResponse>;
+}

package/dist/http-helpers/index.js

@@ -0,0 +1,46 @@
+import axios from "axios";
+export const GET = "GET";
+export const POST = "POST";
+export const DELETE = "DELETE";
+export const PUT = "PUT";
+export class HttpClient {
+    instance;
+    constructor() {
+        this.instance = axios.create({ withCredentials: true });
+    }
+    async send(endpoint, method, headers, data, params) {
+        if (headers !== undefined) {
+            headers["Access-Control-Allow-Credentials"] = true;
+        }
+        try {
+            const resp = await this.instance.request({
+                method,
+                url: endpoint,
+                headers,
+                data,
+                params,
+            });
+            return resp;
+        }
+        catch (err) {
+            if (axios.isAxiosError(err)) {
+                if (err.response) {
+                    const errPayload = {
+                        error: "request error",
+                        status: err.response?.status,
+                        statusText: err.response?.statusText,
+                        data: err.response?.data,
+                    };
+                    console.error("request error", errPayload);
+                    throw new Error(JSON.stringify(errPayload));
+                }
+                else {
+                    const errPayload = { error: "connection error" };
+                    console.error("connection error", errPayload);
+                    throw new Error(JSON.stringify(errPayload));
+                }
+            }
+            throw new Error(JSON.stringify({ error: err }));
+        }
+    }
+}

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/manual/index.d.ts

@@ -0,0 +1,5 @@
+import type { SafeContractConfig } from "../config/index.ts";
+import { ManualTransactionResponse } from "../response/index.ts";
+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

@@ -0,0 +1,49 @@
+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",
+});
+export async function executeManualTransactions(signer, safeContractConfig, transactions, overrides) {
+    const from = await signer.getAddress();
+    const aggTxn = aggregateTransaction(transactions, safeContractConfig.SafeMultisend);
+    const sig = encodePacked(["uint256", "uint256", "uint8"], [BigInt(hexToBigInt(from)), BigInt(0), 1]);
+    const safeAddress = deriveSafe(from, safeContractConfig.SafeFactory);
+    // calldata
+    const data = encodeFunctionData({
+        ...safeExecTransaction,
+        args: [
+            aggTxn.to,
+            aggTxn.value,
+            aggTxn.data,
+            aggTxn.operation,
+            0,
+            0,
+            0,
+            zeroAddress,
+            zeroAddress,
+            sig,
+        ],
+    });
+    if (overrides.gasLimit === undefined) {
+        const gasLimit = await signer.estimateGas({
+            to: safeAddress,
+            data: data,
+            from: from,
+        });
+        console.log(`Estimated gas Limit: ${gasLimit}`);
+        overrides.gasLimit = gasLimit;
+    }
+    const txHash = await signer.sendTransaction({
+        data: data,
+        to: safeAddress,
+        gasPrice: overrides.gasPrice,
+        gasLimit: overrides.gasLimit,
+    });
+    const waitFunc = (txHash) => {
+        return signer.waitTillMined(txHash);
+    };
+    return new ManualTransactionResponse(txHash, waitFunc);
+}

package/dist/response/index.d.ts

@@ -0,0 +1,21 @@
+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;
+    readonly transactionHash: string;
+    readonly hash: string;
+    readonly state: string;
+    constructor(transactionID: string, state: string, transactionHash: string, client: RelayClient);
+    getTransaction(): Promise<RelayerTransaction[]>;
+    wait(): Promise<RelayerTransaction | undefined>;
+}
+type WaitUntilMinedFunction = (transactionHash: string) => Promise<any>;
+export declare class ManualTransactionResponse implements IManualTransactionResponse {
+    readonly hash: string;
+    readonly transactionHash: string;
+    private waitTillMined;
+    constructor(transactionHash: string, waitTillMinedFunc: WaitUntilMinedFunction);
+    wait(): Promise<any>;
+}
+export {};

package/dist/response/index.js

@@ -0,0 +1,34 @@
+import { RelayerTransactionState, } from "../types.js";
+export class ClientRelayerTransactionResponse {
+    client;
+    transactionID;
+    transactionHash;
+    hash;
+    state;
+    constructor(transactionID, state, transactionHash, client) {
+        this.transactionID = transactionID;
+        this.state = state;
+        this.transactionHash = transactionHash;
+        this.hash = transactionHash;
+        this.client = client;
+    }
+    async getTransaction() {
+        return this.client.getTransaction(this.transactionID);
+    }
+    async wait() {
+        return this.client.pollUntilState(this.transactionID, [RelayerTransactionState.STATE_MINED, RelayerTransactionState.STATE_CONFIRMED], RelayerTransactionState.STATE_FAILED, 30);
+    }
+}
+export class ManualTransactionResponse {
+    hash;
+    transactionHash;
+    waitTillMined;
+    constructor(transactionHash, waitTillMinedFunc) {
+        this.transactionHash = transactionHash;
+        this.hash = transactionHash;
+        this.waitTillMined = waitTillMinedFunc;
+    }
+    async wait() {
+        return this.waitTillMined(this.hash);
+    }
+}

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,
+            });
+        },
+    };
+}