Outcomes and recovery

# Resolves one PENDING order. Safe to run repeatedly — the key and the bytes never change.
# PolymarketClient is the canonical auth client published on /connect#authentication.
import sys

import grpc
from polymarket_auth import PolymarketClient

# Generated from polymarket-protos.zip. VERIFY your own package path.
from polymarket.v1 import order_pb2, order_pb2_grpc

# The gRPC target is GRPC_TARGET in polymarket_auth.py — one place, both environments.
pmx = PolymarketClient()
# Written at first submission: req.SerializeToString(deterministic=True). NEVER regenerated.
REQUEST_PATH = "./orders/examplefirm-7f3c1a90.pb"

with open(REQUEST_PATH, "rb") as f:
    req = order_pb2.CreateVendorOrderRequest.FromString(f.read())

print(f"resubmitting idempotency_key={req.idempotency_key} clord_id={req.order.clord_id}")

try:
    with pmx.channel() as ch:
        # x-participant-id is NOT sent on this RPC: pass no participant ID.
        resp = order_pb2_grpc.VendorOrderAPIStub(ch).CreateVendorOrder(req, metadata=pmx.metadata())
except grpc.RpcError as e:
    if e.code() == grpc.StatusCode.ALREADY_EXISTS:
        # The guard working: the body differs from the first submission under this key.
        # Fix the BODY to match the stored bytes. Do NOT mint a new idempotency_key.
        sys.exit(f"ALREADY_EXISTS: body differs from the original submission — {e.details()}")
    raise  # still indeterminate; retry this same script, do not re-place

status = order_pb2.VendorOrderStatus.Name(resp.status)

if status == "PENDING":
    # Still unknown. Re-run this script. Never widen the blast radius with a new key.
    sys.exit(f"still PENDING {req.idempotency_key}: re-run, do not re-place")
if status == "REJECTED":
    sys.exit(f"REJECTED: {resp.failure_reason}")

# Resolved. ACCEPTED still does not mean filled — confirm on drop copy.
print(f"resolved ACCEPTED funding_request_ids={list(resp.funding_request_ids)}")

// Resolves one PENDING order. Safe to run repeatedly — the key and the bytes never change.
// PolymarketClient is the canonical auth client published on /connect#authentication.
import { readFileSync } from "node:fs";
import { PolymarketClient } from "./polymarketAuth";

// Generated from polymarket-protos.zip. VERIFY your own package path.
import {
  VendorOrderAPIClient,
  CreateVendorOrderRequest,
  VendorOrderStatus,
} from "./gen/polymarket/v1/order";

// The gRPC target is GRPC_TARGET in polymarketAuth.ts — one place, both environments.
const pmx = new PolymarketClient();
// Written at first submission with deterministic serialization. NEVER regenerated.
const REQUEST_PATH = "./orders/examplefirm-7f3c1a90.pb";

const req = CreateVendorOrderRequest.fromBinary(readFileSync(REQUEST_PATH));

console.log(`resubmitting idempotency_key=${req.idempotencyKey} clord_id=${req.order?.clordId}`);

let resp;
try {
  // x-participant-id is NOT sent on this RPC: pass no participant ID.
  resp = await new VendorOrderAPIClient(pmx.channel())
    .createVendorOrder(req, await pmx.metadata());
} catch (e: any) {
  if (e?.code === "ALREADY_EXISTS") {
    // The guard working: the body differs from the first submission under this key.
    // Fix the BODY to match the stored bytes. Do NOT mint a new idempotencyKey.
    throw new Error(`ALREADY_EXISTS: body differs from the original submission — ${e.details}`);
  }
  throw e; // still indeterminate; re-run this script, do not re-place
}

const status = VendorOrderStatus[resp.status];

if (status === "PENDING") {
  // Still unknown. Re-run this script. Never widen the blast radius with a new key.
  throw new Error(`still PENDING ${req.idempotencyKey}: re-run, do not re-place`);
}
if (status === "REJECTED") {
  throw new Error(`REJECTED: ${resp.failureReason}`);
}

// Resolved. ACCEPTED still does not mean filled — confirm on drop copy.
console.log(`resolved ACCEPTED funding_request_ids=${resp.fundingRequestIds}`);

#!/usr/bin/env bash
# Resolves one PENDING order. Safe to run repeatedly — the key and the bytes never change.
# curl cannot speak gRPC. Reflection is entitlement-gated, so pass the protos.
set -euo pipefail

