@nradko/metric-omm-sdk-v1 0.2.0 → 0.4.1

package/README.md

@@ -1,8 +1,8 @@
 # @nradko/metric-omm-sdk-v1
 
-TypeScript SDK for **v1** Metric OMM contracts: **Swapper**, **LiquidityAdder**, pool `addLiquidity` / `removeLiquidity`, and factory-backed reads.
+TypeScript SDK for **v1** Metric OMM contracts: **SimpleRouter**, **SwapQuoter**, **LiquidityAdder**, pool `addLiquidity` / `removeLiquidity`, **extensions**, and factory-backed reads.
 
-Pinned to the same commits as [`dev_metric-deploy/versions.env`](../../../dev_metric-deploy/versions.env).
+Pinned **metric-periphery** `dccbda7970da36d55a86108e3dbcce1e794c9634` (core via periphery `lib/metric-core`).
 
 ## Installation
 
@@ -16,72 +16,150 @@ Or via the combined package:
 import { v1 } from "@nradko/metric-omm-sdk";
 ```
 
-## Ethereum mainnet addresses
+## Ethereum mainnet and Base addresses
+
+Protocol contracts use the **same addresses** on Ethereum mainnet and Base (CREATE2). Wrapped native differs per chain (WETH).
 
 | Contract | Address |
 | -------- | ------- |
-| MetricOmmPoolFactory | `0xDd41F182630A395E2ED8b9c1D5f1E22F1f9b133a` |
-| MetricOmmPoolDeployer | `0xb9bb9364FEA5170713709Ba67Aec649eF043e885` |
-| MetricOmmPoolLiquidityAdder | `0x9de47a0C84c7F9486Af77C8135CE7f480d121B44` |
-| MetricOmmPoolDataProvider | `0xf06454dB7E9b8BCa2FC77bF6e88f9B98dF0b52e8` |
-| MetricOmmPoolStateView | `0x124C2853E316d1585621560E35D4dcC8318F97FF` |
-| MetricOmmSimpleRouter | `0x94DD3A9308A1060f4BD9A95dE65F27f0F048f863` |
-| MetricOmmPoolSwapper | `0xc73407A1d240e08EB34654e706cc3B19E356b8C4` |
-| WETH | `0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2` |
-
-`MetricOmmPoolDataProvider` is the deployed lens: pool reads (`slot0`, `binStates`, `positionBinShares`, …) plus swap depth and revert-based quotes. Pass `addresses.dataProvider` to read helpers and liquidity builders (`dataProviderAddress` param).
+| MetricOmmPoolFactory | `0x567C7205107257650dC73a73d87b879a45F5b6F6` |
+| MetricOmmPoolDeployer | `0xBe34D0cEb6CF1acbf55dEf35E4dC3e17BDfb6AE4` |
+| MetricOmmPoolLiquidityAdder | `0x323B95ABcE8b3025829980bb19d1Fd819808FCB2` |
+| MetricOmmPoolDataProvider | `0x5A100da447833D94b8e50AeD1916D7488D15D3fc` |
+| MetricOmmSimpleRouter | `0x18f85056444452E718cD680A08f219B2347FE672` |
+| DepositAllowlistExtension | `0x088B0CCBdb17531132173a30428f66c1d5A73794` |
+| SwapAllowlistExtension | `0x952D844e166E6FAaF73a5e56F0fB0C54543a0f69` |
+| OracleValueStopLossExtension | `0x9694959a452283d86eBF4EF4eB5651dEAa1eCec1` |
+| PriceVelocityGuardExtension | `0xa53E5db6c18Ce258b3090F1470c5fE7f2e0215Fc` |
+| WETH (Ethereum) | `0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2` |
+| WETH (Base) | `0x4200000000000000000000000000000000000006` |
+
+`addresses.quoter` is a zero placeholder until a public SwapQuoter deployment is wired in this SDK release. Pass `quoterAddress` to quote helpers or set the bundled address when available.
+
+`MetricOmmPoolDataProvider` is the deployed lens: pool reads (`slot0`, `binStates`, `positionBinShares`, …). Pass `addresses.dataProvider` to read helpers and liquidity builders (`dataProviderAddress` param).
 
 ```typescript
 import { getAddressesOrThrow, ChainId, isChainSupported } from "@nradko/metric-omm-sdk-v1";
 
 const a = getAddressesOrThrow(ChainId.ETHEREUM);
