# Prepare a withdrawal

Builds the exact withdrawal contract for the given asset and amount, and opens the approval that stands for it. Nothing is signed and no key is touched: this only returns the terms to review and the `fingerprint` that `wallets.confirmWithdrawal` must echo back unchanged.

`POST /v1/users/{userId}/wallet/withdrawals`

## Authentication

Both headers are required.

- Header: `X-Api-Key: YOUR_API_KEY`
- Header: `Authorization: Bearer YOUR_USER_TOKEN`

## Path parameters



```json
[
  {
    "schema": {
      "type": "string",
      "format": "uuid",
      "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
    },
    "in": "path",
    "name": "userId",
    "required": true,
    "description": "The user in the path; must equal the token's own account."
  }
]
```


## Request body



```json
{
  "required": true,
  "content": {
    "application/json": {
      "schema": {
        "type": "object",
        "properties": {
          "tokenId": {
            "type": "string",
            "minLength": 1,
            "maxLength": 512,
            "description": "Which asset to withdraw, as the provider identifies it: one of `wallets.withdrawalSources`' assets."
          },
          "amountRaw": {
            "type": "string",
            "maxLength": 160,
            "pattern": "^(0|[1-9]\\d*)$",
            "description": "How much to withdraw, as a decimal string in the asset's smallest unit, never a float. Must be positive and no more than the current balance."
          }
        },
        "required": [
          "tokenId",
          "amountRaw"
        ],
        "additionalProperties": false
      }
    }
  }
}
```


## Request example

Illustrative request. Replace the host, credentials and resource IDs with your own. If a request file is shown, create it from the schema above. Review the requested action before sending it.

```sh
curl --request POST 'https://api.example.test/v1/users/YOUR_USER_ID/wallet/withdrawals' \
  --header 'X-Api-Key: YOUR_API_KEY' \
  --header 'Authorization: Bearer YOUR_USER_TOKEN' \
  --header 'Content-Type: application/json' \
  --data-binary '@request.json'
```

## Responses

### 200

The withdrawal's exact terms and the approval opened for them.



