Skip to content
On this page

Limits and costs

Every cap, format, deposit and gas figure the vault, the factory, the console and the SDK use, read from the code. It also shows who pays each cost and what a vault spends from its own NEAR.

LiveTestnetReferenceFor Developers, Builders23 min read.md (this page as Markdown)

Probarion's limits live in its code: the caps and formats the vault and the factory enforce, the deposit and gas of each call, what a vault spends from its own NEAR, and the hosted app's upload and rate limits. A test reads contracts/vault/src, contracts/factory/src/lib.rs and the TypeScript modules that define these values, and fails when a row on this page no longer matches them.

How to read the tables#

  • Constant is the name in the source, such as MAX_AGENTS in contracts/vault/src/lib.rs. A Rust value is shown as the source computes it, and a TypeScript value comes from the module that exports it.
  • Units. 1 NEAR is 10^24 yoctoNEAR, and 1 Tgas is 10^12 gas. Times on chain are in nanoseconds, as block_timestamp counts them, and times in TypeScript are in milliseconds. USDC amounts travel in base units, with 6 decimals.
  • Past the limit and Refused with name the PROBARION:<Code> panic a call fails with, such as InvalidInput. A panic reverts every change the call made, and Errors explains each code.
  • Anchors. Each row has its own anchor, such as limits-vault-max_agents or limits-deposit-create_mandate.

Vault limits#

Every vault that runs the code in contracts/vault/src has these limits. No method changes the approvers, the allowed assets, the daily backstop or the hold time that new set, so a vault keeps them for life.

ConstantValueWhat it limitsPast the limit
DAY_NS86,400,000,000,000 ns (one day)The day of the daily backstop: a spend counts in UTC day block_timestamp / DAY_NS, and the vault's daily_backstop caps each day's totalOverDailyBackstop
MAX_HELD_TTL_NS2,592,000,000,000,000 ns (30 days)The held_ttl_ns of new: how long a held spend waits for an approver. It must also be above 0InvalidInput, and the vault is not created
MAX_APPROVERS10Approvers named in new, at least 1. No method changes them after the vault is createdInvalidInput, and the vault is not created
MAX_ASSETS10The allowed_assets of new: the Intents assets a mandate may pay out inInvalidInput, and the vault is not created
MAX_AGENTS16Agent keys on the vault at one time, added with add_agentInvalidInput. Remove a key with remove_agent first
MAX_PAGE100Items one call of list_mandates, list_spends or list_anchors returns. from_index is a position counted from 0None: a larger limit returns 100 items
ONE_YOCTO1 yoctoNEARThe deposit the vault attaches to its own ft_transfer and ft_withdraw calls: in each payout, in withdraw and in withdraw_intentsNone: the vault sets it
USDC_STORAGE_DEPOSIT1,250,000,000,000,000,000,000 yoctoNEAR (0.00125 NEAR)What create_mandate passes to the USDC token's storage_deposit for a NEAR payee, out of the owner's deposit: the storage_balance_bounds().min of mainnet's USDCInsufficientDeposit when the owner's deposit does not cover it and the mandate's storage

The limits of each payment are the owner's to choose when they create a mandate. Mandates lists every field, and How a payment is checked shows the order the vault checks them in, the daily backstop included.

String and hash formats#

The vault and the factory check these shapes before they store a mandate or an agent key, take a spend, record an anchor, create a vault or add a version. A malformed value fails the call. The policy engine in @probarion/core checks a spend's invoice_hash and ref before the SDK sends it, and the console and the CLI check both labels before they build the call.

