Collateral Return

import { privateKeyToAccount } from "viem/accounts";

const COLLATERAL_RETURN_API =
  "https://combos-rfq-collateral-return.polymarket.com";
const RELAYER_API = "https://relayer-v2.polymarket.com";
const DEPOSIT_WALLET_FACTORY = "0x00000000000Fb5C9ADea0298D729A0CB3823Cc07";

const account = privateKeyToAccount(process.env.SIGNER_PRIVATE_KEY);
const wallet = process.env.POLYMARKET_WALLET_ADDRESS;
const relayerHeaders = {
  RELAYER_API_KEY: process.env.RELAYER_API_KEY,
  RELAYER_API_KEY_ADDRESS: account.address,
};

// Request a plan.
const planResponse = await fetch(
  `${COLLATERAL_RETURN_API}/v1/collateral-return/plan`,
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ wallet }),
  },
);
if (!planResponse.ok) throw new Error(await planResponse.text());
const plan = await planResponse.json();

// Inspect the plan and apply any application-specific limits before signing.
console.log({
  netPusdOut: plan.net_pusd_out,
  positionSummary: plan.position_summary,
  estimatedCost: plan.estimated_cost,
  truncated: plan.truncated,
});

// Fetch a fresh Deposit Wallet nonce.
const executeParamsResponse = await fetch(
  `${RELAYER_API}/v1/account/transactions/params?address=${account.address}&type=WALLET`,
  { headers: relayerHeaders },
);
if (!executeParamsResponse.ok) {
  throw new Error(await executeParamsResponse.text());
}
const executeParams = await executeParamsResponse.json();

// Create and sign the Deposit Wallet batch.
const deadline = BigInt(Math.floor(Date.now() / 1_000) + 600);
const calls = [
  {
    target: plan.router_call.to,
    value: 0n,
    data: plan.router_call.data,
  },
];
const signature = await account.signTypedData({
  domain: {
    name: "DepositWallet",
    version: "1",
    chainId: 137,
    verifyingContract: wallet,
  },
  types: {
    Call: [
      { name: "target", type: "address" },
      { name: "value", type: "uint256" },
      { name: "data", type: "bytes" },
    ],
    Batch: [
      { name: "wallet", type: "address" },
      { name: "nonce", type: "uint256" },
      { name: "deadline", type: "uint256" },
      { name: "calls", type: "Call[]" },
    ],
  },
  primaryType: "Batch",
  message: {
    wallet,
    nonce: BigInt(executeParams.nonce),
    deadline,
    calls,
  },
});
const envelope = {
  type: "WALLET",
  from: account.address,
  to: DEPOSIT_WALLET_FACTORY,
  nonce: executeParams.nonce,
  signature,
  metadata: "Return Combo collateral",
  depositWalletParams: {
    depositWallet: wallet,
    deadline: deadline.toString(),
    calls: calls.map((call) => ({
      ...call,
      value: call.value.toString(),
    })),
  },
};

// Execute the plan.
const submitResponse = await fetch(
  `${COLLATERAL_RETURN_API}/v1/collateral-return/submit`,
  {
    method: "POST",
    headers: { "Content-Type": "application/json", ...relayerHeaders },
    body: JSON.stringify({ plan_hash: plan.plan_hash, envelope }),
  },
);
if (!submitResponse.ok) throw new Error(await submitResponse.text());
const submitted = await submitResponse.json();

// Confirm the transaction.
let outcome;
for (;;) {
  const transactionResponse = await fetch(
    `${RELAYER_API}/v1/account/transactions/${submitted.transactionID}`,
    { headers: relayerHeaders },
  );
  if (!transactionResponse.ok) {
    throw new Error(await transactionResponse.text());
  }
  const transaction = await transactionResponse.json();

  if (transaction.state === "STATE_CONFIRMED") {
    outcome = transaction;
    break;
  }
  if (
    transaction.state === "STATE_FAILED" ||
    transaction.state === "STATE_INVALID"
  ) {
    throw new Error(transaction.error_msg ?? transaction.state);
  }

  await new Promise((resolve) => setTimeout(resolve, 1_000));
}

console.log(outcome);

import { hashTypedData, zeroAddress } from "viem";
import { privateKeyToAccount } from "viem/accounts";

const COLLATERAL_RETURN_API =
  "https://combos-rfq-collateral-return.polymarket.com";
const RELAYER_API = "https://relayer-v2.polymarket.com";