-// isChainSupported(ChainId.BASE) === false — use DeployedChainId / getSupportedChainIds() for bundled addresses
+// getAddressesOrThrow(ChainId.BASE) — same protocol addresses as Ethereum
+// isChainSupported(ChainId.ARBITRUM) === false — use DeployedChainId / getSupportedChainIds()
 ```
 
-`ChainId` lists future chain IDs for typing; **only Ethereum mainnet** has entries in `ADDRESSES` for this release. Use `getSupportedChainIds()`, `isChainSupported()`, or `DeployedChainId` when you need compile-time guarantees.
+ChainId lists future chain IDs for typing; **Ethereum mainnet and Base** have entries in ADDRESSES for this release.
+
+## Swaps (SimpleRouter)
 
-## Swaps (Swapper)
+### Single hop
 
 ```typescript
 import {
-  buildArgsAndExpectedAmountsForSwapExactInput,
+  buildExactInputSingleParams,
   getAddressesOrThrow,
   ChainId,
 } from "@nradko/metric-omm-sdk-v1";
-import { MetricOmmPoolSwapperAbi } from "@nradko/metric-omm-sdk-v1/abis";
+import { MetricOmmSimpleRouterAbi } from "@nradko/metric-omm-sdk-v1/abis";
 
 const addresses = getAddressesOrThrow(ChainId.ETHEREUM);
 
