Funding and transfers

import uuid
from polymarket_auth import PolymarketClient  # published on /connect#authentication

# protoc output from the CashMovementService proto your integration lead sent you.
from pmx_protos import cash_movement_pb2 as cm
from pmx_protos import cash_movement_pb2_grpc as cm_grpc

# The gRPC target is GRPC_TARGET in polymarket_auth.py — one place, both environments.
pmx = PolymarketClient()

PARTICIPANT_ACCOUNT = "firms/.../accounts/..."  # provisionedAccount, recorded at onboarding
AMOUNT = "25.00"                                # USD decimal string, at most 2 decimal places

TERMINAL = ("CONFIRMED", "REJECTED")

def create_deposit(idempotency_key: str) -> str:
    with pmx.channel() as channel:
        stub = cm_grpc.CashMovementServiceStub(channel)
        response = stub.CreateCashMovement(
            cm.CreateCashMovementRequest(
                idempotency_key=idempotency_key,
                transfer=cm.Transfer(
                    account=PARTICIPANT_ACCOUNT,
                    amount=AMOUNT,
                    reason=cm.DEPOSIT,
                ),
            ),
            # Firm-scoped: pass NO participant ID, so no x-participant-id header.
            metadata=pmx.metadata(),
        )
    status = cm.CashMovementStatus.Name(response.status)
    if status not in TERMINAL:
        # PENDING or AMBIGUOUS. Keep this key, do not mint a new one, and reconcile.
        raise RuntimeError(f"unresolved cash movement {idempotency_key}: {status}")
    if status == "REJECTED":
        raise RuntimeError(f"rejected {idempotency_key}: {response.rejection_reason}")
    return status

print(create_deposit(str(uuid.uuid4())))

import { randomUUID } from "node:crypto";
import { PolymarketClient } from "./polymarketAuth"; // published on /connect#authentication

// protoc output from the CashMovementService proto your integration lead sent you.
import { CashMovementServiceClient } from "./gen/cash_movement";

// The gRPC target is GRPC_TARGET in polymarketAuth.ts — one place, both environments.
const pmx = new PolymarketClient();

const PARTICIPANT_ACCOUNT = "firms/.../accounts/..."; // provisionedAccount, recorded at onboarding
const AMOUNT = "25.00"; // USD decimal string, at most 2 decimal places

const TERMINAL = new Set(["CONFIRMED", "REJECTED"]);

export async function createDeposit(idempotencyKey: string): Promise<string> {
  const client = new CashMovementServiceClient(pmx.channel());
  const response = await client.createCashMovement(
    {
      idempotencyKey,
      transfer: { account: PARTICIPANT_ACCOUNT, amount: AMOUNT, reason: "DEPOSIT" },
    },
    // Firm-scoped: pass NO participant ID, so no x-participant-id header.
    await pmx.metadata(),
  );

  if (!TERMINAL.has(response.status)) {
    // PENDING or AMBIGUOUS. Keep this key, do not mint a new one, and reconcile.
    throw new Error(`unresolved cash movement ${idempotencyKey}: ${response.status}`);
  }
  if (response.status === "REJECTED") {
    throw new Error(`rejected ${idempotencyKey}: ${response.rejectionReason}`);
  }
  return response.status;
}

createDeposit(randomUUID()).then(console.log);

#!/usr/bin/env bash
set -euo pipefail

GRPC_TARGET="grpc-api.preprod.polymarketexchange.com:443"  # prod: grpc-api.prod.polymarketexchange.com:443
PROTO_FILE="./cash_movement.proto"                          # the proto your integration lead sent you
PROTO_PACKAGE="$(grep -m1 '^package' "$PROTO_FILE" | sed 's/package \(.*\);/\1/')"
PARTICIPANT_ACCOUNT="firms/.../accounts/..."                # provisionedAccount, recorded at onboarding
AMOUNT="25.00"                                              # USD decimal string, max 2 decimal places
IDEMPOTENCY_KEY="$(uuidgen)"
TOKEN="$(./token.sh)"                                       # the script on /connect#authentication

# No x-participant-id header: CashMovementService is firm-scoped.
RESPONSE="$(grpcurl -proto "$PROTO_FILE" \
  -H "authorization: Bearer ${TOKEN}" \
  -d "{\"idempotency_key\":\"${IDEMPOTENCY_KEY}\",\"transfer\":{\"account\":\"${PARTICIPANT_ACCOUNT}\",\"amount\":\"${AMOUNT}\",\"reason\":\"DEPOSIT\"}}" \
  "$GRPC_TARGET" "${PROTO_PACKAGE}.CashMovementService/CreateCashMovement")"

echo "$RESPONSE"
STATUS="$(echo "$RESPONSE" | jq -r .status)"
case "$STATUS" in
  CONFIRMED) exit 0 ;;
  REJECTED)  echo "rejected ${IDEMPOTENCY_KEY}; use a NEW key for any further attempt" >&2; exit 1 ;;
  *)         echo "unresolved ${IDEMPOTENCY_KEY}: ${STATUS}; keep this key and reconcile" >&2; exit 2 ;;
esac

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/google/uuid"
	"google.golang.org/grpc/metadata"

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

	cm "yourfirm/pmxprotos/cashmovement"
)

const (
	participantAccount = "firms/.../accounts/..." // provisionedAccount, recorded at onboarding
	amount             = "25.00"                  // USD decimal string, at most 2 decimal places
)

// One auth client for the life of the process: it caches the token and re-mints
// at expires_in minus 30 s.
var pm = pmauth.New()

func createDeposit(ctx context.Context, idempotencyKey string) (string, error) {
	conn, err := pm.Channel()
	if err != nil {
		return "", err
	}
	defer conn.Close()

	// Firm-scoped: pass "" for the participant ID, so no x-participant-id header.
	md, err := pm.Metadata("")
	if err != nil {
		return "", err
	}

	resp, err := cm.NewCashMovementServiceClient(conn).CreateCashMovement(
		metadata.NewOutgoingContext(ctx, md),
		&cm.CreateCashMovementRequest{
			IdempotencyKey: idempotencyKey,
			Transfer: &cm.Transfer{
				Account: participantAccount,
				Amount:  amount,
				Reason:  cm.CashMovementReason_DEPOSIT,
			},
		})
	if err != nil {
		return "", err
	}

	switch status := resp.GetStatus().String(); status {
	case "CONFIRMED":
		return status, nil
	case "REJECTED":
		return status, fmt.Errorf("rejected %s: %s", idempotencyKey, resp.GetRejectionReason())
	default:
		// PENDING or AMBIGUOUS. Keep this key, do not mint a new one, and reconcile.
		return status, fmt.Errorf("unresolved %s: %s", idempotencyKey, status)
	}
}

func main() {
	status, err := createDeposit(context.Background(), uuid.NewString())
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(status)
}