InputFormatChecked byRefused with
A mandate's purpose_hash, a spend's invoice_hash and decision_hash, and an anchor's root64 lowercase hex characters: a sha256 digestis_hex64InvalidInput
The address of a Base payee0x and 40 hex digits in any case, 42 characters in all. 0X is refusedis_evm_addressInvalidInput
The address of a Solana payeeBase58 in the Bitcoin alphabet, with no 0, O, I or l, 32 to 44 charactersis_solana_addressInvalidInput
The asset of an Intents payeeStarts with base- for a Base payee or sol- for a Solana payee, and is one of the vault's allowed_assetsasset_matches_chainAssetNotAllowed
A spend's ref, its idempotency key1 to 64 bytes. Once the vault accepts a spend, its ref stays usedis_refInvalidInput, or DuplicateRef for a used one
A mandate's labelAt most 64 bytesvalidate_mandateInvalidInput
An agent key's labelAt most 64 bytesadd_agentInvalidInput
The memo of a payout to a Base or Solana payeeWITHDRAW_TO: and the payee's address, byte for byte. @probarion/core exports the same WITHDRAW_MEMO_PREFIXWITHDRAW_MEMO_PREFIXNone: the vault writes it from the mandate
The memo of a payout to a NEAR payeeprobarion: and the spend idNEAR_MEMO_PREFIXNone: the vault writes it
The name of create_vault2 to 31 characters, ^[a-z0-9][a-z0-9_-]{1,30}$. <name>.<factory> must also be a valid NEAR account id: no - or _ at the end, never two of them in a row, and at most 64 characters in allvalid_nameInvalidInput
The code_hash of add_versionBase58 of 32 bytes. An embedded version also needs that code stored by store_codeadd_versionInvalidInput
The mode of add_versionglobal or embeddedadd_versionInvalidInput
The input of store_code: the raw vault wasm, sent with file-argsNot empty. The factory stores it under its sha256, which store_code returnsstore_codeInvalidInput

Factory limits#

The factory checks the new vault's limits before it creates anything, so a create_vault the vault would refuse fails in the factory and no account is made. A taken name is the one failure the factory cannot see in advance: the new account fails, and on_vault_created refunds the deposit from the factory's own balance.

ConstantValueWhat it limitsPast the limit
MAX_NOTES256Bytes of notes in add_versionInvalidInput
MAX_PAGE100Vaults one call of list_vaults returnsNone: a larger limit returns 100 items
MAX_ASSETS10The allowed_assets of the factory's new, which every vault it creates receivesInvalidInput
MAX_APPROVERS10Approvers in create_vault, at least 1: the vault's own limit, checked before anything is createdInvalidInput, and nothing is created
MAX_HELD_TTL_NS2,592,000,000,000,000 ns (30 days)The held_ttl_ns of create_vault, above 0: the vault's own limit, checked before anything is createdInvalidInput, and nothing is created
min_deposit, set in the factory's new500,000,000,000,000,000,000,000 yoctoNEAR (0.5 NEAR) on TestnetThe least create_vault accepts for a global version. An embedded version also charges the byte cost of the vault's copy of the code. get_config returns it. The Testnet factory's current version is embedded, so a Testnet vault needs min_deposit plus the code's byte cost, about 2.98501 NEAR for the 248,501-byte vault wasm, and the CLI requires --deposit for itInsufficientDeposit, and nothing is created

Read the factory's min_deposit and current version on testnet, with no key:

Shell
near contract call-function as-read-only vaults.probarion.testnet get_config json-args '{}' network-config testnet now
near contract call-function as-read-only vaults.probarion.testnet versions json-args '{}' network-config testnet now

Deposits and gas per call#

  • Deposit the contract asks is what the method checks. "Exactly 1 yoctoNEAR" means any other amount, none included, fails with RequiresOneYocto. Only a full-access key can attach a deposit, which is why most owner calls need one. A method whose deposit reads None is not #[payable], and near-sdk refuses a deposit sent to it.
  • Deposit the console and the CLI attach is what the two tools put in the transaction they prepare. Their mandate deposit has a wide margin, and the vault refunds the rest.
  • Prepaid gas is the gas the console and the CLI attach, and for spend and anchor the gas the SDK attaches. The console and the CLI agree on every call they both build. A call signed by hand sets its own.