-const { args, expectedInput, expectedOutput } =
-  await buildArgsAndExpectedAmountsForSwapExactInput({
-    publicClient,
-    factoryAddress: addresses.factory,
-    swapperAddress: addresses.swapper,
-    pool: poolAddress,
-    recipient: account,
-    zeroForOne: true,
-    amountIn: 1_000_000_000_000_000_000n,
-    slippagePercent: 0.5,
-    deadline: BigInt(Math.floor(Date.now() / 1000) + 1200),
-  });
+const params = await buildExactInputSingleParams({
+  publicClient,
+  pool: poolAddress,
+  tokenIn,
+  tokenOut,
+  recipient: account,
+  amountIn: 1_000_000_000_000_000_000n,
+  slippagePercent: 0.5,
+  deadline: BigInt(Math.floor(Date.now() / 1000) + 1200),
+  quoterAddress, // required until addresses.quoter is set
+});
 
 await walletClient.writeContract({
-  address: addresses.swapper,
-  abi: MetricOmmPoolSwapperAbi,
-  functionName: "swapExactInput",
-  args,
+  address: addresses.simpleRouter,
+  abi: MetricOmmSimpleRouterAbi,
+  functionName: "exactInputSingle",
+  args: [params],
+  account,
+});
+```
+
+### Multihop
+
+```typescript
+import { buildExactInputParams, encodeExactInputCalldata } from "@nradko/metric-omm-sdk-v1";
+
+const pathParams = await buildExactInputParams({
+  publicClient,
+  tokenIn,
+  tokenOut,
+  pools: [poolA, poolB],
+  recipient: account,
+  amountIn,
+  slippagePercent: 0.5,
+  deadline,
+  quoterAddress,
+});
+
+await walletClient.sendTransaction({
+  to: addresses.simpleRouter,
+  data: encodeExactInputCalldata(pathParams),
   account,
 });
 ```
 
-Quote without building tx args: `quoteSwap` (read-only pool quote), `quoteExpectedAmountsForSwapExactInput` / `quoteExpectedAmountsForSwapExactOutput` (Swapper-aligned estimates for slippage math).
+Approve the **SimpleRouter** for input tokens (ERC-20 path). Swap allowlist extensions gate the **router contract address**, not the end-user EOA.
+
+## Quotes (SwapQuoter)
+
+Live quotes simulate the quoter contract (eth_call). Pass `quoterAddress` when `addresses.quoter` is unset.
+
+```typescript
+import { quoteLiveExactInSingle, quoteLiveExactIn } from "@nradko/metric-omm-sdk-v1";
+
+const single = await quoteLiveExactInSingle({
+  publicClient,
+  pool: poolAddress,
+  tokenIn,
+  tokenOut,
+  recipient: account,
+  amountIn,
+  quoterAddress,
+});
+
+const path = await quoteLiveExactIn({
+  publicClient,
+  tokenIn,
+  tokenOut,
+  pools: [poolA, poolB],
+  recipient: account,
+  amountIn,
+  quoterAddress,
+});
+```
+
+Hypothetical quotes: `quoteHypotheticalExactInputSingle`, `quoteHypotheticalExactInput`, and exact-output variants with per-pool bid/ask prices.
 
 ## Liquidity
 
 - **Add (EOA):** approve **LiquidityAdder**, then `addLiquidityExactShares` / `addLiquidityWeighted` on the adder (see `encodeAddLiquidity*` helpers).
 - **Remove:** `removeLiquidity` on the pool — build deltas with `buildModifyLiquidityArgsForRemoval` / `encodeRemoveLiquidityCalldata`.
 
-SDK builders still use internal names like `buildModifyLiquidityArgsForUniformAddition` where the math is shared; encoders target v1 pool/adder ABIs.
+## Extensions
+
+Pools support up to seven **extensions** (periphery contracts) configured at creation via `extensions`, `extensionOrders`, and `extensionInitData`. Swap and liquidity encoders forward optional **`extensionData`** (defaults to `0x`).
+
+See extension admin encoders (`encodeSetAllowedToDepositCalldata`, `encodeSetAllowedToSwapCalldata`, …) and [HOW_TO.md](../metric-omm-sdk/HOW_TO.md) for pool-creation examples.
+
+## Oracle registration
+
+For providers-oracle price feeds, register pools before attributed reads:
+
+```typescript
+import { getPoolOracleStatus, registerPool } from "@nradko/metric-omm-sdk-v1";
+
+const status = await getPoolOracleStatus(publicClient, oracleAddress, feedId, poolAddress);
+await registerPool({ publicClient, walletClient, oracleAddress, feedId, pool: poolAddress, factory, account });
+```
 
 ## Pool reads
 
@@ -100,8 +178,14 @@ const slot0 = await getSlot0(publicClient, addresses.dataProvider, poolAddress);
 import {
   MetricOmmPoolAbi,
   MetricOmmPoolDataProviderAbi,
-  MetricOmmPoolSwapperAbi,
+  MetricOmmSimpleRouterAbi,
+  MetricOmmSwapQuoterAbi,
   MetricOmmPoolLiquidityAdderAbi,
+  DepositAllowlistExtensionAbi,
+  SwapAllowlistExtensionAbi,
+  PriceVelocityGuardExtensionAbi,
+  OracleValueStopLossExtensionAbi,
+  OracleProviderAbi,
 } from "@nradko/metric-omm-sdk-v1/abis";
 ```
 
@@ -111,30 +195,20 @@ Regenerate from pinned contracts:
 npm run setup:contracts    # init submodules, hardhat build, sync ABIs
 ```
 
-All pinned contracts (including `MetricOmmPoolDataProvider`) are compiled by Hardhat from the pinned `@metric/core` and `@metric/periphery` git dependencies (periphery remappings use core's libs via `lib/metric-core`).
-
 ## Development
 
 ```bash
 npm run build              # tsc only (default prepare)
 npm run setup:contracts    # refresh ABIs from pinned git deps (maintainers)
 npm test                   # Hardhat tests (needs matching @metric/* in node_modules)
+npm run verify             # lint, format, typecheck, test — publish gate
 ```
 
-In the monorepo, run v1 tests with an isolated install (same pattern as v0):
-
 ```bash
-# from dev_sdk/
 cd v1
 npm ci
