@augustdigital/sdk 9.8.0 → 9.9.0

package/lib/services/layerzero/deposits.d.ts

@@ -9,6 +9,8 @@ export declare const LAYERZERO_VAULTS: {
         receiptToken: "coreusdc";
         decimals: number;
         hubChainId: number;
+        hubComposer: IAddress;
+        hubShareOFT: IAddress;
         spokeChains: Record<number, IAddress>;
         subgraphEndpoints: string[];
     };
@@ -17,6 +19,8 @@ export declare const LAYERZERO_VAULTS: {
         receiptToken: "upusdc";
         decimals: number;
         hubChainId: number;
+        hubComposer: IAddress;
+        hubShareOFT: IAddress;
         spokeChains: Record<number, IAddress>;
         subgraphEndpoints: string[];
     };
@@ -25,6 +29,8 @@ export declare const LAYERZERO_VAULTS: {
         receiptToken: "earnausd";
         decimals: number;
         hubChainId: number;
+        hubComposer: IAddress;
+        hubShareOFT: IAddress;
         spokeChains: Record<number, IAddress>;
         subgraphEndpoints: string[];
     };

package/lib/services/layerzero/deposits.js

@@ -11,12 +11,16 @@ const fetcher_1 = require("../subgraph/fetcher");
 const utils_1 = require("./utils");
 // LayerZero vault addresses and their corresponding receipt tokens
 // spokeChains maps chainId -> shareOFT address (receipt token on that chain)