CallSigned byDeposit the contract asksDeposit the console and the CLI attachPrepaid gas
freeze on the vaultThe owner, from a full-access key or a function-call key that may call the vaultNoneNone30 Tgas
unfreeze on the vaultThe owner, from a full-access keyExactly 1 yoctoNEAR1 yoctoNEAR30 Tgas
withdraw on the vaultThe owner, from a full-access keyExactly 1 yoctoNEAR1 yoctoNEAR100 Tgas
withdraw_intents on the vaultThe owner, from a full-access keyExactly 1 yoctoNEAR1 yoctoNEAR150 Tgas
create_mandate on the vaultThe owner, from a full-access keyThe storage the new mandate takes at the byte cost, plus USDC_STORAGE_DEPOSIT for a NEAR payee. Less is InsufficientDeposit, and the excess is refunded to the owner0.05 NEAR: the console's MANDATE_STORAGE_DEPOSIT and the CLI's --deposit default100 Tgas
revoke_mandate on the vaultThe owner, from a full-access keyExactly 1 yoctoNEAR1 yoctoNEAR30 Tgas
add_agent on the vaultThe owner, from a full-access keyExactly 1 yoctoNEAR1 yoctoNEAR30 Tgas
remove_agent on the vaultThe owner, from a full-access keyExactly 1 yoctoNEAR1 yoctoNEAR30 Tgas
set_ledger_key on the vaultThe owner, from a full-access keyExactly 1 yoctoNEAR1 yoctoNEAR30 Tgas
approve on the vaultAn approver, from a full-access keyExactly 1 yoctoNEAR1 yoctoNEAR150 Tgas
reject on the vaultAn approver, from a full-access keyExactly 1 yoctoNEAR1 yoctoNEAR30 Tgas
spend on the vaultAn agent key on the vault account. The vault's own NEAR pays the gasNone: a function-call key cannot attach oneNone200 Tgas, the SDK's SPEND_GAS
anchor on the vaultThe ledger key on the vault account. The vault's own NEAR pays the gasNone: a function-call key cannot attach oneNone30 Tgas, the SDK's ANCHOR_GAS
expire_held on the vaultAnyone, once the hold has expiredNoneNot built by a Probarion toolNot set by a Probarion tool
create_vault on the factoryAnyone. The caller becomes the new vault's ownerAt least min_deposit, plus the byte cost of the code for an embedded version. Less is InsufficientDeposit. The deposit stays in the vault as its NEAR, and is refunded if the name is takenThe owner's choice, at most 5 NEAR in the console. The CLI attaches min_deposit unless --deposit is given, and needs --deposit for an embedded version300 Tgas
store_code on the factoryThe factory owner, from a full-access keyExactly 1 yoctoNEARNot built by a Probarion tool: the factory owner signs it with near-cli-rsNot set by a Probarion tool
add_version on the factoryThe factory owner, from a full-access keyExactly 1 yoctoNEARNot built by a Probarion tool: the factory owner signs it with near-cli-rsNot set by a Probarion tool
publish_global on the factoryThe factory owner, from a full-access keyExactly 1 yoctoNEAR. The factory's own balance pays for the global contractNot built by a Probarion tool: the factory owner signs it with near-cli-rsNot set by a Probarion tool
storage_deposit on the USDC tokenThe owner, to register the vault on the token before funding it, or the 1Click deposit address of a top-upSet by the token contract0.00125 NEAR, the console's FT_STORAGE_DEPOSIT30 Tgas
ft_transfer on the USDC tokenThe owner, to fund the vault with USDC, or to pay a 1Click top-up quoteSet by the token contract1 yoctoNEAR30 Tgas

Owner signs

The owner signs create_vault, create_mandate, revoke_mandate, add_agent, remove_agent, set_ledger_key, freeze, unfreeze, withdraw and withdraw_intents from their own wallet, and the USDC token calls that fund the vault or pay a top-up. Their wallet pays each call's gas and deposit.

