@polymarbot/shared 0.5.4 → 0.6.0

package/chunk-LHBGF66E.js

@@ -0,0 +1,73 @@
+// src/utils/wallet.ts
+import { createPublicClient, http, formatUnits, parseAbi } from "viem";
+import { polygon } from "viem/chains";
+var USDC_ADDRESS = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
+var USDC_DECIMALS = 6;
+var USDC_ABI = parseAbi(["function balanceOf(address) view returns (uint256)"]);
+var getPublicClient = /* @__PURE__ */ (() => {
+  let client = null;
+  let batchClient = null;
+  return (options) => {
+    const rpcUrl = process.env.POLYGON_RPC || polygon.rpcUrls.default.http[0];
+    if (options?.batch) {
+      if (!batchClient) {
+        batchClient = createPublicClient({
+          chain: polygon,
+          transport: http(rpcUrl, { batch: { batchSize: 100, wait: 0 } })
+        });
+      }
+      return batchClient;
+    }
+    if (!client) {
+      client = createPublicClient({
+        chain: polygon,
+        transport: http(rpcUrl)
+      });
+    }
+    return client;
+  };
+})();
+function formatBalance(rawBalance, decimals = USDC_DECIMALS) {
+  const num = parseFloat(formatUnits(BigInt(rawBalance), decimals));
+  return (Math.floor(num * 100) / 100).toFixed(2);
+}
+async function getUSDCBalance(address) {
+  const publicClient = getPublicClient();
+  return await publicClient.readContract({
+    address: USDC_ADDRESS,
+    abi: USDC_ABI,
+    functionName: "balanceOf",
+    args: [address]
+  });
+}
+async function getUSDCBalancesBatch(addresses) {
+  if (addresses.length === 0) {
+    return [];
+  }
+  const publicClient = getPublicClient();
+  return await publicClient.multicall({
+    contracts: addresses.map((address) => ({
+      address: USDC_ADDRESS,
+      abi: USDC_ABI,
+      functionName: "balanceOf",
+      args: [address]
+    })),
+    allowFailure: true
+  });
+}
+function isAddressEqual(a, b) {
+  if (!a) return false;
+  if (!b) return false;
+  return a.toLowerCase() === b.toLowerCase();
+}
+
+export {
+  USDC_ADDRESS,
+  USDC_DECIMALS,
+  USDC_ABI,
+  getPublicClient,
+  formatBalance,
+  getUSDCBalance,
+  getUSDCBalancesBatch,
+  isAddressEqual
+};

package/index.cjs

@@ -7,6 +7,7 @@ module.exports = {
   ...require('./markets/types.cjs'),
   ...require('./markets/utils.cjs'),
   ...require('./relayer-client.cjs'),
+  ...require('./safe-executor.cjs'),
   ...require('./trade-strategy/normalize.cjs'),
   ...require('./trade-strategy/types.cjs'),
   ...require('./wallet.cjs')

package/index.d.cts

@@ -6,6 +6,7 @@ export * from './load-env.js'
 export * from './markets/types.js'
 export * from './markets/utils.js'
 export * from './relayer-client.js'
+export * from './safe-executor.js'
 export * from './trade-strategy/normalize.js'
 export * from './trade-strategy/types.js'
 export * from './wallet.js'

package/index.d.ts

@@ -6,6 +6,7 @@ export * from './load-env.js'
 export * from './markets/types.js'
 export * from './markets/utils.js'
 export * from './relayer-client.js'
+export * from './safe-executor.js'
 export * from './trade-strategy/normalize.js'
 export * from './trade-strategy/types.js'
 export * from './wallet.js'

package/index.js

@@ -6,6 +6,7 @@ export * from './load-env.js'
 export * from './markets/types.js'
 export * from './markets/utils.js'
 export * from './relayer-client.js'
+export * from './safe-executor.js'
 export * from './trade-strategy/normalize.js'
 export * from './trade-strategy/types.js'
 export * from './wallet.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymarbot/shared",
-  "version": "0.5.4",
+  "version": "0.6.0",
   "type": "module",
   "main": "./index.cjs",
   "module": "./index.js",
@@ -96,6 +96,16 @@
         "default": "./relayer-client.cjs"
       }
     },
+    "./safe-executor": {
+      "import": {
+        "types": "./safe-executor.d.ts",
+        "default": "./safe-executor.js"
+      },
+      "require": {
+        "types": "./safe-executor.d.cts",
+        "default": "./safe-executor.cjs"
+      }
+    },
     "./trade-strategy/normalize": {
       "import": {
         "types": "./trade-strategy/normalize.d.ts",
@@ -134,9 +144,10 @@
     "**/*.d.cts"
   ],
   "dependencies": {
-    "dotenv": "^17.3.1",
     "viem": "^2.46.2",
+    "dotenv": "^17.3.1",
     "@polymarket/builder-relayer-client": "^0.0.8",
-    "@polymarket/builder-signing-sdk": "^0.0.8"
+    "@polymarket/builder-signing-sdk": "^0.0.8",
+    "p-limit": "^7.3.0"
   }
 }