+// hubComposer / hubShareOFT: the hub-chain OVault composer (VAULT() is the
+// vault) and its SHARE_OFT(), verified on-chain 2026-10-01
 exports.LAYERZERO_VAULTS = {
     coreUSDC: {
         address: '0xE9B725010A9E419412ed67d0fA5f3A5f40159D32',
         receiptToken: 'coreusdc',
         decimals: 6, // USDC decimals
         hubChainId: 1,
+        hubComposer: '0xc2637d7721791cc9cb196628d1e5e06887b1d4b9',
+        hubShareOFT: '0x4A21dcbA38c3816C78144f33bb42D8fa17F38067',
         spokeChains: {
             42161: '0x50a31ff4d57841681011837c17aa201c6a34203c', // Arbitrum
             43114: '0x1FA931Bf85248aD2eDf0004DD9A284698358e708', // Avalanche
@@ -32,6 +36,8 @@ exports.LAYERZERO_VAULTS = {
         receiptToken: 'upusdc',
         decimals: 6, // USDC decimals
         hubChainId: 1,
+        hubComposer: '0xbe82134b95a8e9370e6759f3c8f44087cd9a52be',
+        hubShareOFT: '0x81971A3C359cFE74259CfF1b46FB5f2112ddDE34',
         spokeChains: {
             42161: '0x81971a3c359cfe74259cff1b46fb5f2112ddde34', // Arbitrum
             43114: '0x81971A3C359cFE74259CfF1b46FB5f2112ddDE34', // Avalanche
@@ -47,6 +53,8 @@ exports.LAYERZERO_VAULTS = {
         receiptToken: 'earnausd',
         decimals: 6,
         hubChainId: 143,
+        hubComposer: '0xd1b1b12533e12badb8ea6d63aedd11922cae5580',
+        hubShareOFT: '0x9549Fa3DF579Cca9F3e328695382675F7f1f0F34',
         spokeChains: {
             1: '0xa6916b65c5e3fEdf46c0a2F59bff776e872C8992', // Ethereum
         },

package/lib/services/subgraph/schema.d.ts

@@ -20,7 +20,9 @@ export declare function isSubgraphSchemaFieldError(errors: {
 }[] | undefined): boolean;
 /**
  * Detects whether a deployed subgraph uses the old or new field schema by probing
- * a single field (`blockTimestamp`) that exists only on the new template.
+ * a single field (`blockTimestamp`) that exists only on the new template, on
+ * `withdrawalRequesteds`, or on `transfers` for a receipt-token subgraph that
+ * has no `withdrawalRequesteds` entity.
  *
  * This replaces the previous heuristic — "vault symbol present in the deprecated
  * `SUBGRAPH_VAULT_URLS` map ⇒ old schema, else new" — which mis-guessed any
@@ -34,7 +36,8 @@ export declare function isSubgraphSchemaFieldError(errors: {
  * cached per URL ({@link SCHEMA_TTL_MS}); across a page's positions/history/
  * withdrawals reads this amounts to a single extra lightweight query per subgraph.
  *
- * Side effects: at most one HTTP POST to the subgraph per URL per TTL window.
+ * Side effects: at most two HTTP POSTs to the subgraph per URL per TTL window
+ * (the second only for a subgraph without `withdrawalRequesteds`).
  *
  * @param goldskyUrl - Fully-qualified subgraph GraphQL endpoint.
  * @param apiKey - Optional Goldsky API key sent as a Bearer token.

package/lib/services/subgraph/schema.js

@@ -18,9 +18,20 @@ const SCHEMA_TTL_MS = 60 * 60 * 1000; // 1 hour
 function isSubgraphSchemaFieldError(errors) {
     return Boolean(errors?.some((e) => e?.message?.includes('has no field')));
 }
+// GraphQL errors from querying `blockTimestamp` on one row of `entity`;
+// undefined on a non-200 response or a clean result.
+async function probeSchemaErrors(goldskyUrl, entity, apiKey) {
+    const result = await (0, fetcher_1.fetchSubgraph)(goldskyUrl, `{ ${entity}(first: 1) { blockTimestamp } }`, apiKey);
+    if (result.status !== 200)
+        return undefined;
+    const json = (await result.json());
+    return json?.errors;
+}
 /**
  * Detects whether a deployed subgraph uses the old or new field schema by probing
- * a single field (`blockTimestamp`) that exists only on the new template.
+ * a single field (`blockTimestamp`) that exists only on the new template, on
+ * `withdrawalRequesteds`, or on `transfers` for a receipt-token subgraph that
+ * has no `withdrawalRequesteds` entity.
  *
  * This replaces the previous heuristic — "vault symbol present in the deprecated
  * `SUBGRAPH_VAULT_URLS` map ⇒ old schema, else new" — which mis-guessed any
@@ -34,7 +45,8 @@ function isSubgraphSchemaFieldError(errors) {
  * cached per URL ({@link SCHEMA_TTL_MS}); across a page's positions/history/
  * withdrawals reads this amounts to a single extra lightweight query per subgraph.
  *
- * Side effects: at most one HTTP POST to the subgraph per URL per TTL window.
+ * Side effects: at most two HTTP POSTs to the subgraph per URL per TTL window
+ * (the second only for a subgraph without `withdrawalRequesteds`).
  *
  * @param goldskyUrl - Fully-qualified subgraph GraphQL endpoint.
  * @param apiKey - Optional Goldsky API key sent as a Bearer token.
@@ -53,15 +65,15 @@ async function resolveSubgraphSchema(goldskyUrl, apiKey) {
         // `blockTimestamp` is a new-schema-only field. If the subgraph rejects it
         // with an unknown-field error, the deployment is old-schema. Schema
         // validation is static, so this is authoritative even when the entity has
-        // zero rows.
-        const result = await (0, fetcher_1.fetchSubgraph)(goldskyUrl, `{ withdrawalRequesteds(first: 1) { blockTimestamp } }`, apiKey);
-        let schema = 'new';
-        if (result.status === 200) {
-            const json = (await result.json());
-            if (isSubgraphSchemaFieldError(json?.errors)) {
-                schema = 'old';
-            }
+        // zero rows. A receipt-token subgraph indexes only `transfers`, so when
+        // `withdrawalRequesteds` itself is unknown the probe moves to `transfers`.
+        let errors = await probeSchemaErrors(goldskyUrl, 'withdrawalRequesteds', apiKey);
+        if (errors?.some((e) => e?.message?.includes('has no field `withdrawalRequesteds`'))) {
+            errors = await probeSchemaErrors(goldskyUrl, 'transfers', apiKey);
         }
+        const schema = isSubgraphSchemaFieldError(errors)
+            ? 'old'
+            : 'new';
         core_1.CACHE.set(key, schema, { ttl: SCHEMA_TTL_MS });
         return schema;
     }

package/lib/services/subgraph/vaults.d.ts

@@ -1,4 +1,4 @@
-import type { IAddress, IContractRunner, ISubgraphTransfer, ISubgraphUserHistoryItem, ISubgraphWithdrawProccessed, ISubgraphWithdrawRequest } from '../../types';
+import type { IAddress, IContractRunner, ISubgraphReserveDeposit, ISubgraphTransfer, ISubgraphUserHistoryItem, ISubgraphWithdrawProccessed, ISubgraphWithdrawRequest } from '../../types';
 export declare function isOldSubgraphSchema(vaultSymbol: string): boolean;
 /**
  *
@@ -40,3 +40,25 @@ export declare function getSubgraphVaultHistory(provider: IContractRunner, pool:
 export declare function getSubgraphUserTransfers(user: IAddress, provider: IContractRunner, pool: IAddress, slackWebookUrl?: string, options?: {
     receiptSubgraph?: boolean;
 }): Promise<ISubgraphTransfer[]>;
+/**
+ * Fetch the `ReserveDeposit` events that minted vault shares to `user`.
+ *
+ * Some vaults mint shares without an ERC-4626 `Deposit` event: High Growth ETH
+ * emits `ReserveDeposit(account, shares, assets)` for deposits made through
+ * Kelp's gain adapter, so {@link getSubgraphUserHistory} never sees them. Its
+ * subgraph indexes the event as `reserveDeposits`.
+ *
+ * Side effects: one `getVaultSymbol` RPC read (cached), the vault metadata and
+ * schema probes (cached), and one subgraph query.
+ *
+ * @param user - The wallet the shares were minted to.
+ * @param provider - Contract runner for the vault's chain.
+ * @param pool - The vault contract address.
+ * @returns Up to 1000 events, oldest first. Empty when the vault's subgraph
+ *   has no `reserveDeposits` entity, has no URL, or the query fails.
+ * @example
+ * ```ts
+ * const reserveDeposits = await getSubgraphUserReserveDeposits(wallet, provider, vault);
+ * ```
+ */
+export declare function getSubgraphUserReserveDeposits(user: IAddress, provider: IContractRunner, pool: IAddress): Promise<ISubgraphReserveDeposit[]>;

package/lib/services/subgraph/vaults.js

@@ -7,6 +7,7 @@ exports.getSubgraphAllWithdrawals = getSubgraphAllWithdrawals;
 exports.getSubgraphUserHistory = getSubgraphUserHistory;
 exports.getSubgraphVaultHistory = getSubgraphVaultHistory;
 exports.getSubgraphUserTransfers = getSubgraphUserTransfers;
+exports.getSubgraphUserReserveDeposits = getSubgraphUserReserveDeposits;
 const ethers_1 = require("ethers");
 const slack_1 = require("../../core/logger/slack");
 const fetcher_1 = require("./fetcher");
@@ -1119,4 +1120,68 @@ async function getSubgraphUserTransfers(user, provider, pool, slackWebookUrl = (
         return [];
     }
 }
+/**
+ * Fetch the `ReserveDeposit` events that minted vault shares to `user`.
+ *
+ * Some vaults mint shares without an ERC-4626 `Deposit` event: High Growth ETH
+ * emits `ReserveDeposit(account, shares, assets)` for deposits made through
+ * Kelp's gain adapter, so {@link getSubgraphUserHistory} never sees them. Its
+ * subgraph indexes the event as `reserveDeposits`.
+ *
+ * Side effects: one `getVaultSymbol` RPC read (cached), the vault metadata and
+ * schema probes (cached), and one subgraph query.
+ *
+ * @param user - The wallet the shares were minted to.
+ * @param provider - Contract runner for the vault's chain.
+ * @param pool - The vault contract address.
+ * @returns Up to 1000 events, oldest first. Empty when the vault's subgraph
+ *   has no `reserveDeposits` entity, has no URL, or the query fails.
+ * @example
+ * ```ts
+ * const reserveDeposits = await getSubgraphUserReserveDeposits(wallet, provider, vault);
+ * ```
+ */
+async function getSubgraphUserReserveDeposits(user, provider, pool) {
+    try {
+        let vaultSymbol = await (0, core_1.getVaultSymbol)(pool, provider);
+        if (vaultSymbol === undefined)
+            return [];
+        const networkValue = await provider.provider.getNetwork();
+        if (needsMonadSuffix(Number(networkValue.chainId), vaultSymbol)) {
+            vaultSymbol = vaultSymbol.concat('_monad');
+        }
+        const vaultsMetadata = await (0, fetcher_2.fetchVaultMetadata)();
+        const { subgraph } = vaultsMetadata?.[vaultSymbol.toLowerCase()] || {};
+        const goldskyUrl = subgraph ||
+            core_1.SUBGRAPH_VAULT_URLS[vaultSymbol.toLowerCase()] ||
+            (0, core_1.getDefaultSubgraphUrl)(networkValue.name, vaultSymbol);
+        if (!goldskyUrl)
+            return [];
+        const useOldSchema = (await (0, schema_1.resolveSubgraphSchema)(goldskyUrl, GOLDSKY_API_KEY)) === 'old';
+        const props = useOldSchema
+            ? 'id account shares assets transactionHash_ timestamp_ block_number'
+            : 'id account shares assets transactionHash_: transactionHash timestamp_: blockTimestamp block_number: blockNumber';
+        const result = await (0, fetcher_1.fetchSubgraph)(goldskyUrl, `{
+        reserveDeposits(
+          first: 1000,
+          orderBy: ${useOldSchema ? 'timestamp_' : 'blockTimestamp'},
+          orderDirection: asc,
+          where: { account: "${user.toLowerCase()}" }
+        ) {
+          ${props}
+        }
+      }`, GOLDSKY_API_KEY);
+        if (result.status !== 200)
+            return [];
+        const json = (await result.json());
+        if (json.errors?.length && !(0, schema_1.isSubgraphSchemaFieldError)(json.errors)) {
+            core_1.Logger.log.warn('getSubgraphUserReserveDeposits', `${pool}::${JSON.stringify(json.errors).slice(0, 200)}`);
+        }
+        return json.data?.reserveDeposits ?? [];
+    }
+    catch (e) {
+        core_1.Logger.log.warn('getSubgraphUserReserveDeposits', `${pool}::${e}`);
+        return [];
+    }
+}
 //# sourceMappingURL=vaults.js.map

package/lib/types/subgraph.d.ts

@@ -67,6 +67,16 @@ export interface ISubgraphWithdraw extends ISubgraphBase {
     sender: string;
     assets: string;
 }
+/**
+ * A `ReserveDeposit(account, shares, assets)` event: a deposit that mints
+ * shares to `account` without an ERC-4626 `Deposit` event. High Growth ETH
+ * emits it for deposits made through Kelp's gain adapter.
+ */
+export interface ISubgraphReserveDeposit extends ISubgraphBase {
+    account: IAddress;
+    shares: string;
+    assets: string;
+}
 export interface ISubgraphTransfer extends ISubgraphBase {
     from: IAddress;
     to: IAddress;

package/lib/types/vaults.d.ts

@@ -459,6 +459,17 @@ export interface IVaultUserLifetimePnl {
     lifetimePnl: INormalizedNumber;
     lifetimePnlUsd: number;
     pnlPercentage: number;
+    /**
+     * The part of `totalDeposited` that is shares the wallet received from
+     * another holder (a migration airdrop, a DEX purchase, a transfer from
+     * another wallet), valued at the vault's share ratio on the day each
+     * arrived. Zero when no such shares counted. Optional only so objects built
+     * before it existed still type-check; `getVaultUserLifetimePnl` always sets
+     * it.
+     */
+    receivedByTransfer?: INormalizedNumber;
+    /** `receivedByTransfer` in USD, at the same price as the other USD fields. */
+    receivedByTransferUsd?: number;
 }
 export interface IVaultPnl {
     totalPnl: INormalizedNumber;
@@ -636,7 +647,11 @@ export interface ISwapRouterBaseOptions {
     receiver: IAddress;
     /**
      * 32-byte origin/referral code registered via `addOrigin`. Drives the
-     * origin-fee accrual. Defaults to {@link ORIGIN_CODES.default} when omitted.
+     * origin-fee accrual. Defaults to the SDK instance's `attribution.originCode`
+     * when omitted on Ethereum mainnet, else {@link ORIGIN_CODES.default}. A code
+     * passed here that is not registered throws before any approval; an
+     * unregistered instance code falls back to the sentinel with an
+     * `attribution-skipped` warning (or throws under `attribution.strictOrigin`).
      */
     originCode?: `0x${string}`;
     /** When `true`, the helper awaits a single confirmation before returning. */
@@ -675,11 +690,10 @@ export interface ISwapRouterNativeDepositOptions extends ISwapRouterBaseOptions
  * on-chain, then picks the correct router path from `depositAsset`, so callers
  * do not hand-build swap legs or pre-resolve decimals themselves.
  *
- * Prefer this over relying on the implicit routing inside `vaultDeposit`: here
- * the caller opts into the SwapRouter deliberately, so a vault is never
- * silently routed through a swap it does not need — the failure mode that broke
- * native multi-asset deposits when a multi-asset vault was added to
- * `VAULTS_USING_SWAP_ROUTER`.
+ * `vaultDeposit` never swaps; this is the explicit, opt-in entry point for
+ * swap deposits, so a vault is never silently routed through a swap it does
+ * not need — the failure mode that broke native multi-asset deposits when
+ * `vaultDeposit` still auto-routed allowlisted vaults.
  *
  * Unlike {@link ISwapRouterBaseOptions}, `receiver` is optional here and
  * defaults to the signer's resolved EOA.
@@ -717,6 +731,24 @@ export interface ISwapRouterDepositResultOptions {
     /** The vault that was deposited into — isolates its own `Deposit` event from the router's unrelated logs. */
     vault: IAddress;
 }
+/** Options for {@link getOriginInfo}. */
+export interface IGetOriginInfoOptions {
+    /** EVM chain ID whose `SwapRouter` to read. */
+    chainId: number;
+    /** The `bytes32` origin code, `0x` + 64 hex chars. */
+    originCode: `0x${string}`;
+    /** RPC endpoint for `chainId`. */
+    rpcUrl: string;
+}
+/** A SwapRouter origin code's registration, from `origins(bytes32)`. */
+export interface IOriginInfo {
+    /** `true` when registered via `addOrigin` and not revoked (non-zero collector). */
+    registered: boolean;
+    /** Origin fee in basis points; `0` for an attribution-only code. */
+    originFeeBps: number;
+    /** Fee recipient; the zero address when the code is not registered. */
+    collector: IAddress;
+}
 /**
  * Real, on-chain outcome of a SwapRouter deposit, decoded from the vault's own
  * `Deposit` event (the SwapRouter contract itself emits no deposit/amount-out

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@augustdigital/sdk",
-  "version": "9.8.0",
+  "version": "9.9.0",
   "main": "lib/index.js",
   "types": "lib/sdk.d.ts",
   "keywords": [