The owner signs this transaction. Probarion never signs it.

Approver signs

An approver signs approve or reject from their own wallet, with exactly 1 yoctoNEAR, and their wallet pays the gas.

An approver signs this transaction. Probarion never signs it.

Gas the contracts attach#

When a method calls another contract, the gas for that call comes out of the prepaid gas of the transaction that started it. That is why the calls that reach the USDC token or NEAR Intents prepay more than a plain owner call, and a payout also runs a callback. The 1 yoctoNEAR the vault attaches to a payout comes from the vault's own NEAR.

ConstantValueThe call it pays forDeposit attached
GAS_FT_TRANSFER, vault15 Tgasft_transfer on the USDC token: a payout to a NEAR payee, and withdrawONE_YOCTO
GAS_FT_WITHDRAW, vault100 Tgasft_withdraw on NEAR Intents: a payout to a Base or Solana payee, and withdraw_intentsONE_YOCTO
GAS_STORAGE_DEPOSIT, vault10 Tgasstorage_deposit on the USDC token for a NEAR payee, from create_mandate. The vault does not wait for its resultUSDC_STORAGE_DEPOSIT
GAS_CALLBACK, vault15 TgasThe payout's callback, on_transfer or on_withdraw, which settles or releases the spendNone
GAS_VAULT_NEW, factory30 Tgasnew on the vault account that create_vault makesNone
GAS_ON_VAULT_CREATED, factory15 TgasThe callback of create_vault, on_vault_created, which records the vault or refunds the depositNone

What a builder pays#

Probarion takes no fee, and there is no price list or paid plan (Pricing). A vault costs NEAR, paid to the network, from three places:

  • The owner's wallet pays the gas of every call it signs, the 1 yoctoNEAR most of them attach, the create_vault deposit, each mandate's deposit, and 0.00125 NEAR to register an account on the USDC token when funding the vault or paying a top-up. The create_vault deposit is not spent: it becomes the vault's own NEAR, and the vault's storage is staked out of it. A mandate's deposit pays for the mandate's storage and a NEAR payee's USDC registration, and the vault refunds the rest.
  • An approver's wallet pays the gas of approve and reject.
  • The vault's own NEAR pays the gas of every spend and anchor, since the agent key and the ledger key sign as the vault account. It also pays the storage each spend leaves behind, and the storage of each agent key, the ledger key and each anchor: add_agent and set_ledger_key attach only 1 yoctoNEAR. Each key's allowance caps the gas that key can burn. The vault has no method to withdraw NEAR, so NEAR sent to it stays there.

When the vault's free NEAR runs out, a spend fails with the chain's LackBalanceForState or NotEnoughBalance, not a PROBARION: code, and a plain NEAR transfer to the vault tops it up (Transaction failures). The console's figures for that NEAR:

ConstantValueWhat it is
STORAGE_BYTE_COST_YOCTO0.00001 NEAR a byteNEAR's storage staking: the NEAR an account keeps locked for each byte it stores
NEAR_PER_SPEND_YOCTO0.0053 NEARAbout what one paid spend costs the vault: the storage it leaves for good and the gas it burns. A failed spend costs less
EMBEDDED_VAULT_WASM_BYTES248,501 bytesThe size of the vault wasm, which an embedded vault stores a copy of
EMBEDDED_CODE_ESTIMATE_BYTES273,352 bytesWhat the console counts for that copy, the wasm plus 10 percent: 2.73352 NEAR at the byte cost. What the code does not take stays in the vault
FRESH_VAULT_STATE_BYTES2,232 bytesWhat a new vault stores besides its code, for the console's estimate of a new vault's NEAR
LOW_NEAR_YOCTO0.1 NEARBelow this much free NEAR the console shows the vault's runway in amber
NEAR_LOW_ALERT_YOCTO0.05 NEARBelow this much free NEAR the watcher records a near_low event, at most once a UTC day
ALLOWANCE_LOW_ALERT_YOCTO0.2 NEARBelow this much allowance left on an agent or ledger key the watcher records an allowance_low event, at most once a key and UTC day
MAX_CREATE_DEPOSIT_YOCTO5 NEARThe most the console attaches to create_vault: a taken name is refunded from the factory's own balance
MAX_TOPUP_YOCTO5 NEARThe most one plain NEAR transfer to the vault sends from the console. NEAR sent to a vault does not come back out
DEFAULT_TOPUP_YOCTO0.5 NEARThe top-up the console suggests