const account = privateKeyToAccount(process.env.SIGNER_PRIVATE_KEY);
const wallet = process.env.POLYMARKET_WALLET_ADDRESS;
const relayerHeaders = {
  RELAYER_API_KEY: process.env.RELAYER_API_KEY,
  RELAYER_API_KEY_ADDRESS: account.address,
};

// Request a plan.
const planResponse = await fetch(
  `${COLLATERAL_RETURN_API}/v1/collateral-return/plan`,
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ wallet }),
  },
);
if (!planResponse.ok) throw new Error(await planResponse.text());
const plan = await planResponse.json();

// Inspect the plan and apply any application-specific limits before signing.
console.log({
  netPusdOut: plan.net_pusd_out,
  positionSummary: plan.position_summary,
  estimatedCost: plan.estimated_cost,
  truncated: plan.truncated,
});

// Fetch a fresh Safe nonce.
const executeParamsResponse = await fetch(
  `${RELAYER_API}/v1/account/transactions/params?address=${account.address}&type=SAFE`,
  { headers: relayerHeaders },
);
if (!executeParamsResponse.ok) {
  throw new Error(await executeParamsResponse.text());
}
const executeParams = await executeParamsResponse.json();

// Create and sign the Safe transaction.
const message = {
  to: plan.router_call.to,
  value: 0n,
  data: plan.router_call.data,
  operation: 0,
  safeTxGas: 0n,
  baseGas: 0n,
  gasPrice: 0n,
  gasToken: zeroAddress,
  refundReceiver: zeroAddress,
  nonce: BigInt(executeParams.nonce),
};
const digest = hashTypedData({
  domain: { chainId: 137, verifyingContract: wallet },
  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" },
    ],
  },
  primaryType: "SafeTx",
  message,
});

const signed = (await account.signMessage({ message: { raw: digest } })).slice(
  2,
);
const v = Number.parseInt(signed.slice(128, 130), 16);
const packedV = v === 0 || v === 1 ? v + 31 : v === 27 || v === 28 ? v + 4 : v;
const signature = `0x${signed.slice(0, 128)}${packedV.toString(16).padStart(2, "0")}`;
const envelope = {
  type: "SAFE",
  from: account.address,
  to: message.to,
  proxyWallet: wallet,
  value: "0",
  data: message.data,
  nonce: executeParams.nonce,
  signature,
  metadata: "Return Combo collateral",
  signatureParams: {
    operation: "0",
    safeTxnGas: "0",
    baseGas: "0",
    gasPrice: "0",
    gasToken: zeroAddress,
    refundReceiver: zeroAddress,
  },
};

// Execute the plan.
const submitResponse = await fetch(
  `${COLLATERAL_RETURN_API}/v1/collateral-return/submit`,
  {
    method: "POST",
    headers: { "Content-Type": "application/json", ...relayerHeaders },
    body: JSON.stringify({ plan_hash: plan.plan_hash, envelope }),
  },
);
if (!submitResponse.ok) throw new Error(await submitResponse.text());
const submitted = await submitResponse.json();

// Confirm the transaction.
let outcome;
for (;;) {
  const transactionResponse = await fetch(
    `${RELAYER_API}/v1/account/transactions/${submitted.transactionID}`,
    { headers: relayerHeaders },
  );
  if (!transactionResponse.ok) {
    throw new Error(await transactionResponse.text());
  }
  const transaction = await transactionResponse.json();

  if (transaction.state === "STATE_CONFIRMED") {
    outcome = transaction;
    break;
  }
  if (
    transaction.state === "STATE_FAILED" ||
    transaction.state === "STATE_INVALID"
  ) {
    throw new Error(transaction.error_msg ?? transaction.state);
  }

  await new Promise((resolve) => setTimeout(resolve, 1_000));
}

console.log(outcome);

import {
  concat,
  createPublicClient,
  encodeFunctionData,
  http,
  keccak256,
  toHex,
} from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { polygon } from "viem/chains";

const COLLATERAL_RETURN_API =
  "https://combos-rfq-collateral-return.polymarket.com";
const RELAYER_API = "https://relayer-v2.polymarket.com";
const PROXY_WALLET_FACTORY = "0xaB45c5A4B0c941a2F231C04C3f49182e1A254052";
const RELAY_HUB = "0xD216153c06E857cD7f72665E0aF1d7D82172F494";

