@polymarket/relayer-client 4.0.0 → 4.1.0

package/dist/abis/safeFactory.d.ts

@@ -0,0 +1,60 @@
+export declare const safeFactoryAbi: ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+    name?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    inputs: ({
+        internalType: string;
+        name: string;
+        type: string;
+        components?: undefined;
+    } | {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    })[];
+    name: string;
+    outputs: never[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[];

package/dist/abis/safeFactory.js

@@ -0,0 +1,224 @@
+export const safeFactoryAbi = [
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "_masterCopy",
+                type: "address",
+            },
+            {
+                internalType: "address",
+                name: "_fallbackHandler",
+                type: "address",
+            },
+        ],
+        stateMutability: "nonpayable",
+        type: "constructor",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: false,
+                internalType: "contract GnosisSafe",
+                name: "proxy",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "address",
+                name: "owner",
+                type: "address",
+            },
+        ],
+        name: "ProxyCreation",
+        type: "event",
+    },
+    {
+        inputs: [],
+        name: "CREATE_PROXY_TYPEHASH",
+        outputs: [
+            {
+                internalType: "bytes32",
+                name: "",
+                type: "bytes32",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "DOMAIN_TYPEHASH",
+        outputs: [
+            {
+                internalType: "bytes32",
+                name: "",
+                type: "bytes32",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "NAME",
+        outputs: [
+            {
+                internalType: "string",
+                name: "",
+                type: "string",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "user",
+                type: "address",
+            },
+        ],
+        name: "computeProxyAddress",
+        outputs: [
+            {
+                internalType: "address",
+                name: "",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "paymentToken",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "payment",
+                type: "uint256",
+            },
+            {
+                internalType: "address payable",
+                name: "paymentReceiver",
+                type: "address",
+            },
+            {
+                components: [
+                    {
+                        internalType: "uint8",
+                        name: "v",
+                        type: "uint8",
+                    },
+                    {
+                        internalType: "bytes32",
+                        name: "r",
+                        type: "bytes32",
+                    },
+                    {
+                        internalType: "bytes32",
+                        name: "s",
+                        type: "bytes32",
+                    },
+                ],
+                internalType: "struct SafeProxyFactory.Sig",
+                name: "createSig",
+                type: "tuple",
+            },
+        ],
+        name: "createProxy",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "domainSeparator",
+        outputs: [
+            {
+                internalType: "bytes32",
+                name: "",
+                type: "bytes32",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "fallbackHandler",
+        outputs: [
+            {
+                internalType: "address",
+                name: "",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getContractBytecode",
+        outputs: [
+            {
+                internalType: "bytes",
+                name: "",
+                type: "bytes",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "user",
+                type: "address",
+            },
+        ],
+        name: "getSalt",
+        outputs: [
+            {
+                internalType: "bytes32",
+                name: "",
+                type: "bytes32",
+            },
+        ],
+        stateMutability: "pure",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "masterCopy",
+        outputs: [
+            {
+                internalType: "address",
+                name: "",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "proxyCreationCode",
+        outputs: [
+            {
+                internalType: "bytes",
+                name: "",
+                type: "bytes",
+            },
+        ],
+        stateMutability: "pure",
+        type: "function",
+    },
+];

package/dist/auth/handler.d.ts

@@ -0,0 +1,15 @@
+import { type HttpClient } from "../http-helpers/index.ts";
+import type { AuthArgs } from "../types.ts";
+export declare class AuthHandler {
+    readonly url: string;
+    readonly httpClient: HttpClient;
+    readonly token?: string;
+    private cookie?;
+    constructor(httpClient: HttpClient, args: AuthArgs);
+    /**
+     * Logs in to the auth url
+     * Extracts polymarket session cookies from the auth response header and cache it locally.
+     */
+    login(): Promise<void>;
+    getPolymarketCookies(): Promise<string>;
+}

package/dist/auth/handler.js

@@ -0,0 +1,46 @@
+import { GET } from "../http-helpers/index.js";
+const POLYMARKET_COOKIE_NAME = "polymarket";
+export class AuthHandler {
+    url;
+    httpClient;
+    token;
+    cookie;
+    constructor(httpClient, args) {
+        if (args.authUrl === undefined || args.authToken === undefined) {
+            throw new Error("invalid authorization arguments");
+        }
+        this.url = args.authUrl.endsWith("/") ? args.authUrl.slice(0, -1) : args.authUrl;
+        this.token = args.authToken;
+        this.httpClient = httpClient;
+    }
+    /**
+     * Logs in to the auth url
+     * Extracts polymarket session cookies from the auth response header and cache it locally.
+     */
+    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`, 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!`);
+        }
+    }
+    async getPolymarketCookies() {
+        if (this.cookie === undefined) {
+            console.log("Authorization not set, logging in...");
+            await this.login();
+        }
+        return this.cookie;
+    }
+}

package/dist/auth/index.d.ts

@@ -0,0 +1 @@
+export * from "./handler.ts";

package/dist/auth/index.js

@@ -0,0 +1 @@
+export * from "./handler.js";

package/dist/builder/create.d.ts

@@ -0,0 +1,4 @@
+import type { SafeContractConfig } from "../config/index.ts";
+import type { RelayerSigner } from "../signer/index.ts";
+import { type SafeCreateTransactionArgs, type TransactionRequest } from "../types.ts";
+export declare function buildSafeCreateTransactionRequest(signer: RelayerSigner, safeContractConfig: SafeContractConfig, args: SafeCreateTransactionArgs): Promise<TransactionRequest>;

package/dist/builder/create.js

@@ -0,0 +1,48 @@
+import { SAFE_FACTORY_NAME } from "../constants/index.js";
+import { TransactionType, } from "../types.js";
+import { deriveSafe } from "./derive.js";
+async function createSafeCreateSignature(signer, safeFactory, chainId, paymentToken, payment, paymentReceiver) {
+    const domain = {
+        name: 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;
+}
+export 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 = 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: 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,16 @@
+import { encodeAbiParameters, encodePacked, getCreate2Address, keccak256 } from "viem";
+import { PROXY_INIT_CODE_HASH, SAFE_INIT_CODE_HASH } from "../constants/index.js";
+export const deriveProxyWallet = (address, proxyFactory) => {
+    return getCreate2Address({
+        bytecodeHash: PROXY_INIT_CODE_HASH,
+        from: proxyFactory,
+        salt: keccak256(encodePacked(["address"], [address])),
+    });
+};
+export const deriveSafe = (address, safeFactory) => {
+    return getCreate2Address({
+        bytecodeHash: SAFE_INIT_CODE_HASH,
+        from: safeFactory,
+        salt: keccak256(encodeAbiParameters([{ name: "address", type: "address" }], [address])),
+    });
+};

package/dist/builder/index.d.ts

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

package/dist/builder/index.js

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

package/dist/builder/proxy.d.ts

@@ -0,0 +1,4 @@
+import type { ProxyContractConfig } from "../config/index.ts";
+import type { RelayerSigner } from "../signer/index.ts";
+import { type ProxyTransactionArgs, type TransactionRequest } from "../types.ts";
+export declare function buildProxyTransactionRequest(signer: RelayerSigner, args: ProxyTransactionArgs, proxyContractConfig: ProxyContractConfig, metadata?: string): Promise<TransactionRequest>;

package/dist/builder/proxy.js

@@ -0,0 +1,72 @@
+import { concat, keccak256, toHex } from "viem";
+import { TransactionType, } from "../types.js";
+import { deriveProxyWallet } from "./derive.js";
+function createStructHash(from, to, data, txFee, gasPrice, gasLimit, nonce, relayHubAddress, relayAddress) {
+    const relayHubPrefix = toHex("rlx:");
+    const encodedFrom = from;
+    const encodedTo = to;
+    const encodedData = data;
+    const encodedTxFee = toHex(BigInt(txFee), { size: 32 });
+    const encodedGasPrice = toHex(BigInt(gasPrice), { size: 32 });
+    const encodedGasLimit = toHex(BigInt(gasLimit), { size: 32 });
+    const encodedNonce = toHex(BigInt(nonce), { size: 32 });
+    const encodedRelayHubAddress = relayHubAddress;
+    const encodedRelayAddress = relayAddress;
+    const dataToHash = concat([
+        relayHubPrefix,
+        encodedFrom,
+        encodedTo,
+        encodedData,
+        encodedTxFee,
+        encodedGasPrice,
+        encodedGasLimit,
+        encodedNonce,
+        encodedRelayHubAddress,
+        encodedRelayAddress,
+    ]);
+    return keccak256(dataToHash);
+}
+async function createProxySignature(signer, structHash) {
+    return signer.signMessage(structHash);
+}
+export async function buildProxyTransactionRequest(signer, args, proxyContractConfig, metadata) {
+    const proxyWalletFactory = proxyContractConfig.ProxyFactory;
+    const to = proxyWalletFactory;
+    const proxy = 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: TransactionType.PROXY,
+        metadata: metadata,
+    };
+    console.log(`Created Proxy Transaction Request:`);
+    console.log(req);
+    return req;
+}

package/dist/builder/safe.d.ts

@@ -0,0 +1,5 @@
+import type { SafeContractConfig } from "../config/index.ts";
+import type { RelayerSigner } from "../signer/index.ts";
+import { type SafeTransaction, type SafeTransactionArgs, type TransactionRequest } from "../types.ts";
+export declare function aggregateTransaction(txns: SafeTransaction[], safeMultisend: string): SafeTransaction;
+export declare function buildSafeTransactionRequest(signer: RelayerSigner, args: SafeTransactionArgs, safeContractConfig: SafeContractConfig, metadata?: string): Promise<TransactionRequest>;

package/dist/builder/safe.js

@@ -0,0 +1,105 @@
+import { hashTypedData, zeroAddress } from "viem";
+import { createSafeMultisendTransaction } from "../encode/safe.js";
+import { TransactionType, } from "../types.js";
+import { splitAndPackSig } from "../utils/index.js";
+import { deriveSafe } from "./derive.js";
+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 = {
+        chainId: chainId,
+        verifyingContract: safe,
+    };
+    const types = {
+        // keccak256(
+        //     "SafeTx(address to,uint256 value,bytes data,uint8 operation,uint256 safeTxGas,uint256 baseGas,uint256 gasPrice,address gasToken,address refundReceiver,uint256 nonce)"
+        // );
+        SafeTx: [
+            { name: "to", type: "address" },
+            { name: "value", type: "uint256" },
+            { name: "data", type: "bytes" },
+            { name: "operation", type: "uint8" },
+            { name: "safeTxGas", type: "uint256" },
+            { name: "baseGas", type: "uint256" },
+            { name: "gasPrice", type: "uint256" },
+            { name: "gasToken", type: "address" },
+            { name: "refundReceiver", type: "address" },
+            { name: "nonce", type: "uint256" },
+        ],
+    };
+    const values = {
+        to: to,
+        value: value,
+        data: data,
+        operation: operation,
+        safeTxGas: safeTxGas,
+        baseGas: baseGas,
+        gasPrice: gasPrice,
+        gasToken: gasToken,
+        refundReceiver: refundReceiver,
+        nonce: nonce,
+    };
+    // // viem hashTypedData
+    // const structHash = _TypedDataEncoder.hash(domain, types, values);
+    const structHash = hashTypedData({
+        primaryType: "SafeTx",
+        domain: domain,
+        types: types,
+        message: values,
+    });
+    return structHash;
+}
+export function aggregateTransaction(txns, safeMultisend) {
+    let transaction;
+    if (txns.length === 1) {
+        transaction = txns[0];
+    }
+    else {
+        transaction = createSafeMultisendTransaction(txns, safeMultisend);
+    }
+    return transaction;
+}
+export 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 = zeroAddress;
+    const refundReceiver = zeroAddress;
+    const safeAddress = 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 = 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: TransactionType.SAFE,
+        metadata: metadata,
+    };
+    console.log(`Created Safe Transaction Request: `);
+    console.log(req);
+    return req;
+}

package/dist/client.d.ts

@@ -0,0 +1,39 @@
+import { type WalletClient } from "viem";
+import { AuthHandler } from "./auth/handler.ts";
+import { type ContractConfig } from "./config/index.ts";
+import { HttpClient } from "./http-helpers/index.ts";
+import { type RelayerSigner } from "./signer/index.ts";
+import { type AddressPayload, type AuthArgs, type IManualTransactionResponse, type ManualOverrides, type NoncePayload, type ProxyTransaction, type RelayerTransaction, type RelayerTransactionResponse, type RelayPayload, type SafeTransaction } from "./types.ts";
+export declare class RelayClient {
+    readonly relayerUrl: string;
+    readonly chainId: number;
+    readonly contractConfig: ContractConfig;
+    readonly httpClient: HttpClient;
+    readonly signer?: RelayerSigner;
+    readonly authHandler?: AuthHandler;
+    constructor(relayerUrl: string, chainId: number, signer?: WalletClient, authArgs?: AuthArgs);
+    getRelayAddress(): Promise<AddressPayload>;
+    getNonce(signerAddress: string, signerType: string): Promise<NoncePayload>;
+    getRelayPayload(signerAddress: string, signerType: string): Promise<RelayPayload>;
+    getTransaction(transactionId: string): Promise<RelayerTransaction[]>;
+    getTransactions(): Promise<RelayerTransaction[]>;
+    executeProxyTransactions(txns: ProxyTransaction[], metadata?: string): Promise<RelayerTransactionResponse>;
+    executeSafeTransactions(txns: SafeTransaction[], metadata?: string): Promise<RelayerTransactionResponse>;
+    executeManualTransactions(txns: SafeTransaction[], overrides?: ManualOverrides): Promise<IManualTransactionResponse>;
+    deploySafe(): Promise<RelayerTransactionResponse>;
+    /**
+     * 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
+     */
+    pollUntilState(transactionId: string, states: string[], failState?: string, maxPolls?: number, pollFrequency?: number): Promise<RelayerTransaction | undefined>;
+    private submitTransaction;
+    private send;
+}