package/safe-executor.cjs

@@ -0,0 +1,191 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/safe-executor.ts
+var safe_executor_exports = {};
+__export(safe_executor_exports, {
+  execSafeTransaction: () => execSafeTransaction
+});
+module.exports = __toCommonJS(safe_executor_exports);
+var import_viem2 = require("viem");
+var import_accounts = require("viem/accounts");
+var import_chains2 = require("viem/chains");
+var import_builder_relayer_client = require("@polymarket/builder-relayer-client");
+
+// src/utils/wallet.ts
+var import_viem = require("viem");
+var import_chains = require("viem/chains");
+var USDC_ABI = (0, import_viem.parseAbi)(["function balanceOf(address) view returns (uint256)"]);
+var getPublicClient = /* @__PURE__ */ (() => {
+  let client = null;
+  let batchClient = null;
+  return (options) => {
+    const rpcUrl = process.env.POLYGON_RPC || import_chains.polygon.rpcUrls.default.http[0];
+    if (options?.batch) {
+      if (!batchClient) {
+        batchClient = (0, import_viem.createPublicClient)({
+          chain: import_chains.polygon,
+          transport: (0, import_viem.http)(rpcUrl, { batch: { batchSize: 100, wait: 0 } })
+        });
+      }
+      return batchClient;
+    }
+    if (!client) {
+      client = (0, import_viem.createPublicClient)({
+        chain: import_chains.polygon,
+        transport: (0, import_viem.http)(rpcUrl)
+      });
+    }
+    return client;
+  };
+})();
+
+// src/utils/safe-executor.ts
+var import_p_limit = __toESM(require("p-limit"), 1);
+var SAFE_MULTISEND = "0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761";
+var SAFE_ABI = (0, import_viem2.parseAbi)([
+  "function execTransaction(address to, uint256 value, bytes data, uint8 operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, bytes signatures) payable returns (bool success)",
+  "function nonce() view returns (uint256)"
+]);
+var SAFE_TX_TYPES = {
+  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" }
+  ]
+};
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var gasPayerLimit = (0, import_p_limit.default)(1);
+function aggregateTransaction(txns) {
+  if (txns.length === 0) {
+    throw new Error("No transactions to aggregate");
+  }
+  if (txns.length === 1) {
+    return txns[0];
+  }
+  return (0, import_builder_relayer_client.createSafeMultisendTransaction)(txns, SAFE_MULTISEND);
+}
+function createSafeTxHash(chainId, safeAddress, tx, nonce) {
+  return (0, import_viem2.hashTypedData)({
+    domain: {
+      chainId,
+      verifyingContract: safeAddress
+    },
+    types: SAFE_TX_TYPES,
+    primaryType: "SafeTx",
+    message: {
+      to: tx.to,
+      value: BigInt(tx.value),
+      data: tx.data,
+      operation: tx.operation,
+      safeTxGas: 0n,
+      baseGas: 0n,
+      gasPrice: 0n,
+      gasToken: ZERO_ADDRESS,
+      refundReceiver: ZERO_ADDRESS,
+      nonce
+    }
+  });
+}
+async function signSafeTransaction(ownerPrivateKey, structHash) {
+  const account = (0, import_accounts.privateKeyToAccount)(ownerPrivateKey);
+  const signature = await account.signMessage({
+    message: { raw: (0, import_viem2.toBytes)(structHash) }
+  });
+  const r = signature.slice(0, 66);
+  const s = "0x" + signature.slice(66, 130);
+  const v = parseInt(signature.slice(130, 132), 16);
+  const adjustedV = v + 4;
+  return (0, import_viem2.encodePacked)(
+    ["bytes32", "bytes32", "uint8"],
+    [r, s, adjustedV]
+  );
+}
+async function execSafeTransaction(params) {
+  const {
+    safeAddress,
+    ownerPrivateKey,
+    gasPayerPrivateKey,
+    transactions,
+    chainId = import_chains2.polygon.id
+  } = params;
+  const aggregatedTx = aggregateTransaction(transactions);
+  const publicClient = getPublicClient();
+  const safeNonce = await publicClient.readContract({
+    address: safeAddress,
+    abi: SAFE_ABI,
+    functionName: "nonce"
+  });
+  const safeTxHash = createSafeTxHash(chainId, safeAddress, aggregatedTx, safeNonce);
+  const signature = await signSafeTransaction(ownerPrivateKey, safeTxHash);
+  const txHash = await gasPayerLimit(async () => {
+    const rpcUrl = process.env.POLYGON_RPC || import_chains2.polygon.rpcUrls.default.http[0];
+    const gasPayerAccount = (0, import_accounts.privateKeyToAccount)(gasPayerPrivateKey);
+    const gasPayerWallet = (0, import_viem2.createWalletClient)({
+      account: gasPayerAccount,
+      chain: import_chains2.polygon,
+      transport: (0, import_viem2.http)(rpcUrl)
+    });
+    const hash = await gasPayerWallet.writeContract({
+      address: safeAddress,
+      abi: SAFE_ABI,
+      functionName: "execTransaction",
+      args: [
+        aggregatedTx.to,
+        BigInt(aggregatedTx.value),
+        aggregatedTx.data,
+        aggregatedTx.operation,
+        0n,
+        // safeTxGas
+        0n,
+        // baseGas
+        0n,
+        // gasPrice
+        ZERO_ADDRESS,
+        // gasToken
+        ZERO_ADDRESS,
+        // refundReceiver
+        signature
+      ]
+    });
+    return hash;
+  });
+  return txHash;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  execSafeTransaction
+});