const account = privateKeyToAccount(process.env.SIGNER_PRIVATE_KEY);
const wallet = process.env.POLYMARKET_WALLET_ADDRESS;
const publicClient = createPublicClient({
  chain: polygon,
  transport: http(process.env.RPC_URL),
});
const relayerHeaders = {
  RELAYER_API_KEY: process.env.RELAYER_API_KEY,
  RELAYER_API_KEY_ADDRESS: account.address,
};

// Request a plan.
const planResponse = await fetch(
  `${COLLATERAL_RETURN_API}/v1/collateral-return/plan`,
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ wallet }),
  },
);
if (!planResponse.ok) throw new Error(await planResponse.text());
const plan = await planResponse.json();

// Inspect the plan and apply any application-specific limits before signing.
console.log({
  netPusdOut: plan.net_pusd_out,
  positionSummary: plan.position_summary,
  estimatedCost: plan.estimated_cost,
  truncated: plan.truncated,
});

// Fetch a fresh Proxy Wallet nonce and relay address.
const executeParamsResponse = await fetch(
  `${RELAYER_API}/v1/account/transactions/params?address=${account.address}&type=PROXY`,
  { headers: relayerHeaders },
);
if (!executeParamsResponse.ok) {
  throw new Error(await executeParamsResponse.text());
}
const executeParams = await executeParamsResponse.json();

// Encode and sign the Proxy Wallet relay request.
const data = encodeFunctionData({
  abi: [
    {
      type: "function",
      name: "proxy",
      inputs: [
        {
          type: "tuple[]",
          components: [
            { name: "typeCode", type: "uint8" },
            { name: "to", type: "address" },
            { name: "value", type: "uint256" },
            { name: "data", type: "bytes" },
          ],
        },
      ],
      outputs: [{ type: "bytes[]" }],
    },
  ],
  functionName: "proxy",
  args: [
    [
      {
        typeCode: 1,
        to: plan.router_call.to,
        value: 0n,
        data: plan.router_call.data,
      },
    ],
  ],
});
const relayerFee = 0n;
const gasPrice = 0n;
const gasLimit = await publicClient.estimateGas({
  account: account.address,
  to: PROXY_WALLET_FACTORY,
  data,
});
const digest = keccak256(
  concat([
    toHex("rlx:"),
    account.address,
    PROXY_WALLET_FACTORY,
    data,
    toHex(relayerFee, { size: 32 }),
    toHex(gasPrice, { size: 32 }),
    toHex(gasLimit, { size: 32 }),
    toHex(BigInt(executeParams.nonce), { size: 32 }),
    RELAY_HUB,
    executeParams.address,
  ]),
);
const signature = await account.signMessage({ message: { raw: digest } });
const envelope = {
  type: "PROXY",
  from: account.address,
  to: PROXY_WALLET_FACTORY,
  proxyWallet: wallet,
  value: "0",
  data,
  nonce: executeParams.nonce,
  signature,
  metadata: "Return Combo collateral",
  signatureParams: {
    gasPrice: gasPrice.toString(),
    relayerFee: relayerFee.toString(),
    gasLimit: gasLimit.toString(),
    relayHub: RELAY_HUB,
    relay: executeParams.address,
  },
};

// Execute the plan.
const submitResponse = await fetch(
  `${COLLATERAL_RETURN_API}/v1/collateral-return/submit`,
  {
    method: "POST",
    headers: { "Content-Type": "application/json", ...relayerHeaders },
    body: JSON.stringify({ plan_hash: plan.plan_hash, envelope }),
  },
);
if (!submitResponse.ok) throw new Error(await submitResponse.text());
const submitted = await submitResponse.json();

// Confirm the transaction.
let outcome;
for (;;) {
  const transactionResponse = await fetch(
    `${RELAYER_API}/v1/account/transactions/${submitted.transactionID}`,
    { headers: relayerHeaders },
  );
  if (!transactionResponse.ok) {
    throw new Error(await transactionResponse.text());
  }
  const transaction = await transactionResponse.json();

  if (transaction.state === "STATE_CONFIRMED") {
    outcome = transaction;
    break;
  }
  if (
    transaction.state === "STATE_FAILED" ||
    transaction.state === "STATE_INVALID"
  ) {
    throw new Error(transaction.error_msg ?? transaction.state);
  }

  await new Promise((resolve) => setTimeout(resolve, 1_000));
}

console.log(outcome);