TOKEN="$(./token.sh)"   # token.sh is published on /connect#authentication; stdout is the token
# Written at first submission, verbatim. NEVER regenerated: regeneration is what breaks recovery.
REQUEST_PATH="./orders/examplefirm-7f3c1a90.json"

IDEMPOTENCY_KEY=$(jq -r '.idempotency_key' "$REQUEST_PATH")
echo "resubmitting idempotency_key=${IDEMPOTENCY_KEY}"

set +e
RESP=$(grpcurl \
  -import-path ./polymarket-protos \
  -proto polymarket/v1/order.proto \
  -H "authorization: Bearer ${TOKEN}" \
  -d @ < "$REQUEST_PATH" \
  grpc-api.preprod.polymarketexchange.com:443 \
  polymarket.v1.VendorOrderAPI/CreateVendorOrder 2>&1)
RC=$?
set -e

if (( RC != 0 )); then
  case "$RESP" in
    *AlreadyExists*|*ALREADY_EXISTS*)
      # The guard working: the body differs from the first submission under this key.
      # Fix the BODY. Do NOT mint a new idempotency_key.
      echo "ALREADY_EXISTS: body differs from the original submission: ${RESP}" >&2; exit 2 ;;
    *)
      echo "still indeterminate, re-run this script, do not re-place: ${RESP}" >&2; exit 3 ;;
  esac
fi

echo "$RESP"
case "$(echo "$RESP" | jq -r '.status')" in
  PENDING)  echo "still PENDING ${IDEMPOTENCY_KEY}: re-run, do not re-place" >&2; exit 4 ;;
  REJECTED) echo "REJECTED: $(echo "$RESP" | jq -r '.failure_reason')" >&2; exit 5 ;;
  ACCEPTED) echo "resolved ACCEPTED — confirm the fill on drop copy" ;;
  *)        echo "unknown status" >&2; exit 6 ;;
esac

// Resolves one PENDING order. Safe to run repeatedly — the key and the bytes never change.
package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/grpc/metadata"
	"google.golang.org/protobuf/proto"

	// Canonical auth client from /connect#authentication. The gRPC target is
	// pmauth.GRPCTarget — one place, both environments.
	pmauth "example.com/yourfirm/pmauth"

	// Generated from polymarket-protos.zip. VERIFY your own package path.
	orderv1 "github.com/yourfirm/gen/polymarket/v1"
)

// Written at first submission with proto.MarshalOptions{Deterministic: true}. NEVER regenerated.
const requestPath = "./orders/examplefirm-7f3c1a90.pb"

func main() {
	ctx := context.Background()
	pm := pmauth.New()

	raw, err := os.ReadFile(requestPath)
	if err != nil {
		log.Fatalf("read stored request: %v", err)
	}
	req := &orderv1.CreateVendorOrderRequest{}
	if err := proto.Unmarshal(raw, req); err != nil {
		log.Fatalf("unmarshal stored request: %v", err)
	}

	fmt.Printf("resubmitting idempotency_key=%s clord_id=%s\n",
		req.GetIdempotencyKey(), req.GetOrder().GetClordId())

	conn, err := pm.Channel()
	if err != nil {
		log.Fatalf("dial: %v", err)
	}
	defer conn.Close()

	// x-participant-id is NOT sent on this RPC: pass "" for the participant ID.
	md, err := pm.Metadata("")
	if err != nil {
		log.Fatalf("metadata: %v", err)
	}

	resp, err := orderv1.NewVendorOrderAPIClient(conn).CreateVendorOrder(
		metadata.NewOutgoingContext(ctx, md), req)
	if err != nil {
		if status.Code(err) == codes.AlreadyExists {
			// The guard working: the body differs from the first submission under this key.
			// Fix the BODY to match the stored bytes. Do NOT mint a new idempotency key.
			log.Fatalf("ALREADY_EXISTS: body differs from the original submission: %v", err)
		}
		// Still indeterminate. Re-run this program; do not re-place under a new key.
		log.Fatalf("still indeterminate, re-run, do not re-place: %v", err)
	}

	switch resp.GetStatus().String() {
	case "PENDING":
		log.Fatalf("still PENDING %s: re-run, do not re-place", req.GetIdempotencyKey())
	case "REJECTED":
		log.Fatalf("REJECTED: %s", resp.GetFailureReason())
	}

	// Resolved. ACCEPTED still does not mean filled — confirm on drop copy.
	fmt.Printf("resolved ACCEPTED funding_request_ids=%v\n", resp.GetFundingRequestIds())
}