@polymarket/relayer-client 3.0.0 → 4.0.0

package/dist/abis/safeFactory.d.ts

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

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

@@ -1,15 +0,0 @@
-import { HttpClient } from "../http-helpers/index.ts";
-import { 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

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

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

package/dist/auth/index.js

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

package/dist/builder/create.d.ts

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

package/dist/builder/create.js

@@ -1,48 +0,0 @@
-import { TransactionType } from "../types.js";
-import { SAFE_FACTORY_NAME } from "../constants/index.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

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

package/dist/builder/derive.js

@@ -1,16 +0,0 @@
-import { keccak256, encodePacked, getCreate2Address, encodeAbiParameters } from 'viem';
-import { SAFE_INIT_CODE_HASH, PROXY_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

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

package/dist/builder/index.js

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

package/dist/builder/proxy.d.ts

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

package/dist/builder/proxy.js

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

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

package/dist/builder/safe.js

@@ -1,100 +0,0 @@
-import { hashTypedData, zeroAddress } from "viem";
-import { TransactionType } from "../types.js";
-import { deriveSafe } from "./derive.js";
-import { createSafeMultisendTransaction } from "../encode/safe.js";
-import { splitAndPackSig } from "../utils/index.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

@@ -1,41 +0,0 @@
-import { Wallet } from "@ethersproject/wallet";
-import { JsonRpcSigner } from "@ethersproject/providers";
-import { WalletClient } from "viem";
-import { IAbstractSigner } from "@polymarket/abstract-signer";
-import { HttpClient } from "./http-helpers/index.ts";
-import { AddressPayload, AuthArgs, IManualTransactionResponse, ManualOverrides, NoncePayload, ProxyTransaction, RelayerTransaction, RelayerTransactionResponse, RelayPayload, SafeTransaction } from "./types.ts";
-import { AuthHandler } from "./auth/handler.ts";
-import { ContractConfig } from "./config/index.ts";
-export declare class RelayClient {
-    readonly relayerUrl: string;
-    readonly chainId: number;
-    readonly contractConfig: ContractConfig;
-    readonly httpClient: HttpClient;
-    readonly signer?: IAbstractSigner;
-    readonly authHandler?: AuthHandler;
-    constructor(relayerUrl: string, chainId: number, signer?: Wallet | JsonRpcSigner | WalletClient, authArgs?: AuthArgs);
-    getRelayAddress(): Promise<AddressPayload>;
-    getNonce(signerAddress: string, signerType: string): Promise<NoncePayload>;
-    getRelayPayload(signerAddress: string, signerType: string): Promise<RelayPayload>;
-    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;
-}