@upshiftfinance/sdk 0.1.0 → 0.2.0

package/README.md

@@ -25,9 +25,9 @@ The SDK automatically converts viem `WalletClient` to an ethers-compatible signe
 ## Quick Start
 
 ```typescript
-import AugustSDK from '@upshiftfinance/sdk';
+import UpshiftSDK from '@upshiftfinance/sdk';
 
-const sdk = new AugustSDK({
+const sdk = new UpshiftSDK({
   // Required: stable kebab-case slug identifying your application.
   appName: 'acme-trader',
   providers: {
@@ -36,7 +36,7 @@ const sdk = new AugustSDK({
     -1: 'https://api.mainnet-beta.solana.com', // Solana
   },
   keys: {
-    august: 'YOUR_API_KEY', // Optional: vault reads, allocations and vault-linked sub-account reads work without it
+    upshift: 'YOUR_API_KEY', // Optional: vault reads, allocations and vault-linked sub-account reads work without it
   },
   monitoring: {
     env: 'DEV', // Optional: 'DEV' enables console logging (defaults to 'PROD')
@@ -61,10 +61,10 @@ const positions = await sdk.getVaultPositions({
 
 ### App Name
 
-`appName` is required on every `AugustSDK` constructor call. Pass a stable kebab-case slug
+`appName` is required on every `UpshiftSDK` constructor call. Pass a stable kebab-case slug
 identifying your application (e.g. `'acme-trader'`, `'my-defi-app'`):
 
-- **What it's used for.** August Digital tags analytics events with `app.name = <yourSlug>` to
+- **What it's used for.** Upshift tags analytics events with `app.name = <yourSlug>` to
   attribute error spikes and prioritize bug fixes by consuming app.
 - **What it is not.** Not a secret, not a license key, not a display label. Pick a slug once
   and reuse it across deployments.
@@ -73,13 +73,13 @@ identifying your application (e.g. `'acme-trader'`, `'my-defi-app'`):
 
 ```typescript
 // Will throw — appName is required.
-new AugustSDK({ providers: { /* ... */ } } as any);
+new UpshiftSDK({ providers: { /* ... */ } } as any);
 
 // Will throw — spaces not allowed. Use 'acme-trader'.
-new AugustSDK({ appName: 'Acme Trader', providers: { /* ... */ } });
+new UpshiftSDK({ appName: 'Acme Trader', providers: { /* ... */ } });
 
 // Correct.
-new AugustSDK({ appName: 'acme-trader', providers: { /* ... */ } });
+new UpshiftSDK({ appName: 'acme-trader', providers: { /* ... */ } });
 ```
 
 ### Origin-Code Attribution (SwapRouter)
@@ -88,7 +88,7 @@ An integrator with an origin (referral / fee-sharing) code registered on the Swa
 SDK instance. Deposits made through the SDK then carry it on-chain:
 
 ```typescript
