@upshiftfinance/sdk 0.3.0 → 0.4.0

package/README.md

@@ -174,7 +174,7 @@ src.ts/
 - **EVM Chains**: Ethereum, Arbitrum, Base, BSC, Avalanche, and more — `wagmi/viem` and `ethers` signers supported
 - **Solana**: Native Solana program support with full vault functionality
 - **Stellar**: Stellar vault deposit, redeem, and position queries
-- **Sui**: chain ID `-2`, address and version (`sui-0`) recognition; vault reads are not supported yet
+- **Sui**: chain ID `-2`; vault reads (`getVault`, `getVaults`), share positions (`getVaultPositions({ suiWallet })`), deposit and instant redeem (`sdk.sui.vaultDeposit`, `sdk.sui.vaultRedeem`). Pass `sui.packageId`, `sui.originalPackageId` and `sui.registryId` until the SDK ships the contract IDs
 - Unified interface across all chains
 
 ### Vault Versions

package/lib/abis/KycRegistry.d.ts

@@ -0,0 +1,109 @@
+/** ABI for the Upshift `KycRegistry` (one per chain): wallet status and record reads, the vault entry/exit checks, and the check-side errors. */
+export declare const ABI_KYC_REGISTRY: readonly [{
+    readonly type: "function";
+    readonly name: "statusOf";
+    readonly inputs: readonly [{
+        readonly name: "wallet";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+        readonly internalType: "enum IKycRegistry.Status";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getRecord";
+    readonly inputs: readonly [{
+        readonly name: "wallet";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple";
+        readonly internalType: "struct IKycRegistry.Record";
+        readonly components: readonly [{
+            readonly name: "blocked";
+            readonly type: "bool";
+            readonly internalType: "bool";
+        }, {
+            readonly name: "verifiedAt";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "expiresAt";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "revokedAt";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "canEnter";
+    readonly inputs: readonly [{
+        readonly name: "addr";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "ok";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "canExit";
+    readonly inputs: readonly [{
+        readonly name: "addr";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "ok";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "isExempt";
+    readonly inputs: readonly [{
+        readonly name: "addr";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "error";
+    readonly name: "KycIneligible";
+    readonly inputs: readonly [{
+        readonly name: "addr";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "status";
+        readonly type: "uint8";
+        readonly internalType: "enum IKycRegistry.Status";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "WalletBlocked";
+    readonly inputs: readonly [{
+        readonly name: "wallet";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}];

package/lib/abis/KycRegistry.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ABI_KYC_REGISTRY = void 0;
+/** ABI for the Upshift `KycRegistry` (one per chain): wallet status and record reads, the vault entry/exit checks, and the check-side errors. */
+exports.ABI_KYC_REGISTRY = [
+    {
+        type: 'function',
+        name: 'statusOf',
+        inputs: [{ name: 'wallet', type: 'address', internalType: 'address' }],
+        outputs: [
+            { name: '', type: 'uint8', internalType: 'enum IKycRegistry.Status' },
+        ],
+        stateMutability: 'view',
+    },
+    {
+        type: 'function',
+        name: 'getRecord',
+        inputs: [{ name: 'wallet', type: 'address', internalType: 'address' }],
+        outputs: [
+            {
+                name: '',
+                type: 'tuple',
+                internalType: 'struct IKycRegistry.Record',
+                components: [
+                    { name: 'blocked', type: 'bool', internalType: 'bool' },
+                    { name: 'verifiedAt', type: 'uint256', internalType: 'uint256' },
+                    { name: 'expiresAt', type: 'uint256', internalType: 'uint256' },
+                    { name: 'revokedAt', type: 'uint256', internalType: 'uint256' },
+                ],
+            },
+        ],
+        stateMutability: 'view',
+    },
+    {
+        type: 'function',
+        name: 'canEnter',
+        inputs: [{ name: 'addr', type: 'address', internalType: 'address' }],
+        outputs: [{ name: 'ok', type: 'bool', internalType: 'bool' }],
+        stateMutability: 'view',
+    },
+    {
+        type: 'function',
+        name: 'canExit',
+        inputs: [{ name: 'addr', type: 'address', internalType: 'address' }],
+        outputs: [{ name: 'ok', type: 'bool', internalType: 'bool' }],
+        stateMutability: 'view',
+    },
+    {
+        type: 'function',
+        name: 'isExempt',
+        inputs: [{ name: 'addr', type: 'address', internalType: 'address' }],
+        outputs: [{ name: '', type: 'bool', internalType: 'bool' }],
+        stateMutability: 'view',
+    },
+    {
+        type: 'error',
+        name: 'KycIneligible',
+        inputs: [
+            { name: 'addr', type: 'address', internalType: 'address' },
+            {
+                name: 'status',
+                type: 'uint8',
+                internalType: 'enum IKycRegistry.Status',
+            },
+        ],
+    },
+    {
+        type: 'error',
+        name: 'WalletBlocked',
+        inputs: [{ name: 'wallet', type: 'address', internalType: 'address' }],
+    },
+];
+//# sourceMappingURL=KycRegistry.js.map

package/lib/abis/index.d.ts

@@ -32,3 +32,4 @@ export * from './TokenizedVaultV2SenderAllocationWhitelist';
 export * from './RwaRedeemSubaccount';
 export * from './OFT';
 export * from './SwapRouter';
+export * from './KycRegistry';

package/lib/abis/index.js

@@ -48,4 +48,5 @@ __exportStar(require("./TokenizedVaultV2SenderAllocationWhitelist"), exports);
 __exportStar(require("./RwaRedeemSubaccount"), exports);
 __exportStar(require("./OFT"), exports);
 __exportStar(require("./SwapRouter"), exports);
+__exportStar(require("./KycRegistry"), exports);
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,174 @@
+/**
+ * Sui vault actions: deposit and instant redeem.
+ *
+ * Each builder dry-runs the exact transaction with the sender's own coins, so
+ * a vault that would reject it (paused, queue attached, limits) fails here
+ * with a typed {@link UpshiftVaultAbortError} instead of in the wallet, and the
+ * dry run's preview sets the transaction's minimum output. The result is an
+ * unsigned `Transaction` for the wallet to sign; {@link submitSuiTransaction}
+ * executes a signed one and waits for it.
+ *
+ * @module SuiActions
+ */
+import type { Transaction } from '@mysten/sui/transactions';
+import type { ISuiConfig, ISuiNetwork } from '../../types';
+import { UpshiftSDKError } from '../../core/errors';
+import { type ISuiVaultRef } from './getters';
+/** Parameters for {@link buildSuiDepositTransaction}. */
+export interface ISuiDepositParams {
+    /** The vault and its coin types and network. */
+    vault: ISuiVaultRef;
+    /** Deposit amount in asset base units. */
+    amount: bigint;
+    /** Wallet that pays the deposit and receives the shares. */
+    sender: string;
+    /**
+     * Smallest share amount to accept. Defaults to the dry run's exact preview,
+     * so any price move between building and executing aborts with `slippage`.
+     */
+    minSharesOut?: bigint;
+}
+/** Parameters for {@link buildSuiRedeemTransaction}. */
+export interface ISuiRedeemParams {
+    /** The vault and its coin types and network. */
+    vault: ISuiVaultRef;
+    /** Shares to redeem, in share base units. */
+    shares: bigint;
+    /** Wallet that holds the shares and receives the assets. */
+    sender: string;
+    /**
+     * Smallest asset amount to accept, net of the instant fee. Defaults to the
+     * dry run's exact preview.
+     */
+    minAssetsOut?: bigint;
+}
+/** An unsigned deposit transaction and the minimum it enforces. */
+export interface ISuiDepositTransaction {
+    /** Unsigned transaction, sender set; sign it with the sender's wallet. */
+    transaction: Transaction;
+    /** Shares the dry run minted. */
+    expectedShares: bigint;
+    /** Minimum shares the transaction accepts. */
+    minSharesOut: bigint;
+}
+/** An unsigned instant-redeem transaction and the minimum it enforces. */
+export interface ISuiRedeemTransaction {
+    /** Unsigned transaction, sender set; sign it with the sender's wallet. */
+    transaction: Transaction;
+    /** Gross assets before the instant fee. */
+    expectedGrossAssets: bigint;
+    /** Assets the dry run paid, net of the instant fee. */
+    expectedAssets: bigint;
+    /** Minimum net assets the transaction accepts. */
+    minAssetsOut: bigint;
+}
+/** A transaction signed by the sender's wallet. */
+export interface ISuiSignedTransaction {
+    /** Transaction bytes, base64, as the wallet returns them. */
+    bytes: string;
+    /** The sender's signature, base64. */
+    signature: string;
+}
+/** The parts of a Sui execution error the mapping reads. */
+interface ISuiExecutionError {
+    message?: string;
+    MoveAbort?: {
+        abortCode?: string;
+        location?: {
+            module?: string;
+        };
+        cleverError?: {
+            constantName?: string;
+        };
+    };
+}
+/**
+ * Map a failed Sui execution to an SDK error: a contract abort becomes an
+ * {@link UpshiftVaultAbortError} with a stable reason, anything else an
+ * {@link UpshiftSDKError} (`UNKNOWN`).
+ *
+ * @param executionError - `effects.status.error` of a failed transaction, or
+ *   the `executionError` of a `SimulationError`.
+ * @param context - Structured context for the error (e.g. network, digest).
+ * @internal
+ */
+export declare function suiExecutionErrorToSdkError(executionError: ISuiExecutionError | undefined, context?: Record<string, unknown>): UpshiftSDKError;
+/**
+ * Build an unsigned deposit: charge the management fee, deposit with a minimum
+ * share amount, and send the shares to the sender — one transaction.
+ *
+ * The payment is `coinWithBalance(Asset)`: the wallet selects and merges the
+ * sender's coins when it signs. The fee is charged first so the deposit is
+ * priced on a current NAV.
+ *
+ * RPC cost: one dry run (plus the coin lookup it needs).
+ *
+ * @param params - Vault, amount, sender and optional minimum shares.
+ * @param sui - The SDK's `sui` config; applied only for `params.vault.network`.
+ * @returns The unsigned transaction, the shares the dry run minted and the
+ *   minimum it enforces.
+ * @throws {@link UpshiftValidationError} for a malformed sender or vault, an
+ *   out-of-range amount, unknown contract IDs, or a transaction that cannot be
+ *   built (e.g. the sender lacks the asset).
+ * @throws {@link UpshiftVaultAbortError} when the vault would reject the
+ *   deposit (`paused`, `below_min_deposit`, `above_max_deposit`,
+ *   `deposit_cap_exceeded`, `zero_output`, `slippage`, `version_retired`).
+ * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+ * @example
+ * ```ts
+ * const { transaction } = await buildSuiDepositTransaction(
+ *   { vault: ref, amount: 1_000_000n, sender: account.address },
+ *   sdkSuiConfig,
+ * );
+ * const { digest } = await dAppKit.signAndExecuteTransaction({ transaction });
+ * ```
+ */
+export declare function buildSuiDepositTransaction(params: ISuiDepositParams, sui?: ISuiConfig): Promise<ISuiDepositTransaction>;
+/**
+ * Build an unsigned instant redemption: redeem shares with a minimum net
+ * asset amount and send the assets to the sender — one transaction.
+ *
+ * The shares are `coinWithBalance(Share)`. A vault with a withdrawal queue
+ * attached has instant redemption off; that fails here with `queue_attached`.
+ *
+ * Side effect on failure: when the vault rejects the dry run, the failure is
+ * reported to that vault's curator (fire-and-forget; see
+ * `monitoring.curatorAlerts`).
+ *
+ * RPC cost: one dry run (plus the coin lookup it needs).
+ *
+ * @param params - Vault, shares, sender and optional minimum assets.
+ * @param sui - The SDK's `sui` config; applied only for `params.vault.network`.
+ * @returns The unsigned transaction, the dry run's gross and net assets and
+ *   the minimum it enforces.
+ * @throws {@link UpshiftValidationError} for a malformed sender or vault, an
+ *   out-of-range amount, unknown contract IDs, or a transaction that cannot be
+ *   built (e.g. the sender lacks the shares).
+ * @throws {@link UpshiftVaultAbortError} when the vault would reject the
+ *   redemption (`queue_attached`, `paused`, `above_max_withdrawal`,
+ *   `insufficient_liquidity`, `zero_output`, `slippage`, `version_retired`).
+ * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+ */
+export declare function buildSuiRedeemTransaction(params: ISuiRedeemParams, sui?: ISuiConfig): Promise<ISuiRedeemTransaction>;
+/**
+ * Execute a signed transaction and wait until the network has indexed it.
+ *
+ * Side effect on failure: a failed instant redemption is reported to that
+ * vault's curator with its digest (fire-and-forget; see
+ * `monitoring.curatorAlerts`).
+ *
+ * RPC cost: one execution plus the confirmation poll.
+ *
+ * @param signed - Bytes and signature from the wallet's `signTransaction`.
+ * @param network - Network the transaction was built for.
+ * @param sui - The SDK's `sui` config; applied only for `network`.
+ * @returns The transaction digest once it succeeded and is indexed.
+ * @throws {@link UpshiftVaultAbortError} when the vault aborted it on chain.
+ * @throws {@link UpshiftSDKError} (`UNKNOWN`) when it failed for another
+ *   reason; `context.digest` names it.
+ * @throws {@link UpshiftTransactionError} when it executed but was not
+ *   indexed in time; check `signature` (the digest) before retrying.
+ * @throws {@link UpshiftNetworkError} when every Sui endpoint fails.
+ */
+export declare function submitSuiTransaction(signed: ISuiSignedTransaction, network: ISuiNetwork, sui?: ISuiConfig): Promise<string>;
+export {};