> For the complete documentation index, see [llms.txt](https://docs.augustdigital.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.augustdigital.io/developers/typescript-sdk/api/evmadapter.md).

# EVMAdapter

[SDK Reference](/developers/typescript-sdk/api.md) / EVMAdapter

## EVMAdapter

EVM Adapter for August SDK

### Classes

#### default

EVM Adapter for August SDK Supports both ethers Signer/Wallet and wagmi/viem WalletClient

**Example**

To access the EVM adapter instance

```
const sdk = new AugustSDK()
sdk.evm.vaultRedeem()
```

**Constructors**

**Constructor**

> **new default**(`signer?`): [`default`](#default)

**Parameters**

| Parameter | Type  |
| --------- | ----- |
| `signer?` | `any` |

**Returns**

[`default`](#default)

**Methods**

**allowance()**

> **allowance**(`options`): `Promise`<`bigint`>

Read the ERC-20 allowance an owner has granted the vault. Defaults to the vault's underlying asset; pass `asset` to override.

**Parameters**

| Parameter | Type                |
| --------- | ------------------- |
| `options` | `IAllowanceOptions` |

**Returns**

`Promise`<`bigint`>

Allowance as a raw `bigint`.

**Example**

```ts
const raw = await augustSdk.evm.allowance({ vault, owner });
```

**approve()**

> **approve**(`options`): `Promise`<`ApproveResult`>

Approve a vault to spend a deposit token, returning a discriminated ApproveResult so callers can tell `sent` from `sufficient` (existing allowance covers) and `native` (no allowance applies). Prefer this over [vaultApprove](#vaultapprove) for new integrations.

**Parameters**

| Parameter | Type                    |
| --------- | ----------------------- |
| `options` | `IContractWriteOptions` |

**Returns**

`Promise`<`ApproveResult`>

**Example**

```ts
const r = await augustSdk.evm.approve({
  target: vaultAddress,
  wallet: walletAddress,
  amount: '100',
  wait: true,
});
if (r.kind === 'sent') console.log('approve tx', r.hash);
```

**balanceOf()**

> **balanceOf**(`options`): `Promise`<`bigint`>

Read an ERC-20 token balance.

**Parameters**

| Parameter | Type                |
| --------- | ------------------- |
| `options` | `IBalanceOfOptions` |

**Returns**

`Promise`<`bigint`>

Balance as a raw `bigint`.

**Example**

```ts
const raw = await augustSdk.evm.balanceOf({ asset: usdcAddress, owner });
```

**depositNative()**

> **depositNative**(`options`): `Promise`<`string`>

Deposit the chain's native asset (ETH / AVAX / etc.) into a vault by routing through the `MultiAssetNativeDepositWrapper`. The wrapper handles native-to-wrapped conversion and the subsequent vault deposit in a single transaction.

**Parameters**

| Parameter | Type                    | Description                                                                                                                                                           |
| --------- | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `options` | `INativeDepositOptions` | INativeDepositOptions: `wrapperAddress`, `amount` (native, scaled by the chain's native decimals), optional `receiver` (defaults to the signer), and optional `wait`. |

**Returns**

`Promise`<`string`>

The deposit `TransactionResponse`.

**Throws**

AugustValidationError on invalid inputs.

**Throws**

AugustSDKError on RPC / contract revert.

**Example**

```ts
const tx = await augustSdk.evm.depositNative({
  wrapperAddress: nativeWrapperAddress,
  amount: parseEther('1'),
  wait: true,
});
```

**depositNativeViaSwapRouter()**

> **depositNativeViaSwapRouter**(`options`): `Promise`<`string`>

Deposit native ETH (or chain-native equivalent) into a vault via the SwapRouter. Only valid when the vault's reference asset is the chain's wrapped-native token — the SwapRouter wraps `amount` and deposits.

**Parameters**

| Parameter | Type                              | Description                      |
| --------- | --------------------------------- | -------------------------------- |
| `options` | `ISwapRouterNativeDepositOptions` | ISwapRouterNativeDepositOptions. |

**Returns**

`Promise`<`string`>

The transaction hash of the `depositNativeToken` call.

**depositViaSwapRouter()**

> **depositViaSwapRouter**(`options`): `Promise`<`string`>

Deposit a vault's reference asset through the SwapRouter — no swap. Use this when the caller already holds the reference asset but wants the origin/referral fee accounting that the SwapRouter path provides.

**Parameters**

| Parameter | Type                              | Description                      |
| --------- | --------------------------------- | -------------------------------- |
| `options` | `ISwapRouterDirectDepositOptions` | ISwapRouterDirectDepositOptions. |

**Returns**

`Promise`<`string`>

The transaction hash of the `deposit` call.

**getDeposited()**

> **getDeposited**(`options`): `Promise`<`INormalizedNumber`>

**Parameters**

| Parameter           | Type                                                                                               |
| ------------------- | -------------------------------------------------------------------------------------------------- |
| `options`           | { `vault`: `` `0x${string}` ``; `wallet`: `` `0x${string}` ``; `whitelist`: `` `0x${string}` ``; } |
| `options.vault`     | `` `0x${string}` ``                                                                                |
| `options.wallet`    | `` `0x${string}` ``                                                                                |
| `options.whitelist` | `` `0x${string}` ``                                                                                |

**Returns**

`Promise`<`INormalizedNumber`>

**getRemainingAllocations()**

> **getRemainingAllocations**(`options`): `Promise`<`INormalizedNumber`>

**Parameters**

| Parameter                   | Type                                                                                                                              |
| --------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| `options`                   | { `depositCapAmount?`: `bigint`; `vault`: `` `0x${string}` ``; `wallet`: `` `0x${string}` ``; `whitelist`: `` `0x${string}` ``; } |
| `options.depositCapAmount?` | `bigint`                                                                                                                          |
| `options.vault`             | `` `0x${string}` ``                                                                                                               |
| `options.wallet`            | `` `0x${string}` ``                                                                                                               |
| `options.whitelist`         | `` `0x${string}` ``                                                                                                               |

**Returns**

`Promise`<`INormalizedNumber`>

**getSwapRouterDepositResult()**

> **getSwapRouterDepositResult**(`options`): `Promise`<`ISwapRouterDepositResult`>

Resolves the real, post-execution outcome of a SwapRouter deposit from its mined receipt — the actual amount that reached the vault (and shares minted), decoded from the vault's own `Deposit` event, rather than the pre-trade quote shown before submission.

**Parameters**

| Parameter | Type                              | Description                      |
| --------- | --------------------------------- | -------------------------------- |
| `options` | `ISwapRouterDepositResultOptions` | ISwapRouterDepositResultOptions. |

**Returns**

`Promise`<`ISwapRouterDepositResult`>

The decoded ISwapRouterDepositResult, or `null` if the receipt isn't found yet or carries no matching `Deposit` log.

**Example**

```ts
const hash = await augustSdk.evm.swapRouterDeposit({ ... });
const result = await augustSdk.evm.getSwapRouterDepositResult({ txHash: hash, vault });
```

**isWhitelisted()**

> **isWhitelisted**(`options`): `Promise`<`boolean`>

**Parameters**

| Parameter           | Type                                                                 |
| ------------------- | -------------------------------------------------------------------- |
| `options`           | { `wallet`: `` `0x${string}` ``; `whitelist`: `` `0x${string}` ``; } |
| `options.wallet`    | `` `0x${string}` ``                                                  |
| `options.whitelist` | `` `0x${string}` ``                                                  |

**Returns**

`Promise`<`boolean`>

**maxDeposit()**

> **maxDeposit**(`options`): `Promise`<`bigint`>

Read the maximum deposit accepted by the vault for the supplied receiver. Useful for "vault is full" gates.

**Parameters**

| Parameter | Type                 |
| --------- | -------------------- |
| `options` | `IMaxDepositOptions` |

**Returns**

`Promise`<`bigint`>

Max deposit as a raw `bigint`.

**Example**

```ts
const cap = await augustSdk.evm.maxDeposit({ vault });
```

**previewDeposit()**

> **previewDeposit**(`options`): `Promise`<`bigint`>

Preview the share output of a deposit without broadcasting a transaction. See readPreviewDeposit for the routing details (EVM-1 vs EVM-2 multi-asset vaults).

**Parameters**

| Parameter | Type                     |
| --------- | ------------------------ |
| `options` | `IPreviewDepositOptions` |

**Returns**

`Promise`<`bigint`>

Shares minted in raw on-chain units (share-token decimals).

**Example**

```ts
const shares = await augustSdk.evm.previewDeposit({
  vault: '0x...',
  amount: 1_000_000n,
});
```

**previewRedeem()**

> **previewRedeem**(`options`): `Promise`<`bigint`>

Preview the assets returned by redeeming a number of shares, without broadcasting a transaction.

**Parameters**

| Parameter | Type                    |
| --------- | ----------------------- |
| `options` | `IPreviewRedeemOptions` |

**Returns**

`Promise`<`bigint`>

Assets returned in raw on-chain units (asset decimals).

**Example**

```ts
const assets = await augustSdk.evm.previewRedeem({
  vault: '0x...',
  shares: 1_000_000_000_000_000_000n,
});
```

**sendersWhitelistAddress()**

> **sendersWhitelistAddress**(`options`): `Promise`<`` `0x${string}` ``>

**Parameters**

| Parameter       | Type                              |
| --------------- | --------------------------------- |
| `options`       | { `vault`: `` `0x${string}` ``; } |
| `options.vault` | `` `0x${string}` ``               |

**Returns**

`Promise`<`` `0x${string}` ``>

**setSigner()**

> **setSigner**(`signer`): `void`

Set a new signer (supports both ethers and viem/wagmi)

**Parameters**

| Parameter | Type  | Description                                         |
| --------- | ----- | --------------------------------------------------- |
| `signer`  | `any` | Either an ethers Signer/Wallet or viem WalletClient |

**Returns**

`void`

**swapAndDeposit()**

> **swapAndDeposit**(`options`): `Promise`<`string`>

Swap one or more whitelisted ERC-20s into a vault's reference asset via the on-chain `SwapRouter` and deposit the proceeds. The router handles fee accrual, slippage protection, and the v1/v3 vs v2 deposit-interface branching. Approval is sent automatically for each `swaps[i].tokenIn` when the caller's allowance against the SwapRouter is below `amountIn`.

**Parameters**

| Parameter | Type                     | Description             |
| --------- | ------------------------ | ----------------------- |
| `options` | `ISwapAndDepositOptions` | ISwapAndDepositOptions. |

**Returns**

`Promise`<`string`>

The transaction hash of the `swapAndDeposit` call.

**Throws**

AugustValidationError on invalid inputs (bad chain, empty swaps).

**Throws**

AugustSDKError on RPC / contract revert.

**Example**

```ts
const quote = await fetchSwapQuote({
  chainId: 1, srcToken: WBTC, srcDecimals: 8,
  destToken: USDC, destDecimals: 6, amount: 100_000_000n,
  receiver: SWAP_ROUTER_ADDRESSES[1]!,
});
const hash = await augustSdk.evm.swapAndDeposit({
  chainId: 1, vault, receiver: wallet,
  swaps: [{ tokenIn: WBTC, tokenOut: USDC, amountIn: 100_000_000n,
    minAmountOut: quote.minAmountOut, router: quote.router, payload: quote.payload }],
});
```

**swapRouterDeposit()**

> **swapRouterDeposit**(`options`): `Promise`<`string`>

Deposit into a vault through the on-chain `SwapRouter`, choosing the router path from `depositAsset` (direct deposit, native wrap, or a swap to the reference asset). The high-level, explicit counterpart to the SwapRouter branch inside [vaultDeposit](#vaultdeposit) — the caller opts into the router deliberately, so a native-deposit vault is never accidentally swapped.

Reads the vault's reference asset + decimals on-chain, resolves the swap quote and fail-closes on aggregator/whitelist drift, and sends the ERC-20 approval to the SwapRouter when allowance is short.

**Parameters**

| Parameter | Type                        | Description                |
| --------- | --------------------------- | -------------------------- |
| `options` | `ISwapRouterDepositOptions` | ISwapRouterDepositOptions. |

**Returns**

`Promise`<`string`>

The transaction hash of the router deposit call.

**Throws**

AugustValidationError on unsupported chain, invalid address, zero amount, a native deposit into a non-wrapped-native vault, or quote drift.

**Example**

```ts
const hash = await augustSdk.evm.swapRouterDeposit({
  chainId: 1, vault, depositAsset: USDT, amount: '100', slippageBps: 50,
});
```

**vaultAllowance()**

> **vaultAllowance**(`options`): `Promise`<`INormalizedNumber`>

Read the ERC-20 allowance the wallet has granted the vault to spend its underlying asset, returned as a normalized number. For the newer typed read that returns a raw `bigint` and accepts an explicit `asset` override, use [EVMAdapter.allowance](#allowance).

Only `target` (vault address) and `wallet` are read from `options`; the remaining IContractWriteOptions fields are ignored.

**Parameters**

| Parameter | Type                    | Description                                  |
| --------- | ----------------------- | -------------------------------------------- |
| `options` | `IContractWriteOptions` | `{ target, wallet }` (other fields ignored). |

**Returns**

`Promise`<`INormalizedNumber`>

Normalized allowance (`{ raw, normalized }`), or `undefined` when `target` / `wallet` fail address validation.

**Example**

```ts
const a = await augustSdk.evm.vaultAllowance({
  target: vaultAddress,
  wallet: walletAddress,
});
console.log(a?.normalized);
```

**vaultApprove()**

> **vaultApprove**(`options`): `Promise`<`string`>

**Parameters**

| Parameter | Type                    |
| --------- | ----------------------- |
| `options` | `IContractWriteOptions` |

**Returns**

`Promise`<`string`>

**vaultDeposit()**

> **vaultDeposit**(`options`): `Promise`<`string`>

Deposit into an August vault. Routes automatically: V1 single-asset vaults deposit the underlying directly; V2 multi-asset vaults route through the adapter for non-underlying `depositAsset`. If allowance is insufficient the method submits an approve transaction first (the approve step always waits for confirmation to close a race window, regardless of `wait`).

**Parameters**

| Parameter | Type                    | Description                                                                                                                                                                                        |
| --------- | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `options` | `IContractWriteOptions` | IContractWriteOptions. `target` and `wallet` are required; pass `amount`, `depositAsset` (defaults to the vault's underlying), `chainId`, `poolName`, `wait`, and `isDepositWithPermit` as needed. |

**Returns**

`Promise`<`string`>

The deposit `TransactionResponse`, or `undefined` if an approval-only path was taken and no deposit transaction was sent.

**Throws**

AugustValidationError on invalid inputs (bad address, bad amount).

**Throws**

AugustSDKError on RPC / contract revert during the deposit.

**Example**

```ts
const tx = await augustSdk.evm.vaultDeposit({
  target: vaultAddress,
  wallet: walletAddress,
  amount: '100',
  wait: true,
});
```

**vaultRedeem()**

> **vaultRedeem**(`options`): `Promise`<`string`>

Claim assets from a matured redemption request on a dated-redemption (RWA-style) vault. The `year`, `month`, `day`, and `receiverIndex` tuple identifies which batch of the user's matured requests to redeem from — these are emitted at request-time and indexed by the subgraph.

For non-dated vaults that complete their redemption via `instantRedeem`, see [EVMAdapter.vaultRequestRedeem](#vaultrequestredeem) with `isInstantRedeem: true`.

**Parameters**

| Parameter | Type                               | Description                                                                                                   |
| --------- | ---------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| `options` | `IContractWriteOptions` & `object` | IContractWriteOptions plus `year` / `month` / `day` / `receiverIndex` identifying the matured batch to claim. |

**Returns**

`Promise`<`string`>

The redeem `TransactionResponse`.

**Throws**

AugustValidationError on invalid inputs.

**Throws**

AugustSDKError on RPC / contract revert.

**Example**

```ts
const tx = await augustSdk.evm.vaultRedeem({
  target: vaultAddress,
  wallet: walletAddress,
  amount: shareAmount,
  year: '2026',
  month: '06',
  day: '02',
  receiverIndex: '0',
  wait: true,
});
```

**vaultRequestRedeem()**

> **vaultRequestRedeem**(`options`): `Promise`<`string`>

Submit a redemption request against a vault. Shares are escrowed and the underlying assets are released asynchronously by the protocol; callers collect the matured assets via [EVMAdapter.vaultRedeem](#vaultredeem), or use the instant-redeem variant by setting `isInstantRedeem: true`.

**Parameters**

| Parameter | Type                    | Description                                                                                                                                                               |
| --------- | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `options` | `IContractWriteOptions` | IContractWriteOptions. `target`, `wallet`, and `amount` (in shares) are required. Set `isInstantRedeem: true` to take the instant-redeem path when the vault supports it. |

**Returns**

`Promise`<`string`>

The request `TransactionResponse`, or `undefined` if the request could not be built (validation failure).

**Throws**

AugustValidationError on invalid inputs.

**Throws**

AugustSDKError on RPC / contract revert.

**Example**

```ts
const tx = await augustSdk.evm.vaultRequestRedeem({
  target: vaultAddress,
  wallet: walletAddress,
  amount: shareAmount,
  wait: true,
});
```

### Functions

#### getEvmVaultV1()

> **getEvmVaultV1**(`tokenizedVault`, `options`): `Promise`<`IVault`>

Fetch EVM vault data for v1 vault contracts (legacy format). Queries on-chain state and combines with backend metadata.

**Parameters**

| Parameter        | Type                                                                                    | Description                         |
| ---------------- | --------------------------------------------------------------------------------------- | ----------------------------------- |
| `tokenizedVault` | `ITokenizedVault`                                                                       | Vault metadata from backend         |
| `options`        | [`IVaultBaseOptions`](/developers/typescript-sdk/api/augustvaults.md#ivaultbaseoptions) | RPC configuration and chain details |

**Returns**

`Promise`<`IVault`>

Formatted vault object or null if closed/invisible

***

#### getEvmVaultV2()

> **getEvmVaultV2**(`tokenizedVault`, `options`): `Promise`<`IVault`>

Fetch EVM vault data for v2 vault contracts (current format). V2 vaults use separate contracts for vault, receipt token, and whitelist. Queries all three contracts and combines results.

**Parameters**

| Parameter        | Type                                                                                    | Description                         |
| ---------------- | --------------------------------------------------------------------------------------- | ----------------------------------- |
| `tokenizedVault` | `ITokenizedVault`                                                                       | Vault metadata from backend         |
| `options`        | [`IVaultBaseOptions`](/developers/typescript-sdk/api/augustvaults.md#ivaultbaseoptions) | RPC configuration and chain details |

**Returns**

`Promise`<`IVault`>

Formatted vault object or null if closed/invisible