-const sdk = new AugustSDK({
+const sdk = new UpshiftSDK({
   appName: 'acme-trader',
   providers: { 1: 'https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY' },
   attribution: {
@@ -120,10 +120,10 @@ const { registered, originFeeBps, collector } = await sdk.getOriginInfo({
   `vaultDeposit` takes the vault's native path and logs
   `vaultDeposit:attribution-skipped` with the reason (Sentry tag `sdk.attribution.origin=skipped`). The router
   methods send the zero sentinel for an unregistered instance code and log `<method>:attribution-skipped`.
-  With `strictOrigin: true` an unregistered instance code throws `AugustValidationError` before any approval
+  With `strictOrigin: true` an unregistered instance code throws `UpshiftValidationError` before any approval
   instead; a paused router falls back to native even then. An `originCode` passed to a router method that is
-  not registered always throws `AugustValidationError` before any approval. While the router is paused, the
-  router methods throw `AugustSDKError` (`context.reason: 'router-paused'`) before any approval.
+  not registered always throws `UpshiftValidationError` before any approval. While the router is paused, the
+  router methods throw `UpshiftSDKError` (`context.reason: 'router-paused'`) before any approval.
 - **Approve `route.spender`, not the vault.** A routed deposit is pulled by the SwapRouter. `vaultDeposit` and
   `approve` handle this; if you send approvals yourself, read the spender first:
 
@@ -138,14 +138,14 @@ const { registered, originFeeBps, collector } = await sdk.getOriginInfo({
 - **Zero-fee codes.** A code registered with a 0 bps fee is valid for attribution only, but the router emits no
   `OriginFeeApplied` event for it. Its deposits are attributable only from the transaction calldata and SDK
   telemetry.
-- **Process-global.** `attribution` is process-global: the last `AugustSDK` constructed wins, and one
+- **Process-global.** `attribution` is process-global: the last `UpshiftSDK` constructed wins, and one
   constructed without `attribution` clears it. Run one attribution configuration per process.
 
 ## Architecture
 
 ```
 src.ts/
-├── main.ts              # Main SDK class (AugustSDK)
+├── main.ts              # Main SDK class (UpshiftSDK)
 ├── core/                # Base utilities
 │   ├── base.class.ts    # Base SDK functionality
 │   ├── fetcher.ts       # API client with retry logic
@@ -159,7 +159,7 @@ src.ts/
 ├── modules/             # Feature modules
 │   ├── vaults/          # Vault read operations
 │   ├── sub-accounts/    # Sub-account queries
-│   └── api/             # August backend API integration
+│   └── api/             # Upshift backend API integration
 ├── services/            # External service integrations
 │   ├── debank/          # DeFi allocation data
 │   ├── coingecko/       # Token pricing
@@ -339,7 +339,7 @@ if (walletClient) sdk.evm.setSigner(walletClient);
 | --- | --- |
 | `isSuiAddress(address)` | Whether a string is a Sui address / object ID (`0x` + 64 hex) |
 | `isSuiVault(chainId)` | Whether a chain ID is Sui's (`-2`) |
-| `network`, `rpcUrl` | The `sui` config passed to `new AugustSDK({ sui })` |
+| `network`, `rpcUrl` | The `sui` config passed to `new UpshiftSDK({ sui })` |
 
 ## Code Conventions
 
@@ -359,17 +359,17 @@ Search the codebase for these to find important areas:
 
 ### Error Handling
 
-Every public method throws typed errors that subclass `AugustSDKError`:
+Every public method throws typed errors that subclass `UpshiftSDKError`:
 
 ```typescript
-import { AugustValidationError, AugustTimeoutError, AugustSDKError } from '@upshiftfinance/sdk';
+import { UpshiftValidationError, UpshiftTimeoutError, UpshiftSDKError } from '@upshiftfinance/sdk';
 
 try {
   await sdk.evm.vaultDeposit({ target: '0x...', wallet: owner, amount: '1' });
 } catch (err) {
-  if (err instanceof AugustValidationError) showFormError(err.message);
-  else if (err instanceof AugustTimeoutError) scheduleRetry(err.timeoutMs);
-  else if (err instanceof AugustSDKError) reportError(err.code, err.cause);
+  if (err instanceof UpshiftValidationError) showFormError(err.message);
+  else if (err instanceof UpshiftTimeoutError) scheduleRetry(err.timeoutMs);
+  else if (err instanceof UpshiftSDKError) reportError(err.code, err.cause);
   else throw err;
 }
 ```
@@ -382,10 +382,10 @@ try {
 
 ```typescript
 // Development mode — enables console logging
-const sdk = new AugustSDK({ appName: 'my-app', providers: { /* ... */ }, monitoring: { env: 'DEV' } });
+const sdk = new UpshiftSDK({ appName: 'my-app', providers: { /* ... */ }, monitoring: { env: 'DEV' } });
 
 // Production mode — default, no console logs
-const sdk = new AugustSDK({ appName: 'my-app', providers: { /* ... */ } });
+const sdk = new UpshiftSDK({ appName: 'my-app', providers: { /* ... */ } });
 ```
 
 ## Development

package/lib/adapters/sui/client.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Sui gRPC client factory with endpoint failover.
+ *
+ * Sui removed JSON-RPC (Sui v1.82), so the SDK talks to fullnodes over gRPC.
+ * It uses gRPC-web — `@mysten/sui`'s `SuiGrpcClient` — so one code path works
+ * in browsers and Node.js.
+ *
+ * `@mysten/sui` is ESM-only and this SDK is published as CommonJS. The module
+ * is loaded on first use, not when the SDK is imported, so importing the SDK
+ * never requires it. That keeps Jest (which cannot `require` an ES module) and
+ * other CommonJS test runners working for integrators that never call Sui.
+ *
+ * @module SuiClient
+ */
+import type { SuiGrpcClient } from '@mysten/sui/grpc';
+import type { ISuiConfig, ISuiNetwork } from '../../types';
+/** Network and ordered endpoints for Sui calls: primary first, failover after. */
+export interface ISuiNetworkConfig {
+    network: ISuiNetwork;
+    /** gRPC-web endpoints in priority order. */
+    rpcUrls: readonly string[];
+}
+/**
+ * Resolve the network and ordered endpoints for a Sui config.
+ *
+ * A consumer `rpcUrl` becomes the primary, with the public fullnode kept behind
+ * it as failover, so a premium provider still degrades to the public network
+ * instead of becoming a single point of failure.
+ *
+ * @param config - The `sui` config passed to `new UpshiftSDK({ sui })`.
+ * @returns The network (`'mainnet'` by default) and its endpoints.
+ */
+export declare function resolveSuiNetworkConfig(config?: ISuiConfig): ISuiNetworkConfig;
+/**
+ * Host-only view of an endpoint, safe for logs and errors: keyed provider URLs
+ * carry their key in the path.
+ * @internal
+ */
+export declare function suiEndpointHost(url: string): string;
+/**
+ * Whether an error from a Sui call means the endpoint failed and the next one
+ * should be tried.
+ *
+ * @param err - What the call rejected with.
+ * @returns `true` for transport failures, gRPC statuses in
+ *   {@link RETRYABLE_GRPC_CODES}, a bare `NOT_FOUND` (the endpoint has no Sui
+ *   gRPC service at that path) and the SDK's own call timeout.
+ * @internal
+ */
+export declare function isRetryableSuiError(err: unknown): boolean;
+type SuiClientFactory = (baseUrl: string, network: ISuiNetwork) => Promise<SuiGrpcClient>;
+/**
+ * Replace the client factory and clear the caches. Test-only seam.
+ * @internal
+ */
+export declare function setSuiClientFactoryForTests(factory: SuiClientFactory | undefined): void;
+/**
+ * Run a Sui call against the first endpoint that answers.
+ *
+ * Endpoints are tried in order, starting with the one that last worked (for
+ * {@link PREFERRED_ENDPOINT_TTL_MS}). An endpoint failure — see
+ * {@link isRetryableSuiError} — moves on to the next endpoint; any other error
+ * is thrown at once. Each attempt is bounded by a 15 s timeout.
+ *
+ * Worst case: one attempt per endpoint (two with a consumer `rpcUrl`).
+ *
+ * @param config - Network and endpoints from {@link resolveSuiNetworkConfig}.
+ * @param call - The call to make with a client; it may run more than once, so
+ *   it must not have side effects before its RPC completes.
+ * @returns What `call` resolves to.
+ * @throws {@link UpshiftNetworkError} when every endpoint fails, naming their
+ *   hosts (never their full URLs); the last failure is the `cause`.
+ * @throws Whatever `call` throws for a non-endpoint error.
+ * @example
+ * ```ts
+ * const config = resolveSuiNetworkConfig({ network: 'testnet' });
+ * const { object } = await withSuiClient(config, (client) =>
+ *   client.core.getObject({ objectId: vaultId }),
+ * );
+ * ```
+ */
+export declare function withSuiClient<T>(config: ISuiNetworkConfig, call: (client: SuiGrpcClient) => Promise<T>): Promise<T>;
+export {};

package/lib/adapters/sui/client.js

@@ -0,0 +1,216 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSuiNetworkConfig = resolveSuiNetworkConfig;
+exports.suiEndpointHost = suiEndpointHost;
+exports.isRetryableSuiError = isRetryableSuiError;
+exports.setSuiClientFactoryForTests = setSuiClientFactoryForTests;
+exports.withSuiClient = withSuiClient;
+const logger_1 = require("../../core/logger");
+const errors_1 = require("../../core/errors");
+const concurrency_1 = require("../../core/helpers/concurrency");
+const constants_1 = require("./constants");
+/** Bound on one Sui call, so a hung endpoint fails over instead of blocking. */
+const SUI_CALL_TIMEOUT_MS = 15_000;
+/** How long a working endpoint is tried first before the order resets. */
+const PREFERRED_ENDPOINT_TTL_MS = 30_000;
+/**
+ * gRPC status codes that mean the endpoint, not the request, failed: the next
+ * endpoint may succeed. `fetch failed` (refused connection, DNS) arrives as
+ * `INTERNAL`; a provider that does not serve gRPC-web answers `UNAUTHENTICATED`
+ * or similar. Request errors such as `INVALID_ARGUMENT` would fail the same way
+ * everywhere, so they are thrown at once.
+ */
+const RETRYABLE_GRPC_CODES = new Set([
+    'INTERNAL',
+    'UNAVAILABLE',
+    'UNKNOWN',
+    'DEADLINE_EXCEEDED',
+    'RESOURCE_EXHAUSTED',
+    'UNAUTHENTICATED',
+    'PERMISSION_DENIED',
+    'UNIMPLEMENTED',
+]);
+/**
+ * Resolve the network and ordered endpoints for a Sui config.
+ *
+ * A consumer `rpcUrl` becomes the primary, with the public fullnode kept behind
+ * it as failover, so a premium provider still degrades to the public network
+ * instead of becoming a single point of failure.
+ *
+ * @param config - The `sui` config passed to `new UpshiftSDK({ sui })`.
+ * @returns The network (`'mainnet'` by default) and its endpoints.
+ */
+function resolveSuiNetworkConfig(config = {}) {
+    const network = config.network ?? 'mainnet';
+    const publicUrl = constants_1.SUI_GRPC_URLS[network];
+    const override = config.rpcUrl?.trim();
+    const rpcUrls = override && override !== publicUrl ? [override, publicUrl] : [publicUrl];
+    return { network, rpcUrls };
+}
+/**
+ * Host-only view of an endpoint, safe for logs and errors: keyed provider URLs
+ * carry their key in the path.
+ * @internal
+ */
+function suiEndpointHost(url) {
+    try {
+        return new URL(url).host;
+    }
+    catch {
+        return '<invalid url>';
+    }
+}
+/**
+ * Whether an error from a Sui call means the endpoint failed and the next one
+ * should be tried.
+ *
+ * @param err - What the call rejected with.
+ * @returns `true` for transport failures, gRPC statuses in
+ *   {@link RETRYABLE_GRPC_CODES}, a bare `NOT_FOUND` (the endpoint has no Sui
+ *   gRPC service at that path) and the SDK's own call timeout.
+ * @internal
+ */
+function isRetryableSuiError(err) {
+    if (!(err instanceof Error))
+        return false;
+    if (err.message.startsWith('sui call timed out'))
+        return true;
+    if (err.name !== 'RpcError')
+        return false;
+    const code = err.code;
+    if (typeof code !== 'string')
+        return false;
+    if (RETRYABLE_GRPC_CODES.has(code))
+        return true;
+    // A path with no gRPC service answers HTTP 404, which the transport reports
+    // as NOT_FOUND with no message; a missing object is a different error type.
+    return code === 'NOT_FOUND' && err.message === '';
+}
+/** Default factory: loads `@mysten/sui/grpc` on first use. */
+const defaultClientFactory = async (baseUrl, network) => {
+    const { SuiGrpcClient } = await Promise.resolve().then(() => __importStar(require('@mysten/sui/grpc')));
+    return new SuiGrpcClient({ baseUrl, network });
+};
+let clientFactory = defaultClientFactory;
+const clientCache = new Map();
+const preferredEndpoint = new Map();
+/**
+ * Replace the client factory and clear the caches. Test-only seam.
+ * @internal
+ */
+function setSuiClientFactoryForTests(factory) {
+    clientFactory = factory ?? defaultClientFactory;
+    clientCache.clear();
+    preferredEndpoint.clear();
+}
+function clientFor(url, network) {
+    const key = `${network}|${url}`;
+    let client = clientCache.get(key);
+    if (!client) {
+        client = clientFactory(url, network);
+        clientCache.set(key, client);
+        // A failed construction must not be cached forever.
+        client.catch(() => clientCache.delete(key));
+    }
+    return client;
+}
+/**
+ * Run a Sui call against the first endpoint that answers.
+ *
+ * Endpoints are tried in order, starting with the one that last worked (for
+ * {@link PREFERRED_ENDPOINT_TTL_MS}). An endpoint failure — see
+ * {@link isRetryableSuiError} — moves on to the next endpoint; any other error
+ * is thrown at once. Each attempt is bounded by a 15 s timeout.
+ *
+ * Worst case: one attempt per endpoint (two with a consumer `rpcUrl`).
+ *
+ * @param config - Network and endpoints from {@link resolveSuiNetworkConfig}.
+ * @param call - The call to make with a client; it may run more than once, so
+ *   it must not have side effects before its RPC completes.
+ * @returns What `call` resolves to.
+ * @throws {@link UpshiftNetworkError} when every endpoint fails, naming their
+ *   hosts (never their full URLs); the last failure is the `cause`.
+ * @throws Whatever `call` throws for a non-endpoint error.
+ * @example
+ * ```ts
+ * const config = resolveSuiNetworkConfig({ network: 'testnet' });
+ * const { object } = await withSuiClient(config, (client) =>
+ *   client.core.getObject({ objectId: vaultId }),
+ * );
+ * ```
+ */
+async function withSuiClient(config, call) {
+    const cacheKey = `${config.network}|${config.rpcUrls.join('|')}`;
+    const preferred = preferredEndpoint.get(cacheKey);
+    const order = preferred && Date.now() - preferred.at < PREFERRED_ENDPOINT_TTL_MS
+        ? [preferred.url, ...config.rpcUrls.filter((u) => u !== preferred.url)]
+        : [...config.rpcUrls];
+    let lastError;
+    for (const url of order) {
+        let client;
+        try {
+            client = await clientFor(url, config.network);
+        }
+        catch (err) {
+            // A malformed endpoint (e.g. a typo'd consumer rpcUrl) must not disable
+            // the endpoints behind it.
+            lastError = err;
+            logger_1.Logger.log.warn('withSuiClient', 'Invalid Sui endpoint; trying next', {
+                host: suiEndpointHost(url),
+            });
+            continue;
+        }
+        try {
+            const result = await (0, concurrency_1.withTimeout)(call(client), SUI_CALL_TIMEOUT_MS, 'sui call');
+            preferredEndpoint.set(cacheKey, { url, at: Date.now() });
+            return result;
+        }
+        catch (err) {
+            if (!isRetryableSuiError(err))
+                throw err;
+            lastError = err;
+            logger_1.Logger.log.warn('withSuiClient', 'Sui endpoint failed; trying next', {
+                host: suiEndpointHost(url),
+                code: err.code,
+            });
+        }
+    }
+    preferredEndpoint.delete(cacheKey);
+    throw new errors_1.UpshiftNetworkError(`Every Sui ${config.network} endpoint failed: ${order
+        .map(suiEndpointHost)
+        .join(', ')}`, { cause: lastError, context: { network: config.network } });
+}
+//# sourceMappingURL=client.js.map

package/lib/adapters/sui/constants.d.ts

@@ -1 +1,33 @@
+import type { ISuiNetwork } from '../../types';
 export { SUI_CHAIN_ID } from '../../core/constants/web3';
+/** Sui's shared `Clock` system object, passed to time-dependent vault calls. */
+export declare const SUI_CLOCK_ID = "0x6";
+/** Sui's shared `CoinRegistry` system object (coin metadata / currencies). */
+export declare const SUI_COIN_REGISTRY_ID = "0xc";
+/**
+ * Mysten's public fullnodes, which serve gRPC-web. The SDK talks gRPC-web so
+ * the same code runs in browsers; a consumer `rpcUrl` goes in front of these as
+ * the primary (see `resolveSuiNetworkConfig`).
+ */
+export declare const SUI_GRPC_URLS: Record<ISuiNetwork, string>;
+/**
+ * IDs of the deployed Upshift vault contracts on one Sui network.
+ *
+ * `packageId` is the latest published package (what move calls target);
+ * `originalPackageId` is the first published one, which Move keeps in type
+ * names across upgrades, so it names the vault's on-chain type.
+ */
+export interface ISuiVaultContracts {
+    /** Latest `upshift_vault` package ID; move-call targets use it. */
+    packageId: string;
+    /** Original `upshift_vault` package ID; vault and key types use it. */
+    originalPackageId: string;
+    /** Shared `upshift_vault::registry::Registry` object ID. */
+    registryId: string;
+}
+/**
+ * Built-in contract IDs per network. Empty until the contracts are published
+ * there: until then callers pass `packageId`, `originalPackageId` and
+ * `registryId` through `new UpshiftSDK({ sui })`.
+ */
+export declare const SUI_VAULT_CONTRACTS: Record<ISuiNetwork, Partial<ISuiVaultContracts>>;

package/lib/adapters/sui/constants.js

@@ -1,9 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SUI_CHAIN_ID = void 0;
+exports.SUI_VAULT_CONTRACTS = exports.SUI_GRPC_URLS = exports.SUI_COIN_REGISTRY_ID = exports.SUI_CLOCK_ID = exports.SUI_CHAIN_ID = void 0;
 // Canonical definition lives in `core/constants/web3.ts` so `core/` can
 // recognise the Sui chain ID without importing the adapter layer. Re-exported
 // here to keep `adapters/sui/constants` import sites unchanged.
 var web3_1 = require("../../core/constants/web3");
 Object.defineProperty(exports, "SUI_CHAIN_ID", { enumerable: true, get: function () { return web3_1.SUI_CHAIN_ID; } });
+/** Sui's shared `Clock` system object, passed to time-dependent vault calls. */
+exports.SUI_CLOCK_ID = '0x6';
+/** Sui's shared `CoinRegistry` system object (coin metadata / currencies). */
+exports.SUI_COIN_REGISTRY_ID = '0xc';
+/**
+ * Mysten's public fullnodes, which serve gRPC-web. The SDK talks gRPC-web so
+ * the same code runs in browsers; a consumer `rpcUrl` goes in front of these as
+ * the primary (see `resolveSuiNetworkConfig`).
+ */
+exports.SUI_GRPC_URLS = {
+    mainnet: 'https://fullnode.mainnet.sui.io:443',
+    testnet: 'https://fullnode.testnet.sui.io:443',
+};
+/**
+ * Built-in contract IDs per network. Empty until the contracts are published
+ * there: until then callers pass `packageId`, `originalPackageId` and
+ * `registryId` through `new UpshiftSDK({ sui })`.
+ */
+exports.SUI_VAULT_CONTRACTS = {
+    mainnet: {},
+    testnet: {},
+};
 //# sourceMappingURL=constants.js.map

package/lib/adapters/sui/index.d.ts

@@ -4,11 +4,15 @@
  * @module SuiAdapter
  */
 import type { ISuiConfig, ISuiNetwork } from '../../types';
+import * as SuiClient from './client';
 import * as SuiConstants from './constants';
+import * as SuiTargets from './targets';
 import * as SuiUtils from './utils';
 export declare const Sui: {
     utils: typeof SuiUtils;
     constants: typeof SuiConstants;
+    client: typeof SuiClient;
+    targets: typeof SuiTargets;
 };
 /**
  * Sui Adapter for Upshift SDK.

package/lib/adapters/sui/index.js

@@ -34,11 +34,15 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Sui = void 0;
+const SuiClient = __importStar(require("./client"));
 const SuiConstants = __importStar(require("./constants"));
+const SuiTargets = __importStar(require("./targets"));
 const SuiUtils = __importStar(require("./utils"));
 exports.Sui = {
     utils: SuiUtils,
     constants: SuiConstants,
+    client: SuiClient,
+    targets: SuiTargets,
 };
 /**
  * Sui Adapter for Upshift SDK.