-npm run sync:contracts   # required before first test run
+npm run setup:contracts
 npm test
 ```
 
-## Tests
-
-```bash
-npm run sync:contracts && npm test
-```
-
 Fork tests: set `ETHEREUM_RPC_URL` (optional `ETHEREUM_FORK_BLOCK_NUMBER`).

package/dist/abis/DepositAllowlistExtension.d.ts

@@ -0,0 +1,440 @@
+export declare const DepositAllowlistExtensionAbi: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "factory_";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "ExtensionNotImplemented";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "NotAllowedToDeposit";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "caller";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "factory";
+        readonly type: "address";
+    }];
+    readonly name: "OnlyFactory";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "caller";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "factory";
+        readonly type: "address";
+    }];
+    readonly name: "OnlyPool";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "caller";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "admin";
+        readonly type: "address";
+    }];
+    readonly name: "OnlyPoolAdmin";
+    readonly type: "error";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "depositor";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bool";
+        readonly name: "allowed";
+        readonly type: "bool";
+    }];
+    readonly name: "AllowedToDepositSet";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "FACTORY";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint80";
+        readonly name: "";
+        readonly type: "uint80";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "int256[]";
+            readonly name: "binIdxs";
+            readonly type: "int256[]";
+        }, {
+            readonly internalType: "uint256[]";
+            readonly name: "shares";
+            readonly type: "uint256[]";
+        }];
+        readonly internalType: "struct LiquidityDelta";
+        readonly name: "";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly name: "afterAddLiquidity";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "";
+        readonly type: "bytes4";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint80";
+        readonly name: "";
+        readonly type: "uint80";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "int256[]";
+            readonly name: "binIdxs";
+            readonly type: "int256[]";
+        }, {
+            readonly internalType: "uint256[]";
+            readonly name: "shares";
+            readonly type: "uint256[]";
+        }];
+        readonly internalType: "struct LiquidityDelta";
+        readonly name: "";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly name: "afterRemoveLiquidity";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "";
+        readonly type: "bytes4";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }, {
+        readonly internalType: "int128";
+        readonly name: "";
+        readonly type: "int128";
+    }, {
+        readonly internalType: "uint128";
+        readonly name: "";
+        readonly type: "uint128";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint128";
+        readonly name: "";
+        readonly type: "uint128";
+    }, {
+        readonly internalType: "uint128";
+        readonly name: "";
+        readonly type: "uint128";
+    }, {
+        readonly internalType: "int128";
+        readonly name: "";
+        readonly type: "int128";
+    }, {
+        readonly internalType: "int128";
+        readonly name: "";
+        readonly type: "int128";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly name: "afterSwap";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "";
+        readonly type: "bytes4";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "pool";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "depositor";
+        readonly type: "address";
+    }];
+    readonly name: "allowedDepositor";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint80";
+        readonly name: "";
+        readonly type: "uint80";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "int256[]";
+            readonly name: "binIdxs";
+            readonly type: "int256[]";
+        }, {
+            readonly internalType: "uint256[]";
+            readonly name: "shares";
+            readonly type: "uint256[]";
+        }];
+        readonly internalType: "struct LiquidityDelta";
+        readonly name: "";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly name: "beforeAddLiquidity";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "";
+        readonly type: "bytes4";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint80";
+        readonly name: "";
+        readonly type: "uint80";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "int256[]";
+            readonly name: "binIdxs";
+            readonly type: "int256[]";
+        }, {
+            readonly internalType: "uint256[]";
+            readonly name: "shares";
+            readonly type: "uint256[]";
+        }];
+        readonly internalType: "struct LiquidityDelta";
+        readonly name: "";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly name: "beforeRemoveLiquidity";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "";
+        readonly type: "bytes4";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }, {
+        readonly internalType: "int128";
+        readonly name: "";
+        readonly type: "int128";
+    }, {
+        readonly internalType: "uint128";
+        readonly name: "";
+        readonly type: "uint128";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint128";
+        readonly name: "";
+        readonly type: "uint128";
+    }, {
+        readonly internalType: "uint128";
+        readonly name: "";
+        readonly type: "uint128";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly name: "beforeSwap";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "";
+        readonly type: "bytes4";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "";
+        readonly type: "bytes";
+    }];
+    readonly name: "initialize";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "";
+        readonly type: "bytes4";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "pool_";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "depositor";
+        readonly type: "address";
+    }];
+    readonly name: "isAllowedToDeposit";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "pool_";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "depositor";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "allowed";
+        readonly type: "bool";
+    }];
+    readonly name: "setAllowedToDeposit";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];
+//# sourceMappingURL=DepositAllowlistExtension.d.ts.map

package/dist/abis/DepositAllowlistExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DepositAllowlistExtension.d.ts","sourceRoot":"","sources":["../../src/abis/DepositAllowlistExtension.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0jB/B,CAAC"}