@polymarket/relayer-client 3.0.0 → 4.0.0

package/dist/client.js

@@ -1,173 +0,0 @@
-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 { executeManualTransactions } from "./manual/index.js";
-import { ClientRelayerTransactionResponse } from "./response/index.js";
-import { getContractConfig } from "./config/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 = createAbstractSigner(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

@@ -1,13 +0,0 @@
-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

@@ -1,31 +0,0 @@
-;
-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

@@ -1,3 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

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

package/dist/encode/index.js

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

package/dist/encode/proxy.d.ts

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

package/dist/encode/proxy.js

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

package/dist/encode/safe.d.ts

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

package/dist/encode/safe.js

@@ -1,19 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,10 +0,0 @@
-import { AxiosInstance, AxiosResponse, 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

@@ -1,46 +0,0 @@
-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

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

package/dist/index.js

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

package/dist/manual/index.d.ts

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

package/dist/manual/index.js

@@ -1,47 +0,0 @@
-import { encodePacked, hexToBigInt, zeroAddress } from "viem";
-import { encodeFunctionData, prepareEncodeFunctionData } 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

@@ -1,21 +0,0 @@
-import { RelayClient } from "../client.ts";
-import { IManualTransactionResponse, RelayerTransaction, 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

@@ -1,37 +0,0 @@
-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/types.d.ts

@@ -1,132 +0,0 @@
-export declare enum TransactionType {
-    PROXY = "PROXY",
-    SAFE = "SAFE",
-    SAFE_CREATE = "SAFE-CREATE"
-}
-export interface SignatureParams {
-    gasPrice?: string;
-    relayerFee?: string;
-    gasLimit?: string;
-    relayHub?: string;
-    relay?: string;
-    operation?: string;
-    safeTxnGas?: string;
-    baseGas?: string;
-    gasToken?: string;
-    refundReceiver?: string;
-    paymentToken?: string;
-    payment?: string;
-    paymentReceiver?: string;
-}
-export interface AddressPayload {
-    address: string;
-}
-export interface NoncePayload {
-    nonce: string;
-}
-export interface RelayPayload {
-    address: string;
-    nonce: string;
-}
-export interface TransactionRequest {
-    type: string;
-    from: string;
-    to: string;
-    proxyWallet?: string;
-    data: string;
-    nonce?: string;
-    signature: string;
-    signatureParams: SignatureParams;
-    metadata?: string;
-}
-export declare enum CallType {
-    Invalid = "0",
-    Call = "1",
-    DelegateCall = "2"
-}
-export interface ProxyTransaction {
-    to: string;
-    typeCode: CallType;
-    data: string;
-    value: string;
-}
-export declare enum OperationType {
-    Call = 0,// 0
-    DelegateCall = 1
-}
-export interface SafeTransaction {
-    to: string;
-    operation: OperationType;
-    data: string;
-    value: string;
-}
-export interface ProxyTransactionArgs {
-    from: string;
-    nonce: string;
-    gasPrice: string;
-    gasLimit?: string;
-    data: string;
-    relay: string;
-}
-export interface SafeTransactionArgs {
-    from: string;
-    nonce: string;
-    chainId: number;
-    transactions: SafeTransaction[];
-}
-export interface SafeCreateTransactionArgs {
-    from: string;
-    chainId: number;
-    paymentToken: string;
-    payment: string;
-    paymentReceiver: string;
-}
-export declare enum RelayerTransactionState {
-    STATE_NEW = "STATE_NEW",
-    STATE_EXECUTED = "STATE_EXECUTED",
-    STATE_MINED = "STATE_MINED",
-    STATE_INVALID = "STATE_INVALID",
-    STATE_CONFIRMED = "STATE_CONFIRMED",
-    STATE_FAILED = "STATE_FAILED"
-}
-export interface RelayerSubRequest {
-    address: string;
-    transactions: string[];
-    cookies?: string;
-}
-export interface AuthArgs {
-    authUrl: string;
-    authToken: string;
-}
-export interface RelayerTransaction {
-    transactionID: string;
-    transactionHash: string;
-    from: string;
-    to: string;
-    proxyAddress: string;
-    data: string;
-    nonce: string;
-    value: string;
-    state: string;
-    type: string;
-    metadata: string;
-    createdAt: Date;
-    updatedAt: Date;
-}
-export interface IManualTransactionResponse {
-    hash: string;
-    transactionHash: string;
-    wait: () => Promise<any>;
-}
-export interface RelayerTransactionResponse {
-    transactionID: string;
-    state: string;
-    hash: string;
-    transactionHash: string;
-    getTransaction: () => Promise<RelayerTransaction[]>;
-    wait: () => Promise<RelayerTransaction | undefined>;
-}
-export interface ManualOverrides {
-    gasLimit?: bigint;
-    gasPrice?: bigint;
-}

package/dist/types.js

@@ -1,28 +0,0 @@
-export var TransactionType;
-(function (TransactionType) {
-    TransactionType["PROXY"] = "PROXY";
-    TransactionType["SAFE"] = "SAFE";
-    TransactionType["SAFE_CREATE"] = "SAFE-CREATE";
-})(TransactionType || (TransactionType = {}));
-export var CallType;
-(function (CallType) {
-    CallType["Invalid"] = "0";
-    CallType["Call"] = "1";
-    CallType["DelegateCall"] = "2";
-})(CallType || (CallType = {}));
-// Safe Transactions
-export var OperationType;
-(function (OperationType) {
-    OperationType[OperationType["Call"] = 0] = "Call";
-    OperationType[OperationType["DelegateCall"] = 1] = "DelegateCall";
-})(OperationType || (OperationType = {}));
-export var RelayerTransactionState;
-(function (RelayerTransactionState) {
-    RelayerTransactionState["STATE_NEW"] = "STATE_NEW";
-    RelayerTransactionState["STATE_EXECUTED"] = "STATE_EXECUTED";
-    RelayerTransactionState["STATE_MINED"] = "STATE_MINED";
-    RelayerTransactionState["STATE_INVALID"] = "STATE_INVALID";
-    RelayerTransactionState["STATE_CONFIRMED"] = "STATE_CONFIRMED";
-    RelayerTransactionState["STATE_FAILED"] = "STATE_FAILED";
-})(RelayerTransactionState || (RelayerTransactionState = {}));
-;

package/dist/utils/index.d.ts

@@ -1,7 +0,0 @@
-export interface SplitSig {
-    r: string;
-    s: string;
-    v: string;
-}
-export declare function splitAndPackSig(sig: string): string;
-export declare function sleep(ms: number): Promise<unknown>;