The free NEAR is the balance minus the storage stake, amount - storage_usage * 10^19 in yoctoNEAR. near-cli-rs shows both for any vault:

Shell
near account view-account-summary v0.probarion.testnet network-config testnet now

Key allowances#

An agent key and the ledger key sign as the vault account, so the gas they burn comes out of the vault's NEAR, up to the key's allowance. A key that has burned its whole allowance can no longer sign, and the owner adds a new key.

KeyMay callAllowance the console gives it, and the CLI's defaultWhat the vault checks
An agent key, added with add_agentspend on the vault1 NEAR: the console's VAULT_DEFAULTS.agentAllowanceYocto and the default of agent add --allowance. For the Canary's vault the console asks for 3 NEAR (CANARY_KEY_ALLOWANCES.agentAllowanceYocto): its raw mode stops when the agent key has under 0.2 NEAR leftAn allowance above 0 yoctoNEAR. An allowance of 0, an unlimited key, fails with InvalidInput
The ledger key, set with set_ledger_keyanchor on the vault0.25 NEAR: the console's VAULT_DEFAULTS.ledgerAllowanceYocto and the default of ledger set-key --allowance. For the Canary's vault the console asks for 2 NEAR (CANARY_KEY_ALLOWANCES.ledgerAllowanceYocto): the Canary does not open while the ledger key has under 0.5 NEAR leftAn allowance above 0 yoctoNEAR. An allowance of 0, an unlimited key, fails with InvalidInput

Cross-chain payouts#

Probarion adds no fee to a payout to a Base or Solana payee: the vault sends ft_withdraw the spend's amount, and its code computes no bridge or token fee. On testnet the stand-in for NEAR Intents, intents-stub.probarion.testnet, takes no fee. A fee that NEAR Intents or its bridge may take on mainnet is not modelled in this code, and this page does not cover it. No Base or Solana payout has run on mainnet, because spike S1 is unproven. The one mainnet vault, v0.probarion.near, has paid only a NEAR payee.

Top-ups through 1Click#

The console's top-up is meant to buy a vault's Base USDC balance inside NEAR Intents through 1Click. It is built for mainnet only and has not been tried with a live quote yet. It asks 1Click for the exact amount out with a 1 percent slippage tolerance, and refuses a quote that would cost more than 5 percent over that amount. The owner then pays the quote from their own wallet, with a storage_deposit and an ft_transfer on the USDC token.

Hosted app limits#

The hosted app adds limits of its own: what the Payables upload takes and reads, the mandate form, the top-up, the testnet faucet, alerts, and the browser extension's inbox and invoice queue, whose routes are Preview. During the beta its mandate form is stricter than the vault: the CLI accepts 1 to 4,294,967,295 for --uses, and the contract any expiry in the future.

