> ## Documentation Index
> Fetch the complete documentation index at: https://docs.eco.com/llms.txt
> Use this file to discover all available pages before exploring further.

# verify: Test vectors

> Test vectors: 6 exports of the verify module of @eco-incorp/sauce, including SETTLE_PROGRAM, SETTLE_VECTORS, SETTLE_REJECTIONS, settlePayload, ConformanceVector, RejectionVector.

`@eco-incorp/sauce/verify` validates an EVM settlement payload against the pinned settle program (`SETTLE_WIRE`: compiler 2.3.0, 356 bytes) and decodes its runtime argument tail. It depends on viem only, so it runs in browsers and edge runtimes without loading the compiler.

This page covers `sdk/dist/verify/vectors.d.ts`.

<Note>
  Generated from the type declarations shipped in `@eco-incorp/sauce` 0.99.4. Each entry shows the package authors' JSDoc and declaration for this SDK version. For runtime compatibility and deployed addresses, see [architecture and deployments](/programmable-transactions/sauce/architecture-and-deployments).
</Note>

### `SETTLE_PROGRAM`

*Variable* · `sdk/dist/verify/vectors.d.ts`

The compiled `recipes/settle.sauce.ts` program - 356 bytes, measured by compiling it with the
published Rust compiler (`@eco-incorp/sauce-compiler`) against the package's own
`artifacts/IERC20.json`.

ONE constant covers the whole corpus because the program is INVARIANT: `main` takes
`(tokens, minOut, recipient)` as runtime entry arguments, so no caller value reaches the
compiler. That is the property the appended-args model rests on, and `verify.compile.test.ts` recompiles
this and compares - a LIVE pin, unlike the v1 corpus it replaces, whose compiler no longer exists.

```typescript theme={null}
SETTLE_PROGRAM: Hex
```

### `SETTLE_VECTORS`

*Variable* · `sdk/dist/verify/vectors.d.ts`

Golden wire-format vectors - the Go/Solidity/Python conformance corpus, and the definition of the
layout for anyone reimplementing the decoder.

Each `args` tail is proven by EXECUTION, not by construction: `verify-execution.e2e.test.ts` runs
`settlePayload(v.args)` on a real v12 runtime against real ERC20s and asserts the engine sweeps
exactly `v.tokens` to `v.recipient` under `v.minOut`. The bytes below are what the engine reads,
not what this package's encoder happens to emit.

`v3` carries `Z = 0x0000000000000000000000000000000000ff00aa` - the address the retired v1 corpus
used as its trap, because a minimal-length PUSH squeezed it into 3 bytes and a fixed 20-byte read
misframed everything after it. On THIS wire it is an ordinary 32-byte word: the layout is
fixed-width, so leading zero bytes cost nothing and mean nothing. The hazard moved, and
`SETTLE_REJECTIONS` is where it went.

```typescript theme={null}
SETTLE_VECTORS: readonly ConformanceVector[]
```

### `SETTLE_REJECTIONS`

*Variable* · `sdk/dist/verify/vectors.d.ts`

Payloads a conformant decoder MUST refuse - the successor to the v1 corpus's `v3` trap.

The `engineAccepts` rows are the trap proper, and they are the reason this corpus exists at all: the
engine RUNS them and produces exactly the behavior of the canonical payload beside them, so they
are distinct byte strings with identical meaning. A decoder that accepts any of them is not
injective, and `encodeSettleProgram` re-encode-and-compare stops agreeing with decode-and-compare.
`upperBytes` is the sharpest: the engine masks a call target to 160 bits, so twelve arbitrary
bytes ride along in a token word and sweep the very same token.

Each vector's `code` is reachable under ANY check order, so a Go or Solidity reimplementation is not
required to match this decoder's sequence to pass. `tokensPointer` is the one that has to be built
for that: its padding word is `0x02` so that the count read at the canonical offset agrees with the
tail length, leaving the non-canonical pointer as the only complaint. A length-first decoder and a
pointer-first decoder both report `TOKENS_OFFSET`. (The engine reads its array from offset 128, so
that word is not in its read path -- `engineAccepts` is unaffected by its value.)

```typescript theme={null}
SETTLE_REJECTIONS: readonly RejectionVector[]
```

### `settlePayload`

*Function* · `sdk/dist/verify/vectors.d.ts`

The full on-the-wire payload for a vector's tail: `program || args`.

Exported from `./verify`, so it takes a caller's hex rather than only this file's literals: an
unprefixed tail would otherwise lose its first byte to the slice and resurface as a puzzling
`ARGS_TRUNCATED`, and a `0X` prefix - which the decoder itself tolerates - would produce garbage.
Requires the canonical `0x`, consistent with `encodeSettleProgram`'s inputs.

```typescript theme={null}
export declare function settlePayload(args: Hex): Hex;
```

### `ConformanceVector`

*Interface* · `sdk/dist/verify/vectors.d.ts`

```typescript theme={null}
export interface ConformanceVector {
    name: string;
    tokens: Hex[];
    minOut: bigint;
    recipient: Hex;
    args: Hex;
}
```

### `RejectionVector`

*Interface* · `sdk/dist/verify/vectors.d.ts`

```typescript theme={null}
export interface RejectionVector {
    name: string;
    args: Hex;
    code: SettleFailureCode;
    engineAccepts: boolean;
    sweepsIdentically: boolean;
}
```