```json
{
  "description": "The withdrawal's exact terms and the approval opened for them.",
  "content": {
    "application/json": {
      "schema": {
        "type": "object",
        "properties": {
          "operationId": {
            "type": "string",
            "format": "uuid",
            "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$",
            "description": "This withdrawal's id; pass it to `wallets.confirmWithdrawal`."
          },
          "approvalId": {
            "type": "string",
            "format": "uuid",
            "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$",
            "description": "The approval opened for this withdrawal; echo it back to confirm."
          },
          "fingerprint": {
            "type": "string",
            "description": "What `wallets.confirmWithdrawal` must echo back exactly, so confirming something other than what was reviewed here cannot happen."
          },
          "expiresAt": {
            "type": "string",
            "format": "date-time",
            "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z))$",
            "description": "When this approval expires; confirm before then, or prepare again."
          },
          "mainAccountId": {
            "type": "string",
            "description": "The owner's main wallet account this withdrawal would pay out to."
          },
          "contract": {
            "oneOf": [
              {
                "type": "object",
                "properties": {
                  "type": {
                    "type": "string",
                    "description": "Which contract template this is.",
                    "enum": [
                      "near_intents_transfer"
                    ]
                  },
                  "actions": {
                    "minItems": 1,
                    "maxItems": 16,
                    "type": "array",
                    "items": {
                      "oneOf": [
                        {
                          "type": "object",
                          "properties": {
                            "kind": {
                              "type": "string",
                              "description": "Exchange one asset for another; custody never leaves the agent wallet.",
                              "enum": [
                                "swap"
                              ]
                            },
                            "input": {
                              "anyOf": [
                                {
                                  "type": "object",
                                  "properties": {
                                    "pinned": {
                                      "type": "object",
                                      "properties": {
                                        "tokenId": {
                                          "type": "string",
                                          "pattern": "^nep141:[a-z0-9]+(?:[._-][a-z0-9]+)*$",
                                          "description": "The token's NEP-141 identifier."
                                        },
                                        "decimals": {
                                          "type": "integer",
                                          "minimum": 0,
                                          "maximum": 38,
                                          "description": "How many decimal places the token's smallest unit represents."
                                        }
                                      },
                                      "required": [
                                        "tokenId",
                                        "decimals"
                                      ],
                                      "description": "The exact token this asset is pinned to."
                                    }
                                  },
                                  "required": [
                                    "pinned"
                                  ]
                                },
                                {
                                  "type": "object",
                                  "properties": {
                                    "any": {
                                      "type": "boolean",
                                      "description": "Any token the agent wallet holds; the executor picks one at execution.",
                                      "enum": [
                                        true
                                      ]
                                    }
                                  },
                                  "required": [
                                    "any"
                                  ]
                                }
                              ],
                              "description": "The asset this action spends: pinned to one token, or any token the agent wallet holds."
                            },
                            "quantity": {
                              "oneOf": [
                                {
                                  "type": "object",
                                  "properties": {
                                    "kind": {
                                      "type": "string",
                                      "description": "Spend an exact amount of the input token.",
                                      "enum": [
                                        "exact_input_tokens"
                                      ]
                                    },
                                    "amountRaw": {
                                      "type": "string",
                                      "pattern": "^(0|[1-9]\\d{0,38})$",
                                      "description": "The exact input amount, in the input token's smallest unit."
                                    }
                                  },
                                  "required": [
                                    "kind",
                                    "amountRaw"
                                  ],
                                  "description": "Spend an exact quantity of the input token, not its USD value. Exactly 5 USDC with verified input decimals 6 means amountRaw \"5000000\". Scale the requested decimal digits using the verified input decimals; reject excess fractional digits. No floating-point arithmetic or bash."
                                },
                                {
                                  "type": "object",
                                  "properties": {
                                    "kind": {
                                      "type": "string",
                                      "description": "Spend a USD-denominated value of the input token.",
                                      "enum": [
                                        "exact_input_value_usd"
                                      ]
                                    },
                                    "value": {
                                      "type": "string",
                                      "pattern": "^(0|[1-9]\\d{0,38})(?:\\.\\d{1,18})?$",
                                      "description": "The USD value to spend, as a decimal string."
                                    }
                                  },
                                  "required": [
                                    "kind",
                                    "value"
                                  ],
                                  "description": "Spend a USD-denominated value of the input token: \"$5 worth of USDC\" means value \"5\". The host calculates token units from live prices. This does not mean exactly 5 USDC; never substitute it for a token-denominated quantity."
                                },
                                {
                                  "type": "object",
                                  "properties": {
                                    "kind": {
                                      "type": "string",
                                      "description": "Receive an exact amount of the output token.",
                                      "enum": [
                                        "exact_output_tokens"
                                      ]
                                    },
                                    "amountRaw": {
                                      "type": "string",
                                      "pattern": "^(0|[1-9]\\d{0,38})$",
                                      "description": "The exact output amount, in the output token's smallest unit."
                                    }
                                  },
                                  "required": [
                                    "kind",
                                    "amountRaw"
                                  ],
                                  "description": "Receive an exact quantity of the output token. Scale the requested decimal digits using the verified output decimals to obtain amountRaw; reject excess fractional digits. The host calculates the required input. No floating-point arithmetic or bash."
                                },
                                {
                                  "type": "object",
                                  "properties": {
                                    "kind": {
                                      "type": "string",
                                      "description": "Spend everything the agent wallet holds of the input asset.",
                                      "enum": [
                                        "all_of_input"
                                      ]
                                    }
                                  },
                                  "required": [
                                    "kind"
                                  ]
                                },
                                {
                                  "type": "object",
                                  "properties": {
                                    "kind": {
                                      "type": "string",
                                      "description": "Spend a fraction of the input asset.",
                                      "enum": [
                                        "fraction_of_input"
                                      ]
                                    },
                                    "bps": {
                                      "type": "string",
                                      "pattern": "^(0|[1-9]\\d{0,4})$",
                                      "description": "The fraction to spend, in basis points of the input asset."
                                    }
                                  },
                                  "required": [
                                    "kind",
                                    "bps"
                                  ]
                                }
                              ],
                              "description": "How much moves: an exact token amount, an exact USD value, an exact output amount, all of the input, or a fraction of it."
                            },
                            "output": {
                              "anyOf": [
                                {
                                  "type": "object",
                                  "properties": {
                                    "pinned": {
                                      "type": "object",
                                      "properties": {
                                        "tokenId": {
                                          "type": "string",
                                          "pattern": "^nep141:[a-z0-9]+(?:[._-][a-z0-9]+)*$",
                                          "description": "The token's NEP-141 identifier."
                                        },
                                        "decimals": {
                                          "type": "integer",
                                          "minimum": 0,
                                          "maximum": 38,
                                          "description": "How many decimal places the token's smallest unit represents."
                                        }
                                      },
                                      "required": [
                                        "tokenId",
                                        "decimals"
                                      ],
                                      "description": "The exact token this asset is pinned to."
                                    }
                                  },
                                  "required": [
                                    "pinned"
                                  ]
                                },
                                {
                                  "type": "object",
                                  "properties": {
                                    "any": {
                                      "type": "boolean",
                                      "description": "Any token the agent wallet holds; the executor picks one at execution.",
                                      "enum": [
                                        true
                                      ]
                                    }
                                  },
                                  "required": [
                                    "any"
                                  ]
                                }
                              ],
                              "description": "The asset this action produces: pinned to one token, or left open."
                            }
                          },
                          "required": [
                            "kind",
                            "input",
                            "quantity",
                            "output"
                          ]
                        },
                        {
                          "type": "object",
                          "properties": {
                            "kind": {
                              "type": "string",
                              "description": "Return an asset to the account that owns the agent wallet.",
                              "enum": [
                                "withdraw_to_owner"
                              ]
                            },
                            "input": {
                              "anyOf": [
                                {
                                  "type": "object",
                                  "properties": {
                                    "pinned": {
                                      "type": "object",
                                      "properties": {
                                        "tokenId": {
                                          "type": "string",
                                          "pattern": "^nep141:[a-z0-9]+(?:[._-][a-z0-9]+)*$",
                                          "description": "The token's NEP-141 identifier."
                                        },
                                        "decimals": {
                                          "type": "integer",
                                          "minimum": 0,
                                          "maximum": 38,
                                          "description": "How many decimal places the token's smallest unit represents."
                                        }
                                      },
                                      "required": [
                                        "tokenId",
                                        "decimals"
                                      ],
                                      "description": "The exact token this asset is pinned to."
                                    }
                                  },
                                  "required": [
                                    "pinned"
                                  ]
                                },
                                {
                                  "type": "object",
                                  "properties": {
                                    "any": {
                                      "type": "boolean",
                                      "description": "Any token the agent wallet holds; the executor picks one at execution.",
                                      "enum": [
                                        true
                                      ]
                                    }
                                  },
                                  "required": [
                                    "any"
                                  ]
                                }
                              ],
                              "description": "The asset this action spends: pinned to one token, or any token the agent wallet holds."
                            },
                            "quantity": {
                              "oneOf": [
                                {
                                  "type": "object",
                                  "properties": {
                                    "kind": {
                                      "type": "string",
                                      "description": "Spend an exact amount of the input token.",
                                      "enum": [
                                        "exact_input_tokens"
                                      ]
                                    },
                                    "amountRaw": {
                                      "type": "string",
                                      "pattern": "^(0|[1-9]\\d{0,38})$",
                                      "description": "The exact input amount, in the input token's smallest unit."
                                    }
                                  },
                                  "required": [
                                    "kind",
                                    "amountRaw"
                                  ],
                                  "description": "Spend an exact quantity of the input token, not its USD value. Exactly 5 USDC with verified input decimals 6 means amountRaw \"5000000\". Scale the requested decimal digits using the verified input decimals; reject excess fractional digits. No floating-point arithmetic or bash."
                                },
                                {
                                  "type": "object",
                                  "properties": {
                                    "kind": {
                                      "type": "string",
                                      "description": "Spend a USD-denominated value of the input token.",
                                      "enum": [
                                        "exact_input_value_usd"
                                      ]
                                    },
                                    "value": {
                                      "type": "string",
                                      "pattern": "^(0|[1-9]\\d{0,38})(?:\\.\\d{1,18})?$",
                                      "description": "The USD value to spend, as a decimal string."
                                    }
                                  },
                                  "required": [
                                    "kind",
                                    "value"
                                  ],
                                  "description": "Spend a USD-denominated value of the input token: \"$5 worth of USDC\" means value \"5\". The host calculates token units from live prices. This does not mean exactly 5 USDC; never substitute it for a token-denominated quantity."
                                },
                                {
                                  "type": "object",
                                  "properties": {
                                    "kind": {
                                      "type": "string",
                                      "description": "Receive an exact amount of the output token.",
                                      "enum": [
                                        "exact_output_tokens"
                                      ]
                                    },
                                    "amountRaw": {
                                      "type": "string",
                                      "pattern": "^(0|[1-9]\\d{0,38})$",
                                      "description": "The exact output amount, in the output token's smallest unit."
                                    }
                                  },
                                  "required": [
                                    "kind",
                                    "amountRaw"
                                  ],
                                  "description": "Receive an exact quantity of the output token. Scale the requested decimal digits using the verified output decimals to obtain amountRaw; reject excess fractional digits. The host calculates the required input. No floating-point arithmetic or bash."
                                },
                                {
                                  "type": "object",
                                  "properties": {
                                    "kind": {
                                      "type": "string",
                                      "description": "Spend everything the agent wallet holds of the input asset.",
                                      "enum": [
                                        "all_of_input"
                                      ]
                                    }
                                  },
                                  "required": [
                                    "kind"
                                  ]
                                },
                                {
                                  "type": "object",
                                  "properties": {
                                    "kind": {
                                      "type": "string",
                                      "description": "Spend a fraction of the input asset.",
                                      "enum": [
                                        "fraction_of_input"
                                      ]
                                    },
                                    "bps": {
                                      "type": "string",
                                      "pattern": "^(0|[1-9]\\d{0,4})$",
                                      "description": "The fraction to spend, in basis points of the input asset."
                                    }
                                  },
                                  "required": [
                                    "kind",
                                    "bps"
                                  ]
                                }
                              ],
                              "description": "How much moves: an exact token amount, an exact USD value, an exact output amount, all of the input, or a fraction of it."
                            },
                            "output": {
                              "anyOf": [
                                {
                                  "type": "object",
                                  "properties": {
                                    "pinned": {
                                      "type": "object",
                                      "properties": {
                                        "tokenId": {
                                          "type": "string",
                                          "pattern": "^nep141:[a-z0-9]+(?:[._-][a-z0-9]+)*$",
                                          "description": "The token's NEP-141 identifier."
                                        },
                                        "decimals": {
                                          "type": "integer",
                                          "minimum": 0,
                                          "maximum": 38,
                                          "description": "How many decimal places the token's smallest unit represents."
                                        }
                                      },
                                      "required": [
                                        "tokenId",
                                        "decimals"
                                      ],
                                      "description": "The exact token this asset is pinned to."
                                    }
                                  },
                                  "required": [
                                    "pinned"
                                  ]
                                },
                                {
                                  "type": "object",
                                  "properties": {
                                    "any": {
                                      "type": "boolean",
                                      "description": "Any token the agent wallet holds; the executor picks one at execution.",
                                      "enum": [
                                        true
                                      ]
                                    }
                                  },
                                  "required": [
                                    "any"
                                  ]
                                }
                              ],
                              "description": "The asset this action produces: pinned to one token, or left open."
                            }
                          },
                          "required": [
                            "kind",
                            "input",
                            "quantity",
                            "output"
                          ]
                        },
                        {
                          "type": "object",
                          "properties": {
                            "kind": {
                              "type": "string",
                              "description": "Pay a pinned destination outside the agent wallet.",
                              "enum": [
                                "send"
                              ]
                            },
                            "input": {
                              "anyOf": [
                                {
                                  "type": "object",
                                  "properties": {
                                    "pinned": {
                                      "type": "object",
                                      "properties": {
                                        "tokenId": {
                                          "type": "string",
                                          "pattern": "^nep141:[a-z0-9]+(?:[._-][a-z0-9]+)*$",
                                          "description": "The token's NEP-141 identifier."
                                        },
                                        "decimals": {
                                          "type": "integer",
                                          "minimum": 0,
                                          "maximum": 38,
                                          "description": "How many decimal places the token's smallest unit represents."
                                        }
                                      },
                                      "required": [
                                        "tokenId",
                                        "decimals"
                                      ],
                                      "description": "The exact token this asset is pinned to."
                                    }
                                  },
                                  "required": [
                                    "pinned"
                                  ]
                                },
                                {
                                  "type": "object",
                                  "properties": {
                                    "any": {
                                      "type": "boolean",
                                      "description": "Any token the agent wallet holds; the executor picks one at execution.",
                                      "enum": [
                                        true
                                      ]
                                    }
                                  },
                                  "required": [
                                    "any"
                                  ]
                                }
                              ],
                              "description": "The asset this action spends: pinned to one token, or any token the agent wallet holds."
                            },
                            "quantity": {
                              "oneOf": [
                                {
                                  "type": "object",
                                  "properties": {
                                    "kind": {
                                      "type": "string",
                                      "description": "Spend an exact amount of the input token.",
                                      "enum": [
                                        "exact_input_tokens"
                                      ]
                                    },
                                    "amountRaw": {
                                      "type": "string",
                                      "pattern": "^(0|[1-9]\\d{0,38})$",
                                      "description": "The exact input amount, in the input token's smallest unit."
                                    }
                                  },
                                  "required": [
                                    "kind",
                                    "amountRaw"
                                  ],
                                  "description": "Spend an exact quantity of the input token, not its USD value. Exactly 5 USDC with verified input decimals 6 means amountRaw \"5000000\". Scale the requested decimal digits using the verified input decimals; reject excess fractional digits. No floating-point arithmetic or bash."
                                },
                                {
                                  "type": "object",
                                  "properties": {
                                    "kind": {
                                      "type": "string",
                                      "description": "Spend a USD-denominated value of the input token.",
                                      "enum": [
                                        "exact_input_value_usd"
                                      ]
                                    },
                                    "value": {
                                      "type": "string",
                                      "pattern": "^(0|[1-9]\\d{0,38})(?:\\.\\d{1,18})?$",
                                      "description": "The USD value to spend, as a decimal string."
                                    }
                                  },
                                  "required": [
                                    "kind",
                                    "value"
                                  ],
                                  "description": "Spend a USD-denominated value of the input token: \"$5 worth of USDC\" means value \"5\". The host calculates token units from live prices. This does not mean exactly 5 USDC; never substitute it for a token-denominated quantity."
                                },
                                {
                                  "type": "object",
                                  "properties": {
                                    "kind": {
                                      "type": "string",
                                      "description": "Receive an exact amount of the output token.",
                                      "enum": [
                                        "exact_output_tokens"
                                      ]
                                    },
                                    "amountRaw": {
                                      "type": "string",
                                      "pattern": "^(0|[1-9]\\d{0,38})$",
                                      "description": "The exact output amount, in the output token's smallest unit."
                                    }
                                  },
                                  "required": [
                                    "kind",
                                    "amountRaw"
                                  ],
                                  "description": "Receive an exact quantity of the output token. Scale the requested decimal digits using the verified output decimals to obtain amountRaw; reject excess fractional digits. The host calculates the required input. No floating-point arithmetic or bash."
                                },
                                {
                                  "type": "object",
                                  "properties": {
                                    "kind": {
                                      "type": "string",
                                      "description": "Spend everything the agent wallet holds of the input asset.",
                                      "enum": [
                                        "all_of_input"
                                      ]
                                    }
                                  },
                                  "required": [
                                    "kind"
                                  ]
                                },
                                {
                                  "type": "object",
                                  "properties": {
                                    "kind": {
                                      "type": "string",
                                      "description": "Spend a fraction of the input asset.",
                                      "enum": [
                                        "fraction_of_input"
                                      ]
                                    },
                                    "bps": {
                                      "type": "string",
                                      "pattern": "^(0|[1-9]\\d{0,4})$",
                                      "description": "The fraction to spend, in basis points of the input asset."
                                    }
                                  },
                                  "required": [
                                    "kind",
                                    "bps"
                                  ]
                                }
                              ],
                              "description": "How much moves: an exact token amount, an exact USD value, an exact output amount, all of the input, or a fraction of it."
                            },
                            "output": {
                              "anyOf": [
                                {
                                  "type": "object",
                                  "properties": {
                                    "pinned": {
                                      "type": "object",
                                      "properties": {
                                        "tokenId": {
                                          "type": "string",
                                          "pattern": "^nep141:[a-z0-9]+(?:[._-][a-z0-9]+)*$",
                                          "description": "The token's NEP-141 identifier."
                                        },
                                        "decimals": {
                                          "type": "integer",
                                          "minimum": 0,
                                          "maximum": 38,
                                          "description": "How many decimal places the token's smallest unit represents."
                                        }
                                      },
                                      "required": [
                                        "tokenId",
                                        "decimals"
                                      ],
                                      "description": "The exact token this asset is pinned to."
                                    }
                                  },
                                  "required": [
                                    "pinned"
                                  ]
                                },
                                {
                                  "type": "object",
                                  "properties": {
                                    "any": {
                                      "type": "boolean",
                                      "description": "Any token the agent wallet holds; the executor picks one at execution.",
                                      "enum": [
                                        true
                                      ]
                                    }
                                  },
                                  "required": [
                                    "any"
                                  ]
                                }
                              ],
                              "description": "The asset this action produces: pinned to one token, or left open."
                            },
                            "recipient": {
                              "type": "object",
                              "properties": {
                                "chain": {
                                  "type": "string",
                                  "minLength": 1,
                                  "maxLength": 32,
                                  "description": "Which chain the destination address is on."
                                },
                                "address": {
                                  "type": "string",
                                  "pattern": "^[\\x21-\\x7e]{1,128}$",
                                  "description": "The destination address on that chain."
                                }
                              },
                              "required": [
                                "chain",
                                "address"
                              ],
                              "description": "The pinned destination this action pays."
                            }
                          },
                          "required": [
                            "kind",
                            "input",
                            "quantity",
                            "output",
                            "recipient"
                          ]
                        }
                      ]
                    },
                    "description": "The actions this contract authorizes, executed in order."
                  },
                  "validUntil": {
                    "type": "string",
                    "format": "date-time",
                    "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z))$",
                    "description": "When this contract's authority expires."
                  },
                  "maxExecutions": {
                    "type": "integer",
                    "minimum": 1,
                    "maximum": 10000,
                    "description": "How many times this contract may be executed before it is exhausted."
                  },
                  "bounds": {
                    "type": "object",
                    "properties": {
                      "maxValueLossBps": {
                        "type": "string",
                        "pattern": "^(0|[1-9]\\d{0,4})$",
                        "description": "The most value an execution may give up to price movement and fees together, in basis points."
                      },
                      "maxSignatureLifetimeSeconds": {
                        "type": "integer",
                        "minimum": 1,
                        "maximum": 259500,
                        "description": "Explicit maximum lifetime of each released transfer signature, in seconds. 1Click confidential swaps require up to 259500 seconds (72 hours 5 minutes). This does not extend the short execution window or approval validity."
                      }
                    },
                    "required": [
                      "maxValueLossBps",
                      "maxSignatureLifetimeSeconds"
                    ],
                    "description": "The value-loss and signature-lifetime limits every execution must respect."
                  }
                },
                "required": [
                  "type",
                  "actions",
                  "validUntil",
                  "maxExecutions",
                  "bounds"
                ]
              }
            ],
            "description": "The exact authorization contract this withdrawal runs under, precisely as the approval card shows it."
          }
        },
        "required": [
          "operationId",
          "approvalId",
          "fingerprint",
          "expiresAt",
          "mainAccountId",
          "contract"
        ]
      }
    }
  }
}
```