ConstantValueWhat it is
MAX_INVOICE_BYTES4,194,304 bytes (4 MiB)The largest invoice file, pasted invoice text or purpose document the console's Payables upload takes, and the largest invoice file the browser extension queues. The upload's whole request may be 64 KiB larger, for the form: MAX_REQUEST_BYTES in lib/payables/upload.ts. Past a cap, 413 too_large
MAX_TEXT_CHARS50,000The UTF-16 units of invoice text Payables reads, shows the model and hashes: the invoice hash is the hash of exactly that text. Longer text is cut, and its amount is refused
MAX_PDF_PAGES20The pages of a PDF invoice Payables reads. The pages past them are not read or hashed, and the amount is refused
MAX_USES_BETA10,000The most payments the console's mandate form allows a mandate during the beta. The contract takes any u32 above 0
MAX_EXPIRY_AHEAD_MS31,622,400,000 ms (366 days)How far ahead the console's mandate form lets an expiry be, during the beta. The contract asks only for a time in the future
MIN_EXPIRY_AHEAD_MS3,600,000 ms (1 hour)The earliest expiry the form accepts, counted from now: time for the owner to sign before it passes
MIN_TOPUP_UNITS1,000,000 units (1 USDC)The least one 1Click top-up asks for. The top-up is built for mainnet only and has not been tried with a live quote yet
MAX_TOPUP_UNITS1,000,000,000 units (1,000 USDC)The most one 1Click top-up asks for, during the beta
MIN_LEFT_MS60,000 ms (1 minute)A 1Click quote with less time than this left before its deadline is not offered for signing
FAUCET_USDC25 test USDCWhat one use of the testnet faucet mints into the vault. The faucet limiters in the rate limits cap how often
Active alerts, checked in alert_subscription_create20The most active alerts one vault may have, email and Telegram together. Past it the console asks the owner to remove one first
MAX_VAULTS10The vaults one GET /api/ext/inbox answer covers, of those the account owns or approves on that network
MAX_ROWS10The invoices waiting for the owner, and the held payments, that the extension's inbox lists for each vault. Its counts include every one
MAX_REPORT_BYTES2,097,152 bytes (2 MiB)The most of NEAR AI's attestation report the proof page's live TEE check (GET /api/tee/check) reads. A larger report is not read: the next preferred model is asked when NEARAI_MODEL is unset, else each check is unavailable
MAX_ATTESTATIONS4The model attestations of one report that the live TEE check checks, the first ones. Any past them are not checked: the answer's attestations_total counts them, and a pass says it covered the first of them only

Rate limits#

Each limiter allows the hits shown in its window, for each IP address, account, vault or email address it counts. A route past its limit answers 429 rate_limited with a Retry-After header, and a page or a console action shows a message instead. No window is longer than a day (RATE_LIMIT_KEEP_S), because a daily job deletes older counters. HTTP API lists each route with its callers and errors.

LimiterLimitCounted perApplies to
authChallenge20 in a minuteIP addressGET /api/auth/challenge, the start of sign-in
authVerify10 in a minuteIP addressPOST /api/auth/verify, the signed sign-in
snapshot30 in a minuteIP address, for each fileGET /proof/<vault>/snapshot.json, GET /proof/<vault>/ledger.jsonl and GET /proof/<vault>/payments.csv
proofPage60 in a minuteIP addressThe public proof page, /proof/<vault>
topupQuote10 in a minuteSigned-in account and networkPOST /api/topup/quote. The top-up is built for mainnet only and has not been tried with a live quote yet
topupStatus30 in a minuteSigned-in account and networkGET /api/topup/status
topupSubmit10 in a minuteSigned-in account and networkPOST /api/topup/submit
invoiceUpload30 in an hourVaultPOST /api/console/<vault>/invoices, the Payables upload
canaryModelVisitor5 in 10 minutesIP addressPOST /api/canary/attempt, before the model is asked
canaryModelGlobal300 in an hourAll visitors togetherPOST /api/canary/attempt
telegramWebhook120 in a minuteAll calls togetherPOST /api/telegram/webhook
alertTest5 in 10 minutesVaultNew alerts, emails and Telegram links on the console's alerts page, together
alertConfirmAddress3 in a dayEmail address, from every vault togetherThe confirmation emails the alerts page sends
confirmPerAccount30 in a minuteSigned-in account and networkThe console's chain reads for a signed transaction: its confirmation, and the block height read when the send starts, each with its own counters
confirmGlobal300 in a minuteAll accounts togetherThe same reads, each with its own counter
registerPerAccount10 in 10 minutesSigned-in account and networkRegistering an existing vault in the console
extPairPerIp10 in 10 minutesIP address and networkPOST /api/ext/pair, the browser extension's pairing-code exchange
extPairGlobal300 in 10 minutesAll addresses together, per networkPOST /api/ext/pair
extInbox60 in a minuteExtension token's account and networkGET /api/ext/inbox
extInvoice20 in 10 minutesExtension token's account and networkPOST /api/ext/invoices: invoices the browser extension queues for the owner's Confirm
extMint10 in 10 minutesSigned-in account and networkTokens and pairing codes the extension page makes, together
faucetVault1 in a dayVault, each UTC dayPOST /api/topup/faucet, the test USDC faucet on testnet
faucetAccount3 in a daySigned-in owner account, each UTC dayPOST /api/topup/faucet, the same faucet
faucetGlobal50 in a dayAll vaults together, each UTC dayPOST /api/topup/faucet, the same faucet
faucetTries10 in 10 minutesSigned-in accountPOST /api/topup/faucet: each press of the faucet button, before the chain is read
teeCheck30 in a minuteAll visitors togetherGET /api/tee/check, the proof page's live TEE check