package/safe-executor.d.cts

@@ -0,0 +1,19 @@
+import { Address, Hex, Hash } from 'viem';
+import { SafeTransaction } from '@polymarket/builder-relayer-client';
+
+interface ExecSafeTransactionParams {
+    
+    safeAddress: Address;
+    
+    ownerPrivateKey: Hex;
+    
+    gasPayerPrivateKey: Hex;
+    
+    transactions: SafeTransaction[];
+    
+    chainId?: number;
+}
+
+declare function execSafeTransaction(params: ExecSafeTransactionParams): Promise<Hash>;
+
+export { type ExecSafeTransactionParams, execSafeTransaction };

package/safe-executor.d.ts

@@ -0,0 +1,19 @@
+import { Address, Hex, Hash } from 'viem';
+import { SafeTransaction } from '@polymarket/builder-relayer-client';
+
+interface ExecSafeTransactionParams {
+    
+    safeAddress: Address;
+    
+    ownerPrivateKey: Hex;
+    
+    gasPayerPrivateKey: Hex;
+    
+    transactions: SafeTransaction[];
+    
+    chainId?: number;
+}
+
+declare function execSafeTransaction(params: ExecSafeTransactionParams): Promise<Hash>;
+
+export { type ExecSafeTransactionParams, execSafeTransaction };

package/safe-executor.js

@@ -0,0 +1,138 @@
+import {
+  getPublicClient
+} from "./chunk-LHBGF66E.js";
+import "./chunk-JSBRDJBE.js";
+
+// src/utils/safe-executor.ts
+import {
+  createWalletClient,
+  encodePacked,
+  hashTypedData,
+  http,
+  parseAbi,
+  toBytes
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { polygon } from "viem/chains";
+import { createSafeMultisendTransaction } from "@polymarket/builder-relayer-client";
+import pLimit from "p-limit";
+var SAFE_MULTISEND = "0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761";
+var SAFE_ABI = parseAbi([
+  "function execTransaction(address to, uint256 value, bytes data, uint8 operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, bytes signatures) payable returns (bool success)",
+  "function nonce() view returns (uint256)"
+]);
+var SAFE_TX_TYPES = {
+  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" }
+  ]
+};
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var gasPayerLimit = pLimit(1);
+function aggregateTransaction(txns) {
+  if (txns.length === 0) {
+    throw new Error("No transactions to aggregate");
+  }
+  if (txns.length === 1) {
+    return txns[0];
+  }
+  return createSafeMultisendTransaction(txns, SAFE_MULTISEND);
+}
+function createSafeTxHash(chainId, safeAddress, tx, nonce) {
+  return hashTypedData({
+    domain: {
+      chainId,
+      verifyingContract: safeAddress
+    },
+    types: SAFE_TX_TYPES,
+    primaryType: "SafeTx",
+    message: {
+      to: tx.to,
+      value: BigInt(tx.value),
+      data: tx.data,
+      operation: tx.operation,
+      safeTxGas: 0n,
+      baseGas: 0n,
+      gasPrice: 0n,
+      gasToken: ZERO_ADDRESS,
+      refundReceiver: ZERO_ADDRESS,
+      nonce
+    }
+  });
+}
+async function signSafeTransaction(ownerPrivateKey, structHash) {
+  const account = privateKeyToAccount(ownerPrivateKey);
+  const signature = await account.signMessage({
+    message: { raw: toBytes(structHash) }
+  });
+  const r = signature.slice(0, 66);
+  const s = "0x" + signature.slice(66, 130);
+  const v = parseInt(signature.slice(130, 132), 16);
+  const adjustedV = v + 4;
+  return encodePacked(
+    ["bytes32", "bytes32", "uint8"],
+    [r, s, adjustedV]
+  );
+}
+async function execSafeTransaction(params) {
+  const {
+    safeAddress,
+    ownerPrivateKey,
+    gasPayerPrivateKey,
+    transactions,
+    chainId = polygon.id
+  } = params;
+  const aggregatedTx = aggregateTransaction(transactions);
+  const publicClient = getPublicClient();
+  const safeNonce = await publicClient.readContract({
+    address: safeAddress,
+    abi: SAFE_ABI,
+    functionName: "nonce"
+  });
+  const safeTxHash = createSafeTxHash(chainId, safeAddress, aggregatedTx, safeNonce);
+  const signature = await signSafeTransaction(ownerPrivateKey, safeTxHash);
+  const txHash = await gasPayerLimit(async () => {
+    const rpcUrl = process.env.POLYGON_RPC || polygon.rpcUrls.default.http[0];
+    const gasPayerAccount = privateKeyToAccount(gasPayerPrivateKey);
+    const gasPayerWallet = createWalletClient({
+      account: gasPayerAccount,
+      chain: polygon,
+      transport: http(rpcUrl)
+    });
+    const hash = await gasPayerWallet.writeContract({
+      address: safeAddress,
+      abi: SAFE_ABI,
+      functionName: "execTransaction",
+      args: [
+        aggregatedTx.to,
+        BigInt(aggregatedTx.value),
+        aggregatedTx.data,
+        aggregatedTx.operation,
+        0n,
+        // safeTxGas
+        0n,
+        // baseGas
+        0n,
+        // gasPrice
+        ZERO_ADDRESS,
+        // gasToken
+        ZERO_ADDRESS,
+        // refundReceiver
+        signature
+      ]
+    });
+    return hash;
+  });
+  return txHash;
+}
+export {
+  execSafeTransaction
+};