### 400

The request could not be read as this operation expects.

- `invalid_input` — the body or query failed validation; `issues` names each field
- `invalid_cursor` — the `cursor` is not one this list minted



```json
{
  "description": "The request could not be read as this operation expects.\n\n- `invalid_input` — the body or query failed validation; `issues` names each field\n- `invalid_cursor` — the `cursor` is not one this list minted",
  "content": {
    "application/problem+json": {
      "schema": {
        "$ref": "#/components/schemas/ProblemDetails"
      }
    }
  }
}
```


### 401

A credential is missing, invalid or expired.

- `partner_key_required` — no `X-Api-Key` header was sent
- `partner_key_invalid` — the `X-Api-Key` is unknown or revoked
- `credential_expired` — the user token has expired; obtain a fresh one



```json
{
  "description": "A credential is missing, invalid or expired.\n\n- `partner_key_required` — no `X-Api-Key` header was sent\n- `partner_key_invalid` — the `X-Api-Key` is unknown or revoked\n- `credential_expired` — the user token has expired; obtain a fresh one",
  "content": {
    "application/problem+json": {
      "schema": {
        "$ref": "#/components/schemas/ProblemDetails"
      }
    }
  }
}
```


### 403

The credentials are valid but may not do this.

- `subject_mismatch` — the `{userId}` in the path is not the token's user
- `account_disabled` — an operator disabled the account
- `origin_rejected` — a browser `Origin` other than the configured web origin