SDK and core limits#

These bound what @probarion/sdk and @probarion/core send, keep and wait for.

ConstantPackageValueWhat it is
USDC_DECIMALS@probarion/core6Amounts travel in USDC's base units, so 1 USDC is 1000000
PAGE_SIZE@probarion/sdk50Items the SDK asks for in each page when it reads a whole list
MAX_PAGE_LIMIT@probarion/sdk100The largest limit the SDK sends: the contracts' MAX_PAGE
MAX_RESPONSE_BODY_BYTES@probarion/sdk65,536 bytes (64 KiB)The largest NEAR AI response the SDK uses. The response goes into the ledger entry
CATALOG_PAGE_SIZE@probarion/sdk100Models the SDK asks NEAR AI's model catalog for in each page
DEFAULT_NEARAI_TIMEOUTS_MS@probarion/sdkcatalog 10,000 ms (10 seconds), report 15,000 ms (15 seconds), chat 90,000 ms (90 seconds), signature 15,000 ms (15 seconds)How long each kind of NEAR AI call may take, headers and body together, before the SDK gives up on it. The timeoutMs option overrides it per kind
PROPOSAL_MAX_TOKENS@probarion/core4,096The max_tokens of a decision request to the model
MAX_REASONING_CHARS@probarion/core2,000The model's reasoning is cut to this many Unicode code points
UNKNOWN_SETTLE_MS@probarion/sdk172,800,000 ms (48 hours)How long code refuses an invoice whose spend has an unknown outcome, unless the chain shows the spend sooner

What the tables leave out#

  • The limits an owner sets for each payment and for the vault's day: Mandates and How a payment is checked.
  • The arguments, return values and errors of each method: Contract reference.
  • The body, callers and errors of each route: HTTP API.
  • The Canary's own caps on POST /api/canary/attempt, in CANARY_LIMITS (apps/web/src/lib/canary/limits.ts): attempts from one address and from everyone in an hour and a day, a daily budget of model tokens, the length of a message, and how often an attempt may go on chain. An attempt past an attempt cap or the token budget gets 429 budget, not rate_limited.
  • Caps the hosted app keeps on its own work and display, such as how far behind a node the health check accepts and how much of a ledger string the proof page shows.
  • The NEAR protocol's own limits, such as the most gas one transaction may carry, and the price of gas.
  • Mainnet values. The code is the same on both networks, but the mainnet factory is not deployed, and no mainnet min_deposit is recorded. The one mainnet vault, v0.probarion.near, was deployed without a factory. Testnet and mainnet explains the difference.

Built from 4ab41ca · reviewed

Show

Loading the search index