package/trade-strategy/types.d.cts

@@ -80,6 +80,7 @@ interface TokenTradeStepOrder {
     size: number;
     status: string;
     updatedAt: number;
+    expiresAt?: number;
     keep?: boolean;
 }
 

package/trade-strategy/types.d.ts

@@ -80,6 +80,7 @@ interface TokenTradeStepOrder {
     size: number;
     status: string;
     updatedAt: number;
+    expiresAt?: number;
     keep?: boolean;
 }
 

package/wallet.js

@@ -1,67 +1,14 @@
+import {
+  USDC_ABI,
+  USDC_ADDRESS,
+  USDC_DECIMALS,
+  formatBalance,
+  getPublicClient,
+  getUSDCBalance,
+  getUSDCBalancesBatch,
+  isAddressEqual
+} from "./chunk-LHBGF66E.js";
 import "./chunk-JSBRDJBE.js";
-
-// src/utils/wallet.ts
-import { createPublicClient, http, formatUnits, parseAbi } from "viem";
-import { polygon } from "viem/chains";
-var USDC_ADDRESS = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
-var USDC_DECIMALS = 6;
-var USDC_ABI = parseAbi(["function balanceOf(address) view returns (uint256)"]);
-var getPublicClient = /* @__PURE__ */ (() => {
-  let client = null;
-  let batchClient = null;
-  return (options) => {
-    const rpcUrl = process.env.POLYGON_RPC || polygon.rpcUrls.default.http[0];
-    if (options?.batch) {
-      if (!batchClient) {
-        batchClient = createPublicClient({
-          chain: polygon,
-          transport: http(rpcUrl, { batch: { batchSize: 100, wait: 0 } })
-        });
-      }
-      return batchClient;
-    }
-    if (!client) {
-      client = createPublicClient({
-        chain: polygon,
-        transport: http(rpcUrl)
-      });
-    }
-    return client;
-  };
-})();
-function formatBalance(rawBalance, decimals = USDC_DECIMALS) {
-  const num = parseFloat(formatUnits(BigInt(rawBalance), decimals));
-  return (Math.floor(num * 100) / 100).toFixed(2);
-}
-async function getUSDCBalance(address) {
-  const publicClient = getPublicClient();
-  return await publicClient.readContract({
-    address: USDC_ADDRESS,
-    abi: USDC_ABI,
-    functionName: "balanceOf",
-    args: [address]
-  });
-}
-async function getUSDCBalancesBatch(addresses) {
-  if (addresses.length === 0) {
-    return [];
-  }
-  const publicClient = getPublicClient();
-  return await publicClient.multicall({
-    contracts: addresses.map((address) => ({
-      address: USDC_ADDRESS,
-      abi: USDC_ABI,
-      functionName: "balanceOf",
-      args: [address]
-    })),
-    allowFailure: true
-  });
-}
-function isAddressEqual(a, b) {
-  if (!a) return false;
-  if (!b) return false;
-  return a.toLowerCase() === b.toLowerCase();
-}
 export {
   USDC_ABI,
   USDC_ADDRESS,