```json
{
  "description": "The credentials are valid but may not do this.\n\n- `subject_mismatch` — the `{userId}` in the path is not the token's user\n- `account_disabled` — an operator disabled the account\n- `origin_rejected` — a browser `Origin` other than the configured web origin",
  "content": {
    "application/problem+json": {
      "schema": {
        "$ref": "#/components/schemas/ProblemDetails"
      }
    }
  }
}
```


### 404

The resource is missing, belongs to someone else, or its id is malformed: all three answer alike.



```json
{
  "description": "The resource is missing, belongs to someone else, or its id is malformed: all three answer alike.",
  "content": {
    "application/problem+json": {
      "schema": {
        "$ref": "#/components/schemas/ProblemDetails"
      }
    }
  }
}
```


### 409

The operation lost to the current state.

- `withdrawal_changed` — the withdrawal cannot be prepared or confirmed as asked: the balance no longer covers it, its terms changed or expired, or it is already in progress



```json
{
  "description": "The operation lost to the current state.\n\n- `withdrawal_changed` — the withdrawal cannot be prepared or confirmed as asked: the balance no longer covers it, its terms changed or expired, or it is already in progress",
  "content": {
    "application/problem+json": {
      "schema": {
        "$ref": "#/components/schemas/ProblemDetails"
      }
    }
  }
}
```


### 412

The identity is verified but has no account yet.

- `account_not_provisioned` — the identity is verified but has no account yet; call `users.ensure` first



```json
{
  "description": "The identity is verified but has no account yet.\n\n- `account_not_provisioned` — the identity is verified but has no account yet; call `users.ensure` first",
  "content": {
    "application/problem+json": {
      "schema": {
        "$ref": "#/components/schemas/ProblemDetails"
      }
    }
  }
}
```


### 413

The body exceeds the size this deployment accepts.



```json
{
  "description": "The body exceeds the size this deployment accepts.",
  "content": {
    "application/problem+json": {
      "schema": {
        "$ref": "#/components/schemas/ProblemDetails"
      }
    }
  }
}
```


### 429

A limiter refused the request; honour `Retry-After`.

- `rate_limited` — the per-key or per-user limit is spent; honour `Retry-After`



```json
{
  "description": "A limiter refused the request; honour `Retry-After`.\n\n- `rate_limited` — the per-key or per-user limit is spent; honour `Retry-After`",
  "content": {
    "application/problem+json": {
      "schema": {
        "$ref": "#/components/schemas/ProblemDetails"
      }
    }
  }
}
```


### 500

A fault on our side; quote `requestId` when reporting it.

- `internal` — a fault on our side; quote `requestId` when reporting it



```json
{
  "description": "A fault on our side; quote `requestId` when reporting it.\n\n- `internal` — a fault on our side; quote `requestId` when reporting it",
  "content": {
    "application/problem+json": {
      "schema": {
        "$ref": "#/components/schemas/ProblemDetails"
      }
    }
  }
}
```


### 503

The replica is draining or a dependency did not answer; `retryable` says whether to try again.

- `internal` — a fault on our side; quote `requestId` when reporting it
- `provider_unavailable` — an external provider the call depends on did not answer



```json
{
  "description": "The replica is draining or a dependency did not answer; `retryable` says whether to try again.\n\n- `internal` — a fault on our side; quote `requestId` when reporting it\n- `provider_unavailable` — an external provider the call depends on did not answer",
  "content": {
    "application/problem+json": {
      "schema": {
        "$ref": "#/components/schemas/ProblemDetails"
      }
    }
  }
}
```


## Complete OpenAPI definition

The exact operation and all referenced components, including recursive schemas.



```json
{
  "operation": {
    "operationId": "wallets.prepareWithdrawal",
    "summary": "Prepare a withdrawal",
    "tags": [
      "wallets"
    ],
    "description": "Builds the exact withdrawal contract for the given asset and amount, and opens the approval that stands for it. Nothing is signed and no key is touched: this only returns the terms to review and the `fingerprint` that `wallets.confirmWithdrawal` must echo back unchanged.",
    "requestBody": {
      "required": true,
      "content": {
        "application/json": {
          "schema": {
            "type": "object",
            "properties": {
              "tokenId": {
                "type": "string",
                "minLength": 1,
                "maxLength": 512,
                "description": "Which asset to withdraw, as the provider identifies it: one of `wallets.withdrawalSources`' assets."
              },
              "amountRaw": {
                "type": "string",
                "maxLength": 160,
                "pattern": "^(0|[1-9]\\d*)$",
                "description": "How much to withdraw, as a decimal string in the asset's smallest unit, never a float. Must be positive and no more than the current balance."
              }
            },
            "required": [
              "tokenId",
              "amountRaw"
            ],
            "additionalProperties": false
          }
        }
      }
    },
    "parameters": [
      {
        "schema": {
          "type": "string",
          "format": "uuid",
          "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
        },
        "in": "path",
        "name": "userId",
        "required": true,
        "description": "The user in the path; must equal the token's own account."
      }
    ],
    "security": [
      {
        "apiKey": [],
        "userToken": []
      }
    ],
    "responses": {
      "200": {
        "description": "The withdrawal's exact terms and the approval opened for them.",
        "content": {
          "application/json": {
            "schema": {
              "type": "object",
              "properties": {
                "operationId": {
                  "type": "string",
                  "format": "uuid",
                  "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$",
                  "description": "This withdrawal's id; pass it to `wallets.confirmWithdrawal`."
                },
                "approvalId": {
                  "type": "string",
                  "format": "uuid",
                  "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$",
                  "description": "The approval opened for this withdrawal; echo it back to confirm."
                },
                "fingerprint": {
                  "type": "string",
                  "description": "What `wallets.confirmWithdrawal` must echo back exactly, so confirming something other than what was reviewed here cannot happen."
                },
                "expiresAt": {
                  "type": "string",
                  "format": "date-time",
                  "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z))$",
                  "description": "When this approval expires; confirm before then, or prepare again."
                },
                "mainAccountId": {
                  "type": "string",
                  "description": "The owner's main wallet account this withdrawal would pay out to."
                },
                "contract": {
                  "oneOf": [
                    {
                      "type": "object",
                      "properties": {
                        "type": {
                          "type": "string",
                          "description": "Which contract template this is.",
                          "enum": [
                            "near_intents_transfer"
                          ]
                        },
                        "actions": {
                          "minItems": 1,
                          "maxItems": 16,
                          "type": "array",
                          "items": {
                            "oneOf": [
                              {
                                "type": "object",
                                "properties": {
                                  "kind": {
                                    "type": "string",
                                    "description": "Exchange one asset for another; custody never leaves the agent wallet.",
                                    "enum": [
                                      "swap"
                                    ]
                                  },
                                  "input": {
                                    "anyOf": [
                                      {
                                        "type": "object",
                                        "properties": {
                                          "pinned": {
                                            "type": "object",
                                            "properties": {
                                              "tokenId": {
                                                "type": "string",
                                                "pattern": "^nep141:[a-z0-9]+(?:[._-][a-z0-9]+)*$",
                                                "description": "The token's NEP-141 identifier."
                                              },
                                              "decimals": {
                                                "type": "integer",
                                                "minimum": 0,
                                                "maximum": 38,
                                                "description": "How many decimal places the token's smallest unit represents."
                                              }
                                            },
                                            "required": [
                                              "tokenId",
                                              "decimals"
                                            ],
                                            "description": "The exact token this asset is pinned to."
                                          }
                                        },
                                        "required": [
                                          "pinned"
                                        ]
                                      },
                                      {
                                        "type": "object",
                                        "properties": {
                                          "any": {
                                            "type": "boolean",
                                            "description": "Any token the agent wallet holds; the executor picks one at execution.",
                                            "enum": [
                                              true
                                            ]
                                          }
                                        },
                                        "required": [
                                          "any"
                                        ]
                                      }
                                    ],
                                    "description": "The asset this action spends: pinned to one token, or any token the agent wallet holds."
                                  },
                                  "quantity": {
                                    "oneOf": [
                                      {
                                        "type": "object",
                                        "properties": {
                                          "kind": {
                                            "type": "string",
                                            "description": "Spend an exact amount of the input token.",
                                            "enum": [
                                              "exact_input_tokens"
                                            ]
                                          },
                                          "amountRaw": {
                                            "type": "string",
                                            "pattern": "^(0|[1-9]\\d{0,38})$",
                                            "description": "The exact input amount, in the input token's smallest unit."
                                          }
                                        },
                                        "required": [
                                          "kind",
                                          "amountRaw"
                                        ],
                                        "description": "Spend an exact quantity of the input token, not its USD value. Exactly 5 USDC with verified input decimals 6 means amountRaw \"5000000\". Scale the requested decimal digits using the verified input decimals; reject excess fractional digits. No floating-point arithmetic or bash."
                                      },
                                      {
                                        "type": "object",
                                        "properties": {
                                          "kind": {
                                            "type": "string",
                                            "description": "Spend a USD-denominated value of the input token.",
                                            "enum": [
                                              "exact_input_value_usd"
                                            ]
                                          },
                                          "value": {
                                            "type": "string",
                                            "pattern": "^(0|[1-9]\\d{0,38})(?:\\.\\d{1,18})?$",
                                            "description": "The USD value to spend, as a decimal string."
                                          }
                                        },
                                        "required": [
                                          "kind",
                                          "value"
                                        ],
                                        "description": "Spend a USD-denominated value of the input token: \"$5 worth of USDC\" means value \"5\". The host calculates token units from live prices. This does not mean exactly 5 USDC; never substitute it for a token-denominated quantity."
                                      },
                                      {
                                        "type": "object",
                                        "properties": {
                                          "kind": {
                                            "type": "string",
                                            "description": "Receive an exact amount of the output token.",
                                            "enum": [
                                              "exact_output_tokens"
                                            ]
                                          },
                                          "amountRaw": {
                                            "type": "string",
                                            "pattern": "^(0|[1-9]\\d{0,38})$",
                                            "description": "The exact output amount, in the output token's smallest unit."
                                          }
                                        },
                                        "required": [
                                          "kind",
                                          "amountRaw"
                                        ],
                                        "description": "Receive an exact quantity of the output token. Scale the requested decimal digits using the verified output decimals to obtain amountRaw; reject excess fractional digits. The host calculates the required input. No floating-point arithmetic or bash."
                                      },
                                      {
                                        "type": "object",
                                        "properties": {
                                          "kind": {
                                            "type": "string",
                                            "description": "Spend everything the agent wallet holds of the input asset.",
                                            "enum": [
                                              "all_of_input"
                                            ]
                                          }
                                        },
                                        "required": [
                                          "kind"
                                        ]
                                      },
                                      {
                                        "type": "object",
                                        "properties": {
                                          "kind": {
                                            "type": "string",
                                            "description": "Spend a fraction of the input asset.",
                                            "enum": [
                                              "fraction_of_input"
                                            ]
                                          },
                                          "bps": {
                                            "type": "string",
                                            "pattern": "^(0|[1-9]\\d{0,4})$",
                                            "description": "The fraction to spend, in basis points of the input asset."
                                          }
                                        },
                                        "required": [
                                          "kind",
                                          "bps"
                                        ]
                                      }
                                    ],
                                    "description": "How much moves: an exact token amount, an exact USD value, an exact output amount, all of the input, or a fraction of it."
                                  },
                                  "output": {
                                    "anyOf": [
                                      {
                                        "type": "object",
                                        "properties": {
                                          "pinned": {
                                            "type": "object",
                                            "properties": {
                                              "tokenId": {
                                                "type": "string",
                                                "pattern": "^nep141:[a-z0-9]+(?:[._-][a-z0-9]+)*$",
                                                "description": "The token's NEP-141 identifier."
                                              },
                                              "decimals": {
                                                "type": "integer",
                                                "minimum": 0,
                                                "maximum": 38,
                                                "description": "How many decimal places the token's smallest unit represents."
                                              }
                                            },
                                            "required": [
                                              "tokenId",
                                              "decimals"
                                            ],
                                            "description": "The exact token this asset is pinned to."
                                          }
                                        },
                                        "required": [
                                          "pinned"
                                        ]
                                      },
                                      {
                                        "type": "object",
                                        "properties": {
                                          "any": {
                                            "type": "boolean",
                                            "description": "Any token the agent wallet holds; the executor picks one at execution.",
                                            "enum": [
                                              true
                                            ]
                                          }
                                        },
                                        "required": [
                                          "any"
                                        ]
                                      }
                                    ],
                                    "description": "The asset this action produces: pinned to one token, or left open."
                                  }
                                },
                                "required": [
                                  "kind",
                                  "input",
                                  "quantity",
                                  "output"
                                ]
                              },
                              {
                                "type": "object",
                                "properties": {
                                  "kind": {
                                    "type": "string",
                                    "description": "Return an asset to the account that owns the agent wallet.",
                                    "enum": [
                                      "withdraw_to_owner"
                                    ]
                                  },
                                  "input": {
                                    "anyOf": [
                                      {
                                        "type": "object",
                                        "properties": {
                                          "pinned": {
                                            "type": "object",
                                            "properties": {
                                              "tokenId": {
                                                "type": "string",
                                                "pattern": "^nep141:[a-z0-9]+(?:[._-][a-z0-9]+)*$",
                                                "description": "The token's NEP-141 identifier."
                                              },
                                              "decimals": {
                                                "type": "integer",
                                                "minimum": 0,
                                                "maximum": 38,
                                                "description": "How many decimal places the token's smallest unit represents."
                                              }
                                            },
                                            "required": [
                                              "tokenId",
                                              "decimals"
                                            ],
                                            "description": "The exact token this asset is pinned to."
                                          }
                                        },
                                        "required": [
                                          "pinned"
                                        ]
                                      },
                                      {
                                        "type": "object",
                                        "properties": {
                                          "any": {
                                            "type": "boolean",
                                            "description": "Any token the agent wallet holds; the executor picks one at execution.",
                                            "enum": [
                                              true
                                            ]
                                          }
                                        },
                                        "required": [
                                          "any"
                                        ]
                                      }
                                    ],
                                    "description": "The asset this action spends: pinned to one token, or any token the agent wallet holds."
                                  },
                                  "quantity": {
                                    "oneOf": [
                                      {
                                        "type": "object",
                                        "properties": {
                                          "kind": {
                                            "type": "string",
                                            "description": "Spend an exact amount of the input token.",
                                            "enum": [
                                              "exact_input_tokens"
                                            ]
                                          },
                                          "amountRaw": {
                                            "type": "string",
                                            "pattern": "^(0|[1-9]\\d{0,38})$",
                                            "description": "The exact input amount, in the input token's smallest unit."
                                          }
                                        },
                                        "required": [
                                          "kind",
                                          "amountRaw"
                                        ],
                                        "description": "Spend an exact quantity of the input token, not its USD value. Exactly 5 USDC with verified input decimals 6 means amountRaw \"5000000\". Scale the requested decimal digits using the verified input decimals; reject excess fractional digits. No floating-point arithmetic or bash."
                                      },
                                      {
                                        "type": "object",
                                        "properties": {
                                          "kind": {
                                            "type": "string",
                                            "description": "Spend a USD-denominated value of the input token.",
                                            "enum": [
                                              "exact_input_value_usd"
                                            ]
                                          },
                                          "value": {
                                            "type": "string",
                                            "pattern": "^(0|[1-9]\\d{0,38})(?:\\.\\d{1,18})?$",
                                            "description": "The USD value to spend, as a decimal string."
                                          }
                                        },
                                        "required": [
                                          "kind",
                                          "value"
                                        ],
                                        "description": "Spend a USD-denominated value of the input token: \"$5 worth of USDC\" means value \"5\". The host calculates token units from live prices. This does not mean exactly 5 USDC; never substitute it for a token-denominated quantity."
                                      },
                                      {
                                        "type": "object",
                                        "properties": {
                                          "kind": {
                                            "type": "string",
                                            "description": "Receive an exact amount of the output token.",
                                            "enum": [
                                              "exact_output_tokens"
                                            ]
                                          },
                                          "amountRaw": {
                                            "type": "string",
                                            "pattern": "^(0|[1-9]\\d{0,38})$",
                                            "description": "The exact output amount, in the output token's smallest unit."
                                          }
                                        },
                                        "required": [
                                          "kind",
                                          "amountRaw"
                                        ],
                                        "description": "Receive an exact quantity of the output token. Scale the requested decimal digits using the verified output decimals to obtain amountRaw; reject excess fractional digits. The host calculates the required input. No floating-point arithmetic or bash."
                                      },
                                      {
                                        "type": "object",
                                        "properties": {
                                          "kind": {
                                            "type": "string",
                                            "description": "Spend everything the agent wallet holds of the input asset.",
                                            "enum": [
                                              "all_of_input"
                                            ]
                                          }
                                        },
                                        "required": [
                                          "kind"
                                        ]
                                      },
                                      {
                                        "type": "object",
                                        "properties": {
                                          "kind": {
                                            "type": "string",
                                            "description": "Spend a fraction of the input asset.",
                                            "enum": [
                                              "fraction_of_input"
                                            ]
                                          },
                                          "bps": {
                                            "type": "string",
                                            "pattern": "^(0|[1-9]\\d{0,4})$",
                                            "description": "The fraction to spend, in basis points of the input asset."
                                          }
                                        },
                                        "required": [
                                          "kind",
                                          "bps"
                                        ]
                                      }
                                    ],
                                    "description": "How much moves: an exact token amount, an exact USD value, an exact output amount, all of the input, or a fraction of it."
                                  },
                                  "output": {
                                    "anyOf": [
                                      {
                                        "type": "object",
                                        "properties": {
                                          "pinned": {
                                            "type": "object",
                                            "properties": {
                                              "tokenId": {
                                                "type": "string",
                                                "pattern": "^nep141:[a-z0-9]+(?:[._-][a-z0-9]+)*$",
                                                "description": "The token's NEP-141 identifier."
                                              },
                                              "decimals": {
                                                "type": "integer",
                                                "minimum": 0,
                                                "maximum": 38,
                                                "description": "How many decimal places the token's smallest unit represents."
                                              }
                                            },
                                            "required": [
                                              "tokenId",
                                              "decimals"
                                            ],
                                            "description": "The exact token this asset is pinned to."
                                          }
                                        },
                                        "required": [
                                          "pinned"
                                        ]
                                      },
                                      {
                                        "type": "object",
                                        "properties": {
                                          "any": {
                                            "type": "boolean",
                                            "description": "Any token the agent wallet holds; the executor picks one at execution.",
                                            "enum": [
                                              true
                                            ]
                                          }
                                        },
                                        "required": [
                                          "any"
                                        ]
                                      }
                                    ],
                                    "description": "The asset this action produces: pinned to one token, or left open."
                                  }
                                },
                                "required": [
                                  "kind",
                                  "input",
                                  "quantity",
                                  "output"
                                ]
                              },
                              {
                                "type": "object",
                                "properties": {
                                  "kind": {
                                    "type": "string",
                                    "description": "Pay a pinned destination outside the agent wallet.",
                                    "enum": [
                                      "send"
                                    ]
                                  },
                                  "input": {
                                    "anyOf": [
                                      {
                                        "type": "object",
                                        "properties": {
                                          "pinned": {
                                            "type": "object",
                                            "properties": {
                                              "tokenId": {
                                                "type": "string",
                                                "pattern": "^nep141:[a-z0-9]+(?:[._-][a-z0-9]+)*$",
                                                "description": "The token's NEP-141 identifier."
                                              },
                                              "decimals": {
                                                "type": "integer",
                                                "minimum": 0,
                                                "maximum": 38,
                                                "description": "How many decimal places the token's smallest unit represents."
                                              }
                                            },
                                            "required": [
                                              "tokenId",
                                              "decimals"
                                            ],
                                            "description": "The exact token this asset is pinned to."
                                          }
                                        },
                                        "required": [
                                          "pinned"
                                        ]
                                      },
                                      {
                                        "type": "object",
                                        "properties": {
                                          "any": {
                                            "type": "boolean",
                                            "description": "Any token the agent wallet holds; the executor picks one at execution.",
                                            "enum": [
                                              true
                                            ]
                                          }
                                        },
                                        "required": [
                                          "any"
                                        ]
                                      }
                                    ],
                                    "description": "The asset this action spends: pinned to one token, or any token the agent wallet holds."
                                  },
                                  "quantity": {
                                    "oneOf": [
                                      {
                                        "type": "object",
                                        "properties": {
                                          "kind": {
                                            "type": "string",
                                            "description": "Spend an exact amount of the input token.",
                                            "enum": [
                                              "exact_input_tokens"
                                            ]
                                          },
                                          "amountRaw": {
                                            "type": "string",
                                            "pattern": "^(0|[1-9]\\d{0,38})$",
                                            "description": "The exact input amount, in the input token's smallest unit."
                                          }
                                        },
                                        "required": [
                                          "kind",
                                          "amountRaw"
                                        ],
                                        "description": "Spend an exact quantity of the input token, not its USD value. Exactly 5 USDC with verified input decimals 6 means amountRaw \"5000000\". Scale the requested decimal digits using the verified input decimals; reject excess fractional digits. No floating-point arithmetic or bash."
                                      },
                                      {
                                        "type": "object",
                                        "properties": {
                                          "kind": {
                                            "type": "string",
                                            "description": "Spend a USD-denominated value of the input token.",
                                            "enum": [
                                              "exact_input_value_usd"
                                            ]
                                          },
                                          "value": {
                                            "type": "string",
                                            "pattern": "^(0|[1-9]\\d{0,38})(?:\\.\\d{1,18})?$",
                                            "description": "The USD value to spend, as a decimal string."
                                          }
                                        },
                                        "required": [
                                          "kind",
                                          "value"
                                        ],
                                        "description": "Spend a USD-denominated value of the input token: \"$5 worth of USDC\" means value \"5\". The host calculates token units from live prices. This does not mean exactly 5 USDC; never substitute it for a token-denominated quantity."
                                      },
                                      {
                                        "type": "object",
                                        "properties": {
                                          "kind": {
                                            "type": "string",
                                            "description": "Receive an exact amount of the output token.",
                                            "enum": [
                                              "exact_output_tokens"
                                            ]
                                          },
                                          "amountRaw": {
                                            "type": "string",
                                            "pattern": "^(0|[1-9]\\d{0,38})$",
                                            "description": "The exact output amount, in the output token's smallest unit."
                                          }
                                        },
                                        "required": [
                                          "kind",
                                          "amountRaw"
                                        ],
                                        "description": "Receive an exact quantity of the output token. Scale the requested decimal digits using the verified output decimals to obtain amountRaw; reject excess fractional digits. The host calculates the required input. No floating-point arithmetic or bash."
                                      },
                                      {
                                        "type": "object",
                                        "properties": {
                                          "kind": {
                                            "type": "string",
                                            "description": "Spend everything the agent wallet holds of the input asset.",
                                            "enum": [
                                              "all_of_input"
                                            ]
                                          }
                                        },
                                        "required": [
                                          "kind"
                                        ]
                                      },
                                      {
                                        "type": "object",
                                        "properties": {
                                          "kind": {
                                            "type": "string",
                                            "description": "Spend a fraction of the input asset.",
                                            "enum": [
                                              "fraction_of_input"
                                            ]
                                          },
                                          "bps": {
                                            "type": "string",
                                            "pattern": "^(0|[1-9]\\d{0,4})$",
                                            "description": "The fraction to spend, in basis points of the input asset."
                                          }
                                        },
                                        "required": [
                                          "kind",
                                          "bps"
                                        ]
                                      }
                                    ],
                                    "description": "How much moves: an exact token amount, an exact USD value, an exact output amount, all of the input, or a fraction of it."
                                  },
                                  "output": {
                                    "anyOf": [
                                      {
                                        "type": "object",
                                        "properties": {
                                          "pinned": {
                                            "type": "object",
                                            "properties": {
                                              "tokenId": {
                                                "type": "string",
                                                "pattern": "^nep141:[a-z0-9]+(?:[._-][a-z0-9]+)*$",
                                                "description": "The token's NEP-141 identifier."
                                              },
                                              "decimals": {
                                                "type": "integer",
                                                "minimum": 0,
                                                "maximum": 38,
                                                "description": "How many decimal places the token's smallest unit represents."
                                              }
                                            },
                                            "required": [
                                              "tokenId",
                                              "decimals"
                                            ],
                                            "description": "The exact token this asset is pinned to."
                                          }
                                        },
                                        "required": [
                                          "pinned"
                                        ]
                                      },
                                      {
                                        "type": "object",
                                        "properties": {
                                          "any": {
                                            "type": "boolean",
                                            "description": "Any token the agent wallet holds; the executor picks one at execution.",
                                            "enum": [
                                              true
                                            ]
                                          }
                                        },
                                        "required": [
                                          "any"
                                        ]
                                      }
                                    ],
                                    "description": "The asset this action produces: pinned to one token, or left open."
                                  },
                                  "recipient": {
                                    "type": "object",
                                    "properties": {
                                      "chain": {
                                        "type": "string",
                                        "minLength": 1,
                                        "maxLength": 32,
                                        "description": "Which chain the destination address is on."
                                      },
                                      "address": {
                                        "type": "string",
                                        "pattern": "^[\\x21-\\x7e]{1,128}$",
                                        "description": "The destination address on that chain."
                                      }
                                    },
                                    "required": [
                                      "chain",
                                      "address"
                                    ],
                                    "description": "The pinned destination this action pays."
                                  }
                                },
                                "required": [
                                  "kind",
                                  "input",
                                  "quantity",
                                  "output",
                                  "recipient"
                                ]
                              }
                            ]
                          },
                          "description": "The actions this contract authorizes, executed in order."
                        },
                        "validUntil": {
                          "type": "string",
                          "format": "date-time",
                          "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z))$",
                          "description": "When this contract's authority expires."
                        },
                        "maxExecutions": {
                          "type": "integer",
                          "minimum": 1,
                          "maximum": 10000,
                          "description": "How many times this contract may be executed before it is exhausted."
                        },
                        "bounds": {
                          "type": "object",
                          "properties": {
                            "maxValueLossBps": {
                              "type": "string",
                              "pattern": "^(0|[1-9]\\d{0,4})$",
                              "description": "The most value an execution may give up to price movement and fees together, in basis points."
                            },
                            "maxSignatureLifetimeSeconds": {
                              "type": "integer",
                              "minimum": 1,
                              "maximum": 259500,
                              "description": "Explicit maximum lifetime of each released transfer signature, in seconds. 1Click confidential swaps require up to 259500 seconds (72 hours 5 minutes). This does not extend the short execution window or approval validity."
                            }
                          },
                          "required": [
                            "maxValueLossBps",
                            "maxSignatureLifetimeSeconds"
                          ],
                          "description": "The value-loss and signature-lifetime limits every execution must respect."
                        }
                      },
                      "required": [
                        "type",
                        "actions",
                        "validUntil",
                        "maxExecutions",
                        "bounds"
                      ]
                    }
                  ],
                  "description": "The exact authorization contract this withdrawal runs under, precisely as the approval card shows it."
                }
              },
              "required": [
                "operationId",
                "approvalId",
                "fingerprint",
                "expiresAt",
                "mainAccountId",
                "contract"
              ]
            }
          }
        }
      },
      "400": {
        "$ref": "#/components/responses/InvalidInput"
      },
      "401": {
        "$ref": "#/components/responses/Unauthorized"
      },
      "403": {
        "$ref": "#/components/responses/Forbidden"
      },
      "404": {
        "$ref": "#/components/responses/NotFound"
      },
      "409": {
        "description": "The operation lost to the current state.\n\n- `withdrawal_changed` — the withdrawal cannot be prepared or confirmed as asked: the balance no longer covers it, its terms changed or expired, or it is already in progress",
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/ProblemDetails"
            }
          }
        }
      },
      "412": {
        "$ref": "#/components/responses/AccountNotProvisioned"
      },
      "413": {
        "$ref": "#/components/responses/PayloadTooLarge"
      },
      "429": {
        "$ref": "#/components/responses/TooManyRequests"
      },
      "500": {
        "$ref": "#/components/responses/Internal"
      },
      "503": {
        "description": "The replica is draining or a dependency did not answer; `retryable` says whether to try again.\n\n- `internal` — a fault on our side; quote `requestId` when reporting it\n- `provider_unavailable` — an external provider the call depends on did not answer",
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/ProblemDetails"
            }
          }
        }
      }
    }
  },
  "components": {
    "responses": {
      "InvalidInput": {
        "description": "The request could not be read as this operation expects.\n\n- `invalid_input` — the body or query failed validation; `issues` names each field\n- `invalid_cursor` — the `cursor` is not one this list minted",
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/ProblemDetails"
            }
          }
        }
      },
      "Unauthorized": {
        "description": "A credential is missing, invalid or expired.\n\n- `partner_key_required` — no `X-Api-Key` header was sent\n- `partner_key_invalid` — the `X-Api-Key` is unknown or revoked\n- `credential_expired` — the user token has expired; obtain a fresh one",
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/ProblemDetails"
            }
          }
        }
      },
      "Forbidden": {
        "description": "The credentials are valid but may not do this.\n\n- `subject_mismatch` — the `{userId}` in the path is not the token's user\n- `account_disabled` — an operator disabled the account\n- `origin_rejected` — a browser `Origin` other than the configured web origin",
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/ProblemDetails"
            }
          }
        }
      },
      "NotFound": {
        "description": "The resource is missing, belongs to someone else, or its id is malformed: all three answer alike.",
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/ProblemDetails"
            }
          }
        }
      },
      "AccountNotProvisioned": {
        "description": "The identity is verified but has no account yet.\n\n- `account_not_provisioned` — the identity is verified but has no account yet; call `users.ensure` first",
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/ProblemDetails"
            }
          }
        }
      },
      "PayloadTooLarge": {
        "description": "The body exceeds the size this deployment accepts.",
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/ProblemDetails"
            }
          }
        }
      },
      "TooManyRequests": {
        "description": "A limiter refused the request; honour `Retry-After`.\n\n- `rate_limited` — the per-key or per-user limit is spent; honour `Retry-After`",
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/ProblemDetails"
            }
          }
        }
      },
      "Internal": {
        "description": "A fault on our side; quote `requestId` when reporting it.\n\n- `internal` — a fault on our side; quote `requestId` when reporting it",
        "content": {
          "application/problem+json": {
            "schema": {
              "$ref": "#/components/schemas/ProblemDetails"
            }
          }
        }
      }
    },
    "schemas": {
      "ProblemDetails": {
        "type": "object",
        "properties": {
          "type": {
            "type": "string",
            "description": "The kind of problem as a URN, `urn:fin:error:<kind>`; stable, compare against it"
          },
          "title": {
            "type": "string",
            "description": "The kind's human title, for logs; never parse it"
          },
          "status": {
            "type": "integer",
            "minimum": 400,
            "maximum": 599,
            "description": "The HTTP status, repeated in the body"
          },
          "reason": {
            "description": "The machine-readable why. One of:\n\n- `run_active` (409) — a run already holds this conversation\n- `budget_exhausted` (409) — the user's spend headroom is gone, or an operator froze it\n- `approval_not_pending` (409) — the approval was already decided or has expired, or its id does not exist or belongs to a different conversation\n- `execution_capacity` (409) — no execution capacity is free right now; `retryable` says whether to try again\n- `execution_unavailable` (409) — the execution engine could not take the work\n- `stop_pending` (409) — a stop is already in progress and its cleanup is not yet confirmed\n- `automation_changed` (409) — the `revision` sent is stale; reload the automation\n- `automation_held` (409) — an operator holds the automation; it fires again when released\n- `automation_invalid` (409) — the automation's definition cannot run as written\n- `automation_completed` (409) — the automation has finished for good and cannot fire again\n- `automation_limit` (409) — the user already has as many automations as the deployment allows\n- `profile_unknown_tool` (409) — the run profile names a tool this deployment does not have\n- `deployment_paused` (409) — an operator paused a deployment control; nothing was admitted or fired\n- `run_not_active` (409) — the run named in the path is not the conversation's live run\n- `withdrawal_changed` (409) — the withdrawal cannot be prepared or confirmed as asked: the balance no longer covers it, its terms changed or expired, or it is already in progress\n- `credential_expired` (401) — the user token has expired; obtain a fresh one\n- `account_disabled` (403) — an operator disabled the account\n- `account_not_provisioned` (412) — the identity is verified but has no account yet; call `users.ensure` first\n- `provider_unavailable` (503) — an external provider the call depends on did not answer\n- `engine_unavailable` (503) — the execution engine did not answer\n- `invalid_input` (400) — the body or query failed validation; `issues` names each field\n- `internal` (500) — a fault on our side; quote `requestId` when reporting it\n- `partner_key_required` (401) — no `X-Api-Key` header was sent\n- `partner_key_invalid` (401) — the `X-Api-Key` is unknown or revoked\n- `subject_mismatch` (403) — the `{userId}` in the path is not the token's user\n- `origin_rejected` (403) — a browser `Origin` other than the configured web origin\n- `permission_required` (403) — the operator credential lacks the scope this call needs\n- `rate_limited` (429) — the per-key or per-user limit is spent; honour `Retry-After`\n- `stream_capacity` (429) — no stream socket is free on this replica or for this user; honour `Retry-After`\n- `invalid_cursor` (400) — the `cursor` is not one this list minted",
            "type": "string",
            "enum": [
              "run_active",
              "budget_exhausted",
              "approval_not_pending",
              "execution_capacity",
              "execution_unavailable",
              "stop_pending",
              "automation_changed",
              "automation_held",
              "automation_invalid",
              "automation_completed",
              "automation_limit",
              "profile_unknown_tool",
              "deployment_paused",
              "run_not_active",
              "withdrawal_changed",
              "credential_expired",
              "account_disabled",
              "account_not_provisioned",
              "provider_unavailable",
              "engine_unavailable",
              "invalid_input",
              "internal",
              "partner_key_required",
              "partner_key_invalid",
              "subject_mismatch",
              "origin_rejected",
              "permission_required",
              "rate_limited",
              "stream_capacity",
              "invalid_cursor"
            ]
          },
          "requestId": {
            "type": "string",
            "description": "The id Fin used for this request; quote it when reporting a problem"
          },
          "retryable": {
            "type": "boolean",
            "description": "Whether repeating the same request later can succeed without changing it"
          },
          "detail": {
            "description": "Only on `invalid_input`: which part of the request failed validation",
            "type": "string"
          },
          "issues": {
            "description": "Only on `invalid_input`: one entry per failing field",
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "path": {
                  "type": "string",
                  "description": "The JSON pointer of the failing field; empty for the root object"
                },
                "message": {
                  "type": "string",
                  "description": "Why the field failed"
                }
              },
              "required": [
                "path",
                "message"
              ]
            }
          }
        },
        "required": [
          "type",
          "title",
          "status",
          "requestId",
          "retryable"
        ],
        "description": "RFC 9457 problem details: what every error response carries. Never a provider's message, a query or a stack."
      }
    },
    "securitySchemes": {
      "apiKey": {
        "type": "apiKey",
        "in": "header",
        "name": "X-Api-Key"
      },
      "userToken": {
        "type": "http",
        "scheme": "bearer",
        "bearerFormat": "JWT"
      }
    }
  }
}
```

