@affluent-org/sdk 0.0.1 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@affluent-org/sdk",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "affluent-sdk",
   "main": "dist/index.js",
   "scripts": {

package/Refactoring.md

@@ -1,548 +0,0 @@
-# Factorial SDK Refactoring Plan
-
-## 현재 핵심 문제
-
-하나의 클래스/파일이 여러 성격의 책임을 동시에 지고 있다.
-
-| 파일 | 라인 수 | 섞여 있는 것 |
-|------|---------|-------------|
-| `contracts/vault/strategy-vault/index.ts` | 4,614 | Codec + Query + Action + Computation |
-| `pool.ts` | 2,895 | Query + Action + Oracle + Tracker + Flow |
-| `strategy_vault/base.ts` | 2,637 | Query + Action + Oracle + Computation |
-| `share-vault.ts` | 1,213 | Query + Action + Tracker + Flow |
-| `contracts/core/pool/index.ts` | 409 | Codec + Query + Action + Computation |
-
----
-
-## 기능 레이어 정의
-
-SDK가 하는 모든 일은 다음 5개 레이어로 분류된다.
-
-```
-┌─────────────────────────────────────────────────┐
-│                     Flow                        │
-│          다단계 흐름 조율 (조합 레이어)              │
-├────────┬────────┬────────┬─────────────────────┤
-│ Query  │ Oracle │Compute │  Tracker            │
-│온체인   │외부     │로컬     │ 온체인              │
-│읽기    │데이터    │연산     │ 변화 감시           │
-├────────┴────────┴────────┴─────────────────────┤
-│                    Codec                        │
-│             Cell ↔ TS 양방향 변환                  │
-└─────────────────────────────────────────────────┘
-```
-
-| 레이어 | 정의 | I/O | 의존 |
-|--------|------|-----|------|
-| **Codec** | Cell ↔ TypeScript 객체 양방향 변환. 메시지 빌드(`create*MsgBody` → Cell) 포함 | 없음 | 없음 |
-| **Query** | 온체인 상태 읽기 (get method 호출) | provider | Codec |
-| **Oracle** | 외부 데이터 수집 (가격 피드 등) | 외부 API | Codec |
-| **Computation** | 이미 가져온 데이터로 로컬 계산 | 없음 | 없음 |
-| **Tracker** | 온체인 트랜잭션 전파 추적, 결과 대기 | provider | Codec |
-| **Flow** | 위 레이어들의 조합. 고수준 사용자 동작 단위 | 전부 | 전부 |
-
-> **Action 레이어 제거**: 기존에 Codec의 `create*MsgBody`(→ Cell)를 `{ to, value, body }` 로 감싸는 Action 레이어가 있었으나, 모든 함수가 동일한 래핑만 수행하므로 불필요한 추상화로 판단하여 제거. 호출하는 쪽(Flow 또는 사용자)에서 직접 조립한다:
-> ```ts
-> const body = createSetOwnerAddressMsgBody(newOwner);
-> await sender.send({ to: vault.address, value: toNano("0.1"), body });
-> ```
-
----
-
-## 3레벨 아키텍처
-
-레이어를 분리하려면 **2분류(libs + services)로는 부족**하다. Query/Action이 두 수준에 걸쳐 있고, Oracle/Tracker는 특정 도메인에 속하지 않기 때문이다.
-
-| 레이어 | I/O | 범위 | 소속 레벨 |
-|--------|-----|------|----------|
-| Codec | 없음 | 컨트랙트별 | contracts/ |
-| Computation | 없음 | 컨트랙트별 + 범용 | contracts/ + core/ |
-| Query | provider | 컨트랙트별 | contracts/ |
-| Oracle | 외부 API | **도메인 횡단** | core/ |
-| Tracker | provider + 시간 | **도메인 횡단** | core/ |
-| Flow | 전부 | 도메인별 | services/ |
-
-### 3개 레벨 구조
-
-```
-┌──────────────────────────────────────────────┐
-│              services/ (도메인별)               │
-│  Flow: 고수준 API, 레이어 조합                   │
-│  pool/ share-vault/ strategy-vault/ rfq/     │
-├──────────────────────────────────────────────┤
-│              core/ (도메인 횡단)                │
-│  Oracle: 외부 데이터 수집                        │
-│  Tracker: Tx 추적, Step 실행                    │
-│  ContractOpener: 컨트랙트 열기 + 캐시            │
-│  Cache: TTL 캐시                               │
-│  RiskCalculator: 범용 Computation              │
-├──────────────────────────────────────────────┤
-│              contracts/ (컨트랙트별)             │
-│  Codec: Cell ↔ TS                             │
-│  Computation: 순수 계산                         │
-│  Query + Action: 단일 컨트랙트 get/send          │
-│  Constants, Types                             │
-└──────────────────────────────────────────────┘
-```
-
-### 의존 방향
-
-```
-services/ ──→ core/ ──→ contracts/
-    │                       ↑
-    └───────────────────────┘
-```
-
-**단방향만 허용.** contracts/가 core/나 services/를 import하면 안 된다. core/가 services/를 import하면 안 된다.
-
----
-
-## 레벨 1: contracts/ — 컨트랙트별, 바닥 레이어
-
-### 역할
-
-한 컨트랙트의 인터페이스를 정의한다. **다른 컨트랙트를 모른다.**
-
-포함 레이어: Codec, Computation, Query(단일), Constants, Types
-
-### 레이어별 경계
-
-| 레이어 | 받는 것 | 반환하는 것 | 의존 |
-|--------|---------|-----------|------|
-| Codec | Cell/Slice 또는 TS 객체 | TS 객체 또는 Cell | 없음 |
-| Computation | TS 객체 (이미 파싱된 상태) | TS 객체 (계산 결과) | Codec의 타입만 |
-| Query | provider + 주소/파라미터 | 파싱된 TS 객체 | Codec (파싱에 사용) |
-
-### 파일 분리 구조
-
-```
-contracts/<domain>/<contract>/
-├── codec.ts          ← Codec: 직렬화 + 파싱 + DictionaryValues (Cell ↔ TS 전부)
-├── computation.ts    ← Computation: 시뮬레이션, Gas 계산, 상태 변환
-├── constants.ts      ← Op, ErrorCodes, Gas
-├── type.ts           ← 상태/설정 타입 정의
-└── index.ts          ← Contract 클래스 (Query만)
-```
-
-> **dictionary.ts 제거**: DictionaryValues는 codec.ts 안에 포함. 단순한 serialize/parse 리스트이므로 별도 파일 불필요.
-
-### index.ts (Contract 클래스)의 최종 역할
-
-- **Query**: `get*` 메서드 — provider를 통해 온체인 데이터를 읽고, `codec.ts`로 파싱하여 반환
-
-Contract 클래스가 Codec과 Computation을 **import해서 사용**하되 **소유하지 않는** 구조.
-
-메시지 빌드는 Codec의 `create*MsgBody` 함수를 직접 사용:
-```ts
-import { createDepositPayload } from "./codec";
-const body = createDepositPayload(responseAddress, oracleParams);
-await sender.send({ to: vault.address, value: toNano("0.5"), body });
-```
-
-### 적용 대상
-
-| 컨트랙트 | Codec 추출 대상 | Computation 추출 대상 |
-|---------|----------------|---------------------|
-| Pool | `parsePoolData`, `createSupplyPayload`, `createWithdrawMsgBody` 등 | `simulateAccrueInterest`, `calculateGasFee` |
-| Account | `parseAccountData`, `accountConfigToCell` | `convertShareToAmount`, `applyDelta`, `haveBorrow`, `haveAssets` |
-| ShareVault | `parseVaultData`, config 직렬화 | `calculateGasFee` |
-| StrategyVault | 4,614줄 중 대부분 — parse/create 전체 | Gas 계산, fee accrual |
-| RFQAuction | `parseRFQStorage`, 메시지 빌더 | `computeBidReserveFee`, `computeSellReserveFee` |
-| RFQBatch | `parseStorage`, 메시지 빌더 | `computeOrderReserveFee` |
-
-### _parse_temp 폴더 처리
-
-`utils/_parse_temp/` (5,343줄)의 파싱 로직을 각 Contract의 `codec.ts`로 흡수하고 폴더 삭제.
-
-### Tx 메시지 Codec
-
-현재 `utils/parser.ts`에 범용으로 존재하는 Tx 메시지 파싱을 Contract별 `codec.ts`로 분산하고, 범용 dispatch 함수만 남긴다.
-
----
-
-## 레벨 2: core/ — 도메인 횡단, 중간 레이어
-
-### 역할
-
-여러 도메인이 공유하는 I/O 인프라를 제공한다. **특정 도메인에 속하지 않는다.**
-
-포함 레이어: Oracle, Tracker, ContractOpener, Cache, 범용 Computation
-
-### 레이어별 경계
-
-| 모듈 | 받는 것 | 반환하는 것 | 의존 |
-|------|---------|-----------|------|
-| Oracle | 자산 주소 목록 + oracle config | 가격 데이터, oracle params (Cell) | contracts/ Codec (Cell 빌드), 외부 API (Redstone) |
-| Tracker | provider + 탐색 조건 (주소, queryId, step 목록) | 발견된 트랜잭션, 완료 상태 | contracts/ Codec (tx 파싱), provider (폴링) |
-| ContractOpener | TonClient + Contract 클래스 + 주소 | OpenedContract (캐시된 인스턴스) | contracts/ (Contract 타입), Cache |
-| Cache | 캐시 키 + 값 | 캐시된 값 | 없음 |
-| RiskCalculator | 파싱된 account/pool 상태 + 가격 | risk ratio, max borrow/withdraw | contracts/ 타입만 |
-
-### 파일 구조
-
-```
-core/
-├── oracle/
-│   ├── redstone.ts              ← Redstone 연동
-│   ├── oracle-params.ts         ← oracle params 빌드 (현 oracle-v2.ts)
-│   └── type.ts                  ← AddressBucket, OracleParamsResult 등
-├── tracker/
-│   ├── tx-finder.ts             ← 트랜잭션 탐색 (현 utils/tracer.ts)
-│   ├── step-runner.ts           ← Step 순차 실행 + 콜백
-│   ├── seqno-waiter.ts          ← wallet seqno 폴링 대기
-│   └── type.ts                  ← TxStep, StepCallback 등
-├── contract-opener.ts           ← Contract 열기 + 캐시 (현 ServiceBaseV1.open/getByContract)
-├── cache.ts                     ← ContractCache + withCache (현 common/cache.ts)
-├── risk-calculator/             ← 범용 Computation (현 utils/risk_calculator/)
-└── type.ts                      ← 공용 타입 (Maybe, AddressLike, AddressInput)
-```
-
-### 현재 코드에서 추출할 위치
-
-| core/ 모듈 | 현재 위치 | 추출 방법 |
-|------------|----------|----------|
-| oracle | `oracle/oracle-v2.ts` + `PoolV1` 내 oracle 메서드 + `StrategyVaultBase` 내 oracle 메서드 | oracle-v2.ts를 core/로 이동, 서비스 내 인라인 oracle 로직을 core/oracle 호출로 교체 |
-| tracker | `PoolV1.findAndCallback` + `ShareVaultV1.buildSupplySteps/waitSupplyTx` + `StrategyVaultSteps.processingSteps` + `utils/tracer.ts` | 공통 패턴(step 빌드, step 실행, tx 탐색, polling)을 추출 |
-| contract-opener | `ServiceBaseV1.open()`, `getByContract()`, `contractCache` | ServiceBaseV1에서 분리, 주입 가능한 객체로 |
-| cache | `common/cache.ts` | 위치 이동 |
-| risk-calculator | `utils/risk_calculator/` | 위치 이동 |
-
-### ServiceBaseV1 해체
-
-현재 ServiceBaseV1이 제공하는 기능을 core/ 모듈로 분산:
-
-| 기능 | 현재 (ServiceBaseV1) | 변경 (core/) |
-|------|---------------------|-------------|
-| Contract 캐시 + 열기 | `open()`, `getByContract()` | `core/contract-opener.ts` |
-| 네트워크 설정 | `contracts`, `network` | 생성자 주입 설정 타입 |
-| Asset Type 캐시 | `static assetTypes` | `core/contract-opener.ts` 인스턴스 레벨 |
-| Wallet seqno 대기 | `waitWalletSeq()` | `core/tracker/seqno-waiter.ts` |
-| WTON 배포 | `deployWTONWallet()` | `services/` 레벨 Flow |
-
----
-
-## 레벨 3: services/ — 도메인별, 최상위 레이어
-
-### 역할
-
-사용자가 호출하는 고수준 API를 제공한다. contracts/와 core/를 **조합**한다.
-
-포함 레이어: Flow (Query + Action + Oracle + Tracker 조합)
-
-### 레이어별 경계
-
-| 레이어 | 받는 것 | 반환하는 것 | 의존 |
-|--------|---------|-----------|------|
-| Flow | 사용자 파라미터 (sender, 금액, 주소 등) | 트랜잭션 결과, 추적 결과 | contracts/ (Query, Action, Codec) + core/ (Oracle, Tracker, ContractOpener) |
-
-**실제 전송은 Flow에서 발생:**
-```ts
-// services/pool/supply.ts (Flow)
-const body = createSupplyPayload(params);  // Codec: Cell 생성
-await sender.send({ to: pool.address, value: toNano("0.5"), body });  // Flow: 전송
-```
-
-### 서비스 내부 분리 판단
-
-서비스 내부를 더 쪼갤지는 **크기로 판단**한다.
-
-| 서비스 | 현재 크기 | 분리 여부 | 근거 |
-|--------|----------|----------|------|
-| Pool | 2,895줄 | 분리 필요 | supply/withdraw/borrow/repay/liquidate 5개 도메인 액션 + 가격/리스크 조회 |
-| ShareVault | 1,213줄 | 분리 필요 | 버전 분기(V1/V2) + 매니저 액션 |
-| StrategyVault | 2,637 + 498줄 | 분리 필요 | deposit/withdraw/queue/owner/config 5개 도메인 액션 |
-| RFQAuction | 작음 | 단일 파일 | Flow가 단순 |
-| RFQBatch | 작음 | 단일 파일 | Flow가 단순 |
-
-### 큰 서비스 분리 구조
-
-```
-services/<domain>/
-├── index.ts          ← Flow: 고수준 API (조합 포인트)
-├── supply.ts         ← Flow: supply 흐름 (Action + Tracker 조합)
-├── withdraw.ts       ← Flow: withdraw 흐름
-├── ...               ← 도메인별 추가 흐름
-└── queries.ts        ← 서비스 레벨 조회 (여러 contracts/ Query 조합)
-```
-
-각 파일 내부에서 contracts/와 core/를 import해서 조합한다. **파일 간 import는 index.ts를 통해서만.**
-
-### 조합 예시: supply 흐름의 의존 관계
-
-```
-services/pool/supply.ts (Flow)
-  ├── contracts/jetton/         Query: wallet 주소 조회
-  ├── contracts/core/pool/      Query: pool 데이터, Codec: supply Cell 빌드, Computation: gas 계산
-  ├── contracts/core/account/   Query: account 주소
-  ├── core/oracle/              Oracle: 가격 데이터 수집
-  ├── core/tracker/             Tracker: tx 추적, step 실행
-  └── sender.send()             Flow에서 직접 전송 (Codec은 Cell만 생성)
-```
-
-### 작은 서비스 단일 파일 구조
-
-```
-services/rfq-auction/
-└── index.ts          ← Flow + 조회 전부 포함
-```
-
----
-
-## 반복 패턴 추출
-
-3회 이상 반복이 확인된 패턴만 추출한다.
-
-### Dictionary → Record 변환 (5회 반복)
-
-Pool, Account, ShareVault, StrategyVault, RFQBatch에서 동일한 Dictionary → Record 변환 패턴 반복.
-`contracts/` 레벨 공통 Codec 유틸로 추출.
-
-### 트랜잭션 Step 빌드 + 실행 (3회 반복)
-
-PoolV1, ShareVaultV1, StrategyVaultSteps에서 동일한 step 배열 빌드 → 순차 실행 → 콜백 패턴 반복.
-`core/tracker/step-runner.ts`로 추출.
-
-### ~~Message 빌더 반환 타입 (10회+ 반복)~~ → 제거됨
-
-Action 레이어를 제거했으므로 `TxMessage` 래핑 패턴도 불필요. Codec이 `Cell`을 반환하고, 호출 측에서 `{ to, value, body }` 인라인 조립.
-
-### Address 변환 (4회 반복)
-
-`toAddress()` 헬퍼가 `contracts/common/utils.ts`, `pool.ts`, `share-vault.ts`, `strategy_vault/base.ts`에 중복.
-`core/type.ts`로 통합.
-
----
-
-## 타입 정리
-
-### 중복 타입 통합
-
-| 타입 | 중복 위치 | 통합 위치 |
-|------|----------|----------|
-| `Maybe<T>` | `types/pool.ts`, `contracts/common/type.ts` | `core/type.ts` |
-| `AddressLike` | `contracts/common/type.ts`, 여러 파일 인라인 | `core/type.ts` |
-
-### 대형 Config 타입 분할
-
-`StrategyVaultConfig` (50+ 필드)를 논리적 하위 타입으로 분할: Ownership, State, FeeConfig, QueueConfig 등.
-
-### Cell | ParsedType 모호성 해결
-
-`irmConfig: Cell | JumpIRMConfig` 같은 union을 Raw 타입과 Parsed 타입으로 명확히 분리.
-
-### 네이밍 규칙 확립
-
-| 접미사 | 의미 |
-|--------|------|
-| `*Payload` | Jetton forward에 실리는 데이터 (Codec 산출물) |
-| `*MsgBody` | 직접 전송하는 메시지 본문 (Codec 산출물) |
-| `*Params` | SDK 함수에 전달하는 TypeScript 파라미터 (Codec 입력) |
-
-### 오타 수정
-
-- `TansferOutActionParams` → `TransferOutActionParams`
-- `traceActionNotificaitonTx` → `traceActionNotificationTx`
-- `LiquidateionNotificationFee` → `LiquidationNotificationFee`
-
----
-
-## 정리 작업
-
-- `utils/_parse_temp/` 폴더 삭제 (contracts/ codec.ts로 흡수 완료)
-- console.log 제거 (`utils/parser.ts`, `share-vault.ts`)
-- 주석 처리된 dead code 제거 (`utils/parser.ts`, `share-vault.ts`)
-
----
-
-## 최종 디렉토리 구조
-
-```
-src/
-├── contracts/                           ← 레벨 1: 컨트랙트별 (다른 컨트랙트를 모름)
-│   ├── core/
-│   │   ├── pool/
-│   │   │   ├── codec.ts               ← Codec + DictionaryValues
-│   │   │   ├── computation.ts          ← Computation: 시뮬레이션, Gas
-│   │   │   ├── constants.ts            ← Op, ErrorCodes, Gas
-│   │   │   ├── type.ts                 ← 타입 정의
-│   │   │   └── index.ts               ← Contract 클래스 (Query)
-│   │   └── account/
-│   │       ├── codec.ts
-│   │       ├── computation.ts          ← 지분 변환, delta
-│   │       ├── constants.ts
-│   │       ├── type.ts
-│   │       └── index.ts
-│   ├── vault/
-│   │   ├── share-vault/
-│   │   │   ├── codec.ts               ← Codec + DictionaryValues
-│   │   │   ├── computation.ts
-│   │   │   ├── constants.ts
-│   │   │   ├── type.ts
-│   │   │   └── index.ts
-│   │   └── strategy-vault/            ← ✅ codec 분리 완료
-│   │       ├── codec.ts               ← Codec + DictionaryValues (#region 섹션)
-│   │       ├── computation.ts
-│   │       ├── constants.ts
-│   │       ├── type.ts                 ← 분할된 Config 하위 타입
-│   │       └── index.ts
-│   ├── rfq/
-│   │   ├── auction/                    ← 동일 구조
-│   │   ├── batch/
-│   │   └── event-emitter/
-│   ├── jetton/
-│   ├── factory/
-│   └── wton/
-│
-├── core/                                ← 레벨 2: 도메인 횡단 (특정 도메인에 속하지 않음)
-│   ├── oracle/
-│   │   ├── redstone.ts                 ← Redstone 연동
-│   │   ├── oracle-params.ts            ← oracle params 빌드
-│   │   └── type.ts
-│   ├── tracker/
-│   │   ├── tx-finder.ts               ← 트랜잭션 탐색
-│   │   ├── step-runner.ts             ← Step 순차 실행 + 콜백
-│   │   ├── seqno-waiter.ts            ← wallet seqno 폴링 대기
-│   │   └── type.ts                    ← TxStep, StepCallback 등
-│   ├── risk-calculator/                ← 범용 Computation
-│   ├── contract-opener.ts             ← Contract 열기 + 캐시
-│   ├── cache.ts                        ← ContractCache + withCache
-│   └── type.ts                         ← Maybe, AddressLike, toAddress
-│
-├── services/                            ← 레벨 3: 도메인별 (contracts/ + core/ 조합)
-│   ├── pool/
-│   │   ├── index.ts                    ← Flow: 고수준 API
-│   │   ├── supply.ts                   ← Flow: supply 흐름
-│   │   ├── withdraw.ts                 ← Flow: withdraw 흐름
-│   │   ├── borrow.ts                   ← Flow: borrow 흐름
-│   │   ├── repay.ts                    ← Flow: repay 흐름
-│   │   ├── liquidate.ts               ← Flow: liquidate 흐름
-│   │   └── queries.ts                 ← 서비스 레벨 조회 (가격, 리스크 등)
-│   ├── share-vault/
-│   │   ├── index.ts                    ← Flow
-│   │   ├── supply.ts
-│   │   ├── withdraw.ts
-│   │   ├── manage.ts                  ← 매니저 액션 (supplyToPool, withdrawFromPool, setTargetWeight)
-│   │   └── queries.ts
-│   ├── strategy-vault/
-│   │   ├── index.ts                    ← Flow
-│   │   ├── deposit.ts
-│   │   ├── withdraw.ts
-│   │   ├── queue.ts                   ← deposit/withdraw queue
-│   │   ├── owner.ts                   ← owner/guardian/manager 설정
-│   │   └── queries.ts
-│   ├── rfq-auction/
-│   │   └── index.ts                    ← Flow (단일 파일)
-│   └── rfq-batch/
-│       └── index.ts                    ← Flow (단일 파일)
-│
-├── types/                               ← 공개 타입
-├── constants/                           ← 전역 상수
-├── _compiled/                           ← 컴파일된 바이너리
-└── index.ts                             ← 배럴 export
-```
-
----
-
-## 실행 순서
-
-| 순서 | 내용 | 대상 레벨 | 상태 |
-|------|------|----------|------|
-| 1 | 정리 (console.log, dead code, 오타) | 전체 | |
-| 2 | 타입 중복 제거, 네이밍 정리 | 전체 | |
-| 3 | contracts/ Codec 분리 | contracts/ | **strategy-vault ✅** |
-| 4 | contracts/ Computation 분리 | contracts/ | |
-| 5 | contracts/ index.ts 정리 (Query만 잔류) | contracts/ | |
-| 6 | core/ 모듈 추출 (Oracle, Tracker, ContractOpener) | core/ | |
-| 7 | services/ 재구성 (상속 제거, Flow 조합) | services/ | |
-
-아래에서 위로. contracts/ (I/O 없는 Codec, Computation) → core/ (도메인 횡단 인프라) → services/ (Flow 조합).
-
----
-
-## 진행 기록
-
-### strategy-vault Codec 분리 (완료)
-
-**변경 내용:**
-- 28개 파일 (`codec/` 디렉토리) + `parser.ts` + `dictionary.ts` → 단일 `codec.ts`로 병합 (~1270줄)
-- `#region` 섹션으로 구분: Dictionary Values, Storage, Utility, Message-Owner, Message-Manager, Message-User
-- `action/` 디렉토리 전체 삭제 — `{ to, value, body }` 래핑만 하는 함수들은 불필요한 추상화
-- `serializer.ts` (레거시) 삭제
-
-**결과 구조:**
-```
-contracts/vault/strategy-vault/
-├── codec.ts       ← 1270줄, #region 섹션
-├── constants.ts
-├── type.ts
-└── index.ts       ← StrategyVault 클래스 (Query + static re-exports)
-```
-
-**설계 판단:**
-- codec은 단순 serialize/parse 리스트이므로 파일이 길어도 문제 없음. 한번 만들면 고정이고, 수정해도 단일 액션
-- 파일 분할 기준은 "독립적으로 변경 가능한 단위"이지 "줄 수"가 아님
-- DictionaryValues도 codec 안에 포함 — 별도 파일 불필요
-
----
-
-### CompositeOracle 리팩토링 (완료)
-
-**문제점:**
-- `strategy-vault/oracle.ts`에 가격 계산 로직이 중복 존재 (487줄)
-- `composite-oracle/`와 동일한 가격 계산 함수들이 분산되어 있음
-- `getOracleParams`(온체인 Cell 생성)와 `CompositeOracle`(오프체인 가격 계산)이 같은 데이터를 각각 따로 fetch
-
-**핵심 원칙: I/O와 Computation 분리**
-```
-┌─────────────────────────────────────────────────────────┐
-│                    services/ 레이어                      │
-├─────────────────────────────────────────────────────────┤
-│  CompositeOracle (가격 계산)   StrategyVault (트랜잭션)    │
-│         │                           │                    │
-│         ▼                           ▼                    │
-│  ┌─────────────────────────────────────────────┐        │
-│  │           getOracleContext()                │        │
-│  │         (공유 데이터 fetch)                  │        │
-│  └─────────────────────────────────────────────┘        │
-│         │                           │                    │
-│         ▼                           ▼                    │
-│   compute() ← 순수 함수       getOracleParamsV2()        │
-│   (가격 계산)                  (Cell 생성)                │
-└─────────────────────────────────────────────────────────┘
-```
-
-**변경 내용:**
-
-1. **getOracleContext() 공유 메서드 생성** (`composite-oracle/fetcher.ts`)
-   - vault 데이터, oracle config, 자산 목록, 포지션 등을 한 번에 fetch
-   - On-chain Cell 생성과 Off-chain 가격 계산 모두 동일 context 사용
-
-2. **strategy-vault/oracle.ts 대폭 축소** (487줄 → 107줄)
-   - 중복된 가격 계산 함수 모두 제거: `getAssetPrice`, `calcVaultPrice`, `computeAssetPrices` 등
-   - `getOracleParamsV2`만 남김 — CompositeOracle의 `getOracleContext()` 사용
-
-3. **StrategyVaultV1 가격 메서드 위임** (`services/strategy-vault/index.ts`)
-   - `getVaultPrice()`, `getTotalValue()`, `getAllAssetPrices()` → CompositeOracle 호출로 변경
-
-**결과 구조:**
-```
-services/
-├── composite-oracle/
-│   ├── fetcher.ts        ← getOracleContext() 공유 메서드 추가
-│   ├── computation.ts    ← 순수 가격 계산 (I/O 없음)
-│   └── index.ts          ← fetchAll(), compute(), static helpers
-├── strategy-vault/
-│   ├── oracle.ts         ← 107줄로 축소 (getOracleParamsV2만)
-│   └── index.ts          ← 가격 메서드는 CompositeOracle 위임
-```
-
-**설계 판단:**
-- **"Fetch once, compute multiple times"**: 데이터는 한 번만 fetch하고, 계산은 여러 번 재사용
-- **On-chain vs Off-chain 분리**:
-  - On-chain: `getOracleParamsV2()` → Cell 생성 (트랜잭션에 사용)
-  - Off-chain: `compute()` → 가격 계산 (조회에 사용)
-- **Static 메서드 제공**: 캐시된 input으로 재계산 가능 (`getVaultPriceFromInput`, `getTotalValueFromInput`)
-
-**테스트 결과:**
-- mainnet 테스트 7개 항목 모두 통과
-- fork 테스트 9개 항목 모두 통과