@polymarket/relayer-client 0.0.1

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,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeFactoryAbi = void 0;
+exports.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,12 @@
+import { AxiosRequestHeaders } from "axios";
+import { AuthArgs } from "../../src/types";
+export declare class AuthHandler {
+    readonly url: string;
+    readonly token?: string;
+    private cookie?;
+    constructor(args: AuthArgs);
+    login(): Promise<void>;
+    isLoggedIn(): boolean;
+    getAuthHeader(): Promise<AxiosRequestHeaders>;
+    getPolymarketCookies(): Promise<string>;
+}

package/dist/auth/handler.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthHandler = void 0;
+const tslib_1 = require("tslib");
+const http_helpers_1 = require("../../src/http-helpers");
+const POLYMARKET_COOKIE_NAME = "polymarket";
+class AuthHandler {
+    constructor(args) {
+        if (args.token == undefined && args.cookie == undefined) {
+            throw new Error("invalid authorization arguments");
+        }
+        this.url = args.authUrl.endsWith("/") ? args.authUrl.slice(0, -1) : args.authUrl;
+        ;
+        if (args.token !== undefined) {
+            this.token = args.token;
+        }
+        if (args.cookie !== undefined) {
+            this.cookie = args.cookie;
+        }
+    }
+    login() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.token == undefined) {
+                throw new Error("authorization token missing");
+            }
+            const resp = yield http_helpers_1.raw_get(`${this.url}/login`, {
+                headers: {
+                    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!`);
+            }
+        });
+    }
+    isLoggedIn() {
+        return this.cookie != undefined;
+    }
+    getAuthHeader() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return { "Cookie": yield this.getPolymarketCookies() };
+        });
+    }
+    getPolymarketCookies() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!this.isLoggedIn()) {
+                console.log("Authorization not set, logging in...");
+                yield this.login();
+            }
+            return this.cookie;
+        });
+    }
+}
+exports.AuthHandler = AuthHandler;

package/dist/auth/index.d.ts

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

package/dist/auth/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./handler"), exports);

package/dist/builder/create.d.ts

@@ -0,0 +1,4 @@
+import { Wallet } from "@ethersproject/wallet";
+import { JsonRpcSigner } from "@ethersproject/providers";
+import { SafeCreateTransactionArgs, TransactionRequest } from "../types";
+export declare function buildSafeCreateTransactionRequest(signer: Wallet | JsonRpcSigner, args: SafeCreateTransactionArgs): Promise<TransactionRequest>;

package/dist/builder/create.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSafeCreateTransactionRequest = void 0;
+const tslib_1 = require("tslib");
+const ethers_1 = require("ethers");
+const types_1 = require("../types");
+const constants_1 = require("../constants");
+const utils_1 = require("./utils");
+function createSafeCreateSignature(signer, chainId, paymentToken, payment, paymentReceiver) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const domain = {
+            name: constants_1.SAFE_FACTORY_NAME,
+            chainId: ethers_1.BigNumber.from(chainId).toHexString(),
+            verifyingContract: constants_1.SAFE_FACTORY_ADDRESS,
+        };
+        const types = {
+            CreateProxy: [
+                { name: "paymentToken", type: "address" },
+                { name: "payment", type: "uint256" },
+                { name: "paymentReceiver", type: "address" },
+            ],
+        };
+        const values = {
+            paymentToken,
+            payment: ethers_1.BigNumber.from(payment),
+            paymentReceiver,
+        };
+        return signer._signTypedData(domain, types, values);
+    });
+}
+function buildSafeCreateTransactionRequest(signer, args) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const sig = yield createSafeCreateSignature(signer, args.chainId, args.paymentToken, args.payment, args.paymentReceiver);
+        const sigParams = {
+            paymentToken: args.paymentToken,
+            payment: args.payment,
+            paymentReceiver: args.paymentReceiver,
+        };
+        const safeAddress = utils_1.deriveSafe(args.from);
+        const request = {
+            from: args.from,
+            to: constants_1.SAFE_FACTORY_ADDRESS,
+            // 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: types_1.TransactionType.SAFE_CREATE,
+        };
+        console.log(`Created a SAFE-CREATE Transaction:`);
+        console.log(request);
+        return request;
+    });
+}
+exports.buildSafeCreateTransactionRequest = buildSafeCreateTransactionRequest;

package/dist/builder/index.d.ts

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

package/dist/builder/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./proxy"), exports);
+tslib_1.__exportStar(require("./safe"), exports);

package/dist/builder/proxy.d.ts

@@ -0,0 +1,4 @@
+import { Wallet } from "@ethersproject/wallet";
+import { JsonRpcSigner } from "@ethersproject/providers";
+import { ProxyTransactionArgs, TransactionRequest } from "../types";
+export declare function buildProxyTransactionRequest(signer: Wallet | JsonRpcSigner, args: ProxyTransactionArgs): Promise<TransactionRequest>;

package/dist/builder/proxy.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProxyTransactionRequest = void 0;
+const tslib_1 = require("tslib");
+const web3_utils_1 = tslib_1.__importDefault(require("web3-utils"));
+const constants_1 = require("../constants");
+const types_1 = require("../types");
+const utils_1 = require("./utils");
+const ethers_1 = require("ethers");
+const utils_2 = require("ethers/lib/utils");
+const relayPrefix = "rlx:";
+const zeroPad = "0000000000000000000000000000000000000000000000000000000000000000";
+function padTo64(_hex) {
+    let hex = _hex;
+    if (hex.length < 64) {
+        hex = (zeroPad + hex).slice(-64);
+    }
+    return hex;
+}
+function removeHexPrefix(hex) {
+    return hex.replace(/^0x/, "");
+}
+function toUint256NoPrefix(hexString) {
+    return padTo64(removeHexPrefix(hexString));
+}
+function bytesToHexNoPrefix(bytes) {
+    let hex = removeHexPrefix(web3_utils_1.default.toHex(bytes));
+    if (hex.length % 2 !== 0) {
+        hex = "0" + hex;
+    }
+    return hex;
+}
+function createStructHash(from, to, data, txFee, gasPrice, gasLimit, nonce, relayHubAddress, relayAddress) {
+    const txhstr = bytesToHexNoPrefix(data);
+    const dataToHash = Buffer.from(relayPrefix).toString("hex") +
+        removeHexPrefix(from) +
+        removeHexPrefix(to) +
+        txhstr +
+        toUint256NoPrefix(ethers_1.BigNumber.from(txFee).toHexString()) +
+        toUint256NoPrefix(ethers_1.BigNumber.from(gasPrice).toHexString()) +
+        toUint256NoPrefix(ethers_1.BigNumber.from(gasLimit).toHexString()) +
+        toUint256NoPrefix(ethers_1.BigNumber.from(nonce).toHexString()) +
+        removeHexPrefix(relayHubAddress) +
+        removeHexPrefix(relayAddress);
+    return utils_2.keccak256("0x" + dataToHash);
+}
+function createProxySignature(signer, structHash) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return signer.signMessage(utils_2.arrayify(structHash));
+    });
+}
+function buildProxyTransactionRequest(signer, args) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const to = constants_1.PROXY_WALLET_FACTORY_ADDRESS;
+        const proxy = utils_1.deriveProxyWallet(args.from);
+        const relayerFee = "0";
+        const relayHub = constants_1.RELAY_HUB_ADDRESS;
+        const gasLimit = yield signer.provider.estimateGas({
+            to: to,
+            data: args.data,
+        });
+        const gasLimitStr = gasLimit.toString();
+        console.log(`GasLimit: ${gasLimitStr}`);
+        const sigParams = {
+            gasPrice: args.gasPrice,
+            gasLimit: gasLimitStr,
+            relayerFee: relayerFee,
+            relayHub: constants_1.RELAY_HUB_ADDRESS,
+            relay: args.relay,
+        };
+        const txHash = createStructHash(args.from, to, args.data, relayerFee, args.gasPrice, gasLimitStr, args.nonce, relayHub, args.relay);
+        const sig = yield createProxySignature(signer, txHash);
+        const req = {
+            from: args.from,
+            to: to,
+            proxyWallet: proxy,
+            data: args.data,
+            nonce: args.nonce,
+            signature: sig,
+            signatureParams: sigParams,
+            type: types_1.TransactionType.PROXY,
+        };
+        console.log(`Created Proxy Transaction Request:`);
+        console.log(req);
+        return req;
+    });
+}
+exports.buildProxyTransactionRequest = buildProxyTransactionRequest;

package/dist/builder/safe.d.ts

@@ -0,0 +1,4 @@
+import { Wallet } from "@ethersproject/wallet";
+import { JsonRpcSigner } from "@ethersproject/providers";
+import { SafeTransactionArgs, TransactionRequest } from "../types";
+export declare function buildSafeTransactionRequest(signer: Wallet | JsonRpcSigner, args: SafeTransactionArgs): Promise<TransactionRequest>;

package/dist/builder/safe.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSafeTransactionRequest = void 0;
+const tslib_1 = require("tslib");
+const types_1 = require("../types");
+const utils_1 = require("./utils");
+const ethers_1 = require("ethers");
+const utils_2 = require("ethers/lib/utils");
+const safe_1 = require("../encode/safe");
+const utils_3 = require("../encode/utils");
+function createSafeSignature(signer, structHash) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return signer.signMessage(ethers_1.ethers.utils.arrayify(structHash));
+    });
+}
+function splitSignature(sig) {
+    let sigV = parseInt(sig.slice(-2), 16);
+    switch (sigV) {
+        case 0:
+        case 1:
+            sigV += 31;
+            break;
+        case 27:
+        case 28:
+            sigV += 4;
+            break;
+        default:
+            throw new Error("Invalid signature");
+    }
+    sig = sig.slice(0, -2) + sigV.toString(16);
+    return {
+        r: ethers_1.BigNumber.from("0x" + sig.slice(2, 66)).toString(),
+        s: ethers_1.BigNumber.from("0x" + sig.slice(66, 130)).toString(),
+        v: ethers_1.BigNumber.from("0x" + sig.slice(130, 132)).toString(),
+    };
+}
+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,
+    };
+    const structHash = utils_2._TypedDataEncoder.hash(domain, types, values);
+    // console.log(`Safe Struct Hash: ${structHash}`);
+    return structHash;
+}
+function aggregateTransaction(txns) {
+    let transaction;
+    if (txns.length == 1) {
+        transaction = txns[0];
+    }
+    else {
+        transaction = safe_1.createSafeMultisendTransaction(txns);
+    }
+    return transaction;
+}
+function buildSafeTransactionRequest(signer, args) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const transaction = aggregateTransaction(args.transactions);
+        const safeTxnGas = "0";
+        const baseGas = "0";
+        const gasPrice = "0";
+        const gasToken = ethers_1.ethers.constants.AddressZero;
+        const refundReceiver = ethers_1.ethers.constants.AddressZero;
+        const safeAddress = utils_1.deriveSafe(args.from);
+        // 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 = yield createSafeSignature(signer, structHash);
+        // Split the sig then pack it into Gnosis accepted rsv format
+        const splitSig = splitSignature(sig);
+        const packedSig = utils_3.abiEncodePacked({ type: "uint256", value: splitSig.r }, { type: "uint256", value: splitSig.s }, { type: "uint8", value: splitSig.v });
+        const sigParams = {
+            gasPrice,
+            operation: `${transaction.operation}`,
+            safeTxnGas,
+            baseGas,
+            gasToken,
+            refundReceiver,
+        };
+        const req = {
+            from: args.from,
+            to: transaction.to,
+            proxyWallet: safeAddress,
+            data: transaction.data,
+            nonce: args.nonce,
+            signature: packedSig,
+            signatureParams: sigParams,
+            type: types_1.TransactionType.SAFE,
+        };
+        console.log(`Created Safe Transaction Request: `);
+        console.log(req);
+        return req;
+    });
+}
+exports.buildSafeTransactionRequest = buildSafeTransactionRequest;

package/dist/builder/utils.d.ts

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

package/dist/builder/utils.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveSafe = exports.deriveProxyWallet = void 0;
+const sdk_1 = require("@polymarket/sdk");
+const ethers_1 = require("ethers");
+const constants_1 = require("../constants");
+exports.deriveProxyWallet = (address) => {
+    return sdk_1.getProxyWalletAddress(constants_1.PROXY_WALLET_FACTORY_ADDRESS, address);
+};
+exports.deriveSafe = (address) => {
+    return ethers_1.ethers.utils.getCreate2Address(constants_1.SAFE_FACTORY_ADDRESS, ethers_1.ethers.utils.keccak256(ethers_1.ethers.utils.defaultAbiCoder.encode(["address"], [address])), constants_1.SAFE_INIT_CODE_HASH);
+};