@ember-finance/sdk 2.38.0 → 2.40.0

package/dist/src/common/constants.d.ts

@@ -1,5 +1,5 @@
 export type PlatformEnv = "prod" | "staging" | "dev";
-export type ChainType = "sui" | "evm";
+export type ChainType = "sui" | "evm" | "solana";
 export type EnvironmentConfig = {
     [K in PlatformEnv]: {
         apiHost: string;

package/dist/src/ember-vaults.d.ts

@@ -18,6 +18,12 @@ import { EVMDeploymentParser } from "./evm-vaults/utils/deployment-parser.js";
 import { EVMVaultReader } from "./evm-vaults/on-chain-calls/vault-reader.js";
 import { AccountsApi, VaultsApi } from "./api/index.js";
 import { AccountsApi as AccountsV2Api, VaultsApi as VaultsV2Api } from "./api/v2/index.js";
+import type { Connection as SolanaConnection } from "@solana/web3.js";
+import type { ISolanaDeployment } from "./solana-vaults/interfaces/index.js";
+import { SolanaDeploymentParser } from "./solana-vaults/utils/deployment-parser.js";
+import { SolanaVaultReader } from "./solana-vaults/on-chain-calls/vault-reader.js";
+import { SolanaUserCalls } from "./solana-vaults/on-chain-calls/user.js";
+import type { SolanaSigner } from "./solana-vaults/signers/solana-signer.js";
 import { ChainType, PlatformEnv } from "./common/constants.js";
 /**
  * SUI-specific initialization options
@@ -46,7 +52,48 @@ export interface EvmInitOptions {
     environment?: PlatformEnv;
     chainIdentifier: string;
 }
-export type EmberVaultsInitOptions = SuiInitOptions | EvmInitOptions;
+/**
+ * Solana-specific initialization options.
+ *
+ * `connection` rather than a provider: web3.js has no provider abstraction,
+ * and every read goes through it.
+ *
+ * `signer` takes either shape - a raw Keypair for scripts and ops tooling, or
+ * a connected browser wallet - and is optional so a page can read before
+ * anyone connects. A write with no signer anywhere throws.
+ */
+export interface SolanaInitOptions {
+    chainType: "solana";
+    connection: SolanaConnection;
+    signer?: SolanaSigner;
+    /**
+     * Unused on Solana and accepted only so the constructor can read it
+     * uniformly. The chain identifier is "solana" on every cluster; which
+     * cluster an environment talks to follows from the deployment it serves.
+     */
+    chainIdentifier?: string;
+    walletAddress?: string;
+    deployment?: ISolanaDeployment;
+    basePath?: string;
+    environment?: PlatformEnv;
+}
+export type EmberVaultsInitOptions = SuiInitOptions | EvmInitOptions | SolanaInitOptions;
+/**
+ * Solana-specific EmberVaults instance type.
+ *
+ * Narrower than its Sui and EVM counterparts: reads plus the user writes.
+ * The admin, operator, vaultAdmin and txBuilder surfaces follow, and the
+ * getters for them throw rather than returning undefined until they do.
+ */
+export interface SolanaEmberVaults {
+    chainType: "solana";
+    connection: SolanaConnection;
+    parser: SolanaDeploymentParser;
+    walletAddress?: string;
+    reader: SolanaVaultReader;
+    user: SolanaUserCalls;
+    deployment: ISolanaDeployment;
+}
 /**
  * SUI-specific EmberVaults instance type
  */
@@ -133,9 +180,23 @@ export declare class EmberVaults {
     private _evmUser?;
     private _evmDeployment?;
     private _evmVaultReader?;
+    private _solanaConnection?;
+    private _solanaParser?;
+    private _solanaDeployment?;
+    private _solanaVaultReader?;
+    private _solanaUser?;
+    private _solanaSigner?;
     private _walletAddress?;
     private _chainIdentifier?;
     constructor(options: EmberVaultsInitOptions);
+    /**
+     * Solana setup.
+     *
+     * The deployment is optional here as it is on the other chains: pass one
+     * to work offline, or call `init()` to fetch it from the API. Without
+     * either, the reader has nothing to resolve addresses against.
+     */
+    private _initSolana;
     private _initSui;
     private _initEvm;
     /**
@@ -146,19 +207,30 @@ export declare class EmberVaults {
      * Updates the deployment configuration
      * @param newDeployment The new deployment configuration (ISuiDeployment or EvmProtocolInfo)
      */
-    updateDeployment(newDeployment: ISuiDeployment | EvmProtocolInfo): void;
+    updateDeployment(newDeployment: ISuiDeployment | EvmProtocolInfo | ISolanaDeployment): void;
     get suiClient(): SuiClient;
     get network(): string;
     get provider(): EvmProvider | undefined;
     get walletAddress(): string | undefined;
+    /**
+     * Read-only vault access. Sui has no reader, so this is EVM or Solana.
+     */
+    get reader(): EVMVaultReader | SolanaVaultReader;
+    /**
+     * Solana's write surfaces are not built yet. Thrown rather than returning
+     * undefined so the failure names what is missing instead of surfacing as
+     * "cannot read property of undefined" several frames later.
+     */
+    private notOnSolana;
+    get connection(): SolanaConnection;
     get signer(): SuiSigner | EvmSigner | undefined;
-    get parser(): SuiDeploymentParser | EVMDeploymentParser;
+    get parser(): SuiDeploymentParser | EVMDeploymentParser | SolanaDeploymentParser;
     get txBuilder(): SuiTxBuilder | EVMTxBuilder;
     get admin(): SuiAdminCalls | EVMAdminCalls;
     get operator(): SuiOperatorCalls | EVMOperatorCalls;
     get vaultAdmin(): SuiVaultAdminCalls | EVMVaultAdminCalls;
-    get user(): SuiUserCalls | EVMUserCalls;
-    get deployment(): ISuiDeployment | EvmProtocolInfo;
+    get user(): SuiUserCalls | EVMUserCalls | SolanaUserCalls;
+    get deployment(): ISuiDeployment | EvmProtocolInfo | ISolanaDeployment;
     /**
      * Check if this is a SUI instance
      */
@@ -166,6 +238,10 @@ export declare class EmberVaults {
     /**
      * Check if this is an EVM instance
      */
+    /**
+     * Check if this is a Solana instance
+     */
+    isSolana(): this is EmberVaults & SolanaEmberVaults;
     isEvm(): this is EmberVaults & EvmEmberVaults;
     /**
      * Get SUI-specific instance (throws if not SUI)
@@ -175,4 +251,8 @@ export declare class EmberVaults {
      * Get EVM-specific instance (throws if not EVM)
      */
     asEvm(): EvmEmberVaults;
+    /**
+     * Get Solana-specific instance (throws if not Solana)
+     */
+    asSolana(): SolanaEmberVaults;
 }

package/dist/src/ember-vaults.js

@@ -14,6 +14,9 @@ import { EVMVaultReader } from "./evm-vaults/on-chain-calls/vault-reader.js";
 // API imports
 import { AccountsApi, Configuration, VaultsApi } from "./api/index.js";
 import { AccountsApi as AccountsV2Api, Configuration as ConfigurationV2, VaultsApi as VaultsV2Api } from "./api/v2/index.js";
+import { SolanaDeploymentParser } from "./solana-vaults/utils/deployment-parser.js";
+import { SolanaVaultReader } from "./solana-vaults/on-chain-calls/vault-reader.js";
+import { SolanaUserCalls } from "./solana-vaults/on-chain-calls/user.js";
 import { environmentConfig } from "./common/constants.js";
 /**
  * EmberVaults - Unified interface for both SUI and EVM chains
@@ -54,10 +57,31 @@ export class EmberVaults {
         if (options.chainType === "sui") {
             this._initSui(options);
         }
+        else if (options.chainType === "solana") {
+            this._initSolana(options);
+        }
         else {
             this._initEvm(options);
         }
     }
+    /**
+     * Solana setup.
+     *
+     * The deployment is optional here as it is on the other chains: pass one
+     * to work offline, or call `init()` to fetch it from the API. Without
+     * either, the reader has nothing to resolve addresses against.
+     */
+    _initSolana(options) {
+        this._solanaConnection = options.connection;
+        this._walletAddress = options.walletAddress;
+        this._solanaSigner = options.signer;
+        if (options.deployment) {
+            this._solanaDeployment = options.deployment;
+            this._solanaParser = new SolanaDeploymentParser(options.deployment);
+            this._solanaVaultReader = new SolanaVaultReader(options.connection, this._solanaParser);
+            this._solanaUser = new SolanaUserCalls(options.connection, this._solanaParser, options.signer);
+        }
+    }
     _initSui(options) {
         this._suiNetwork = options.network;
         this._suiClient = options.suiClient;
@@ -97,6 +121,23 @@ export class EmberVaults {
                 throw new Error(`Deployment data not found for chain ${this._chainIdentifier}`);
             }
         }
+        else if (this.chainType === "solana") {
+            // One Solana deployment per environment, so there is nothing to
+            // disambiguate by chain identifier - it is "solana" on every
+            // cluster, and which cluster follows from the environment.
+            // Compared as a string: the API spec vendored under src/api/v2 was
+            // copied before bfvs added "solana" to VaultsDeploymentConfig's
+            // chainType enum, so the generated union does not list it yet. The
+            // wire value is correct and staging already serves it; this reads
+            // as written rather than as typed until the client is regenerated.
+            const deploymentData = deployment.data.find(d => d.chainType === "solana");
+            if (deploymentData) {
+                this.updateDeployment(deploymentData.config);
+            }
+            else {
+                throw new Error("Deployment data not found for chain solana");
+            }
+        }
         else {
             const deploymentData = deployment.data.find(d => d.chainType === "evm" && d.chain === this._chainIdentifier);
             if (deploymentData) {
@@ -112,6 +153,27 @@ export class EmberVaults {
      * @param newDeployment The new deployment configuration (ISuiDeployment or EvmProtocolInfo)
      */
     updateDeployment(newDeployment) {
+        if (this.chainType === "solana") {
+            const solanaDeployment = newDeployment;
+            this._solanaDeployment = solanaDeployment;
+            // The parser holds the program id that every address derives from,
+            // so it is rebuilt rather than mutated - a deployment pointing at a
+            // different program is a different parser.
+            this._solanaParser = new SolanaDeploymentParser(solanaDeployment);
+            if (this._solanaUser) {
+                this._solanaUser.updateDeployment(this._solanaParser);
+            }
+            else {
+                this._solanaUser = new SolanaUserCalls(this._solanaConnection, this._solanaParser, this._solanaSigner);
+            }
+            if (this._solanaVaultReader) {
+                this._solanaVaultReader.updateDeployment(this._solanaParser);
+            }
+            else if (this._solanaConnection) {
+                this._solanaVaultReader = new SolanaVaultReader(this._solanaConnection, this._solanaParser);
+            }
+            return;
+        }
         if (this.chainType === "sui") {
             const suiDeployment = newDeployment;
             this._suiDeployment = suiDeployment;
@@ -161,28 +223,82 @@ export class EmberVaults {
     get walletAddress() {
         return this._walletAddress;
     }
+    /**
+     * Read-only vault access. Sui has no reader, so this is EVM or Solana.
+     */
+    get reader() {
+        if (this.chainType === "solana") {
+            if (!this._solanaVaultReader)
+                throw new Error("No Solana deployment loaded. Pass one, or call init().");
+            return this._solanaVaultReader;
+        }
+        if (this.chainType === "sui")
+            throw new Error("reader is not available for SUI chain");
+        return this._evmVaultReader;
+    }
+    /**
+     * Solana's write surfaces are not built yet. Thrown rather than returning
+     * undefined so the failure names what is missing instead of surfacing as
+     * "cannot read property of undefined" several frames later.
+     */
+    notOnSolana(surface) {
+        throw new Error(`${surface} is not available for Solana yet. ` +
+            `The Solana module exposes reads and the user writes: ` +
+            `use .reader, .user, .parser or .deployment.`);
+    }
+    // ============================================
+    // Solana Getters
+    // ============================================
+    get connection() {
+        if (this.chainType !== "solana")
+            throw new Error("connection is only available for Solana chain");
+        return this._solanaConnection;
+    }
     get signer() {
         return this.chainType === "sui" ? this._suiSigner : this._evmSigner;
     }
     get parser() {
+        if (this.chainType === "solana") {
+            if (!this._solanaParser)
+                throw new Error("No Solana deployment loaded. Pass one, or call init().");
+            return this._solanaParser;
+        }
         return this.chainType === "sui" ? this._suiParser : this._evmParser;
     }
     get txBuilder() {
+        if (this.chainType === "solana")
+            this.notOnSolana("txBuilder");
         return this.chainType === "sui" ? this._suiTxBuilder : this._evmTxBuilder;
     }
     get admin() {
+        if (this.chainType === "solana")
+            this.notOnSolana("admin");
         return this.chainType === "sui" ? this._suiAdmin : this._evmAdmin;
     }
     get operator() {
+        if (this.chainType === "solana")
+            this.notOnSolana("operator");
         return this.chainType === "sui" ? this._suiOperator : this._evmOperator;
     }
     get vaultAdmin() {
+        if (this.chainType === "solana")
+            this.notOnSolana("vaultAdmin");
         return this.chainType === "sui" ? this._suiVaultAdmin : this._evmVaultAdmin;
     }
     get user() {
+        if (this.chainType === "solana") {
+            if (!this._solanaUser)
+                throw new Error("No Solana deployment loaded. Pass one, or call init().");
+            return this._solanaUser;
+        }
         return this.chainType === "sui" ? this._suiUser : this._evmUser;
     }
     get deployment() {
+        if (this.chainType === "solana") {
+            if (!this._solanaDeployment)
+                throw new Error("No Solana deployment loaded. Pass one, or call init().");
+            return this._solanaDeployment;
+        }
         return this.chainType === "sui" ? this._suiDeployment : this._evmDeployment;
     }
     // ============================================
@@ -197,6 +313,12 @@ export class EmberVaults {
     /**
      * Check if this is an EVM instance
      */
+    /**
+     * Check if this is a Solana instance
+     */
+    isSolana() {
+        return this.chainType === "solana";
+    }
     isEvm() {
         return this.chainType === "evm";
     }
@@ -242,4 +364,26 @@ export class EmberVaults {
             reader: this._evmVaultReader
         };
     }
+    /**
+     * Get Solana-specific instance (throws if not Solana)
+     */
+    asSolana() {
+        if (!this.isSolana())
+            throw new Error("This EmberVaults instance is not configured for Solana");
+        if (!this._solanaParser || !this._solanaVaultReader || !this._solanaDeployment) {
+            throw new Error("No Solana deployment loaded. Pass one, or call init().");
+        }
+        if (!this._solanaUser) {
+            throw new Error("No Solana deployment loaded. Pass one, or call init().");
+        }
+        return {
+            chainType: "solana",
+            connection: this._solanaConnection,
+            parser: this._solanaParser,
+            walletAddress: this._walletAddress,
+            reader: this._solanaVaultReader,
+            user: this._solanaUser,
+            deployment: this._solanaDeployment
+        };
+    }
 }

package/dist/src/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./api/index.js";
 export * from "./sui-vaults/index.js";
+export * from "./solana-vaults/index.js";
 export * from "./ember-vaults.js";
 export type { PlatformEnv } from "./common/constants.js";

package/dist/src/index.js

@@ -1,3 +1,4 @@
 export * from "./api/index.js";
 export * from "./sui-vaults/index.js";
+export * from "./solana-vaults/index.js";
 export * from "./ember-vaults.js";

package/dist/src/solana-vaults/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./interfaces/index.js";
+export * from "./on-chain-calls/index.js";
+export * from "./signers/index.js";
+export * from "./utils/index.js";

package/dist/src/solana-vaults/index.js

@@ -0,0 +1,4 @@
+export * from "./interfaces/index.js";
+export * from "./on-chain-calls/index.js";
+export * from "./signers/index.js";
+export * from "./utils/index.js";

package/dist/src/solana-vaults/interfaces/index.d.ts

@@ -0,0 +1,260 @@
+import type { PublicKey } from "@solana/web3.js";
+/**
+ * Solana vault interfaces.
+ *
+ * The on-chain program is `ember_vaults`, the Anchor port of the Move
+ * `vault` module. Three things differ from Sui and EVM and shape everything
+ * here:
+ *
+ * - **Every account a transaction touches must be named up front.** There is
+ *   no equivalent of Sui reaching through a shared object or EVM reading
+ *   storage mid-call, so the builders below take addresses the other chains
+ *   derive internally.
+ * - **The share mint is the vault's identity.** The vault PDA is
+ *   `["vault", share_mint]`, so one mint is one vault and every other address
+ *   follows from it.
+ * - **Withdrawals are asynchronous.** Redeeming queues a request and escrows
+ *   the shares; the operator settles the queue in FIFO order afterwards.
+ */
+/** 100% in the program's fixed point. Rates and percentages both use it. */
+export declare const RATE_ONE = 1000000000n;
+/** `PERCENT_DECIMALS` in the program: 1% is 1e7. */
+export declare const PERCENT_DECIMALS = 7;
+/** Seeds for every PDA the program owns, verbatim from `constants.rs`. */
+export declare const SOLANA_SEEDS: {
+    readonly protocolConfig: "protocol_config";
+    readonly vault: "vault";
+    readonly vaultCollateral: "vault_collateral";
+    readonly vaultPendingShares: "vault_pending_shares";
+    readonly withdrawalQueue: "withdrawal_queue";
+    readonly account: "account";
+    readonly withdrawalRequest: "withdrawal_request";
+    readonly parkingLot: "parking_lot";
+    readonly parkingLotEscrow: "parking_lot_escrow";
+    readonly depositRequest: "deposit_request";
+};
+/** A cluster the deployment manifest can describe. */
+export type SolanaCluster = "localnet" | "devnet" | "testnet" | "mainnet";
+/**
+ * The deployed program, as `deployments/<cluster>.json` records it in
+ * ember-contracts. Addresses are base58 strings rather than `PublicKey`s so
+ * the manifest round-trips through JSON and the API unchanged.
+ */
+export interface ISolanaProgramInfo {
+    /** The only field the API guarantees: everything else is a PDA of it. */
+    programId: string;
+    programDataAddress?: string;
+    upgradeAuthority?: string | null;
+    /** Manifest only. */
+    programSize?: number;
+    deployedAt?: string;
+    /** Where an indexer starts its backfill. EVM's deploymentBlockNumber. */
+    deploySlot?: number;
+    /** Manifest only. */
+    gitCommit?: string;
+}
+/** The protocol-wide config PDA and the values it holds. */
+export interface ISolanaProtocolConfig {
+    address: string;
+    version: string;
+    /**
+     * The fields below are manifest only. All of them change without a
+     * redeployment - `transfer_protocol_admin`, `set_guardian`,
+     * `update_platform_fee_recipient` - so a config file is the wrong place to
+     * trust them. Read them from the chain with {@link decodeProtocolConfig}.
+     */
+    admin?: string;
+    guardian?: string | null;
+    platformFeeRecipient?: string;
+    initializedAt?: string;
+    slot?: number;
+}
+/** A collateral mint the protocol knows about, keyed by symbol. */
+export interface ISolanaTokenInfo {
+    mint: string;
+    symbol: string;
+    name: string;
+    decimals: number;
+    /** SPL Token or Token-2022; the two mints of a vault may differ. */
+    tokenProgram: string;
+    /** Manifest only: live state, readable from the mint. */
+    mintAuthority?: string | null;
+    freezeAuthority?: string | null;
+}
+/**
+ * A vault, keyed in the manifest by its share mint.
+ *
+ * The four PDAs are recorded rather than re-derived so ops tooling and
+ * indexers agree with the SDK byte for byte, but every one of them is a pure
+ * function of `shareMint` — see {@link deriveVaultPdas}.
+ */
+export interface ISolanaVaultInfo {
+    name: string;
+    vault: string;
+    collateralMint: string;
+    shareMint: string;
+    /** Null when the vault was created with `--no-metadata`. */
+    shareName: string | null;
+    shareSymbol: string | null;
+    /**
+     * The Metaplex Token Metadata PDA holding those two. Manifest only: it is
+     * a PDA of the share mint, so {@link metadataAddress} derives it.
+     */
+    shareMetadata?: string | null;
+    admin: string;
+    operator: string;
+    /** Unset until the admin calls `update_vault_rate_manager`. */
+    rateManager: string | null;
+    subAccounts: string[];
+    /**
+     * Manifest only. All three are PDAs of the share mint, so
+     * {@link deriveVaultPdas} produces them; the API does not serve a second
+     * source of truth that could disagree with the chain.
+     */
+    vaultCollateral?: string;
+    vaultPendingShares?: string;
+    withdrawalQueue?: string;
+    /** Raw u64 strings, at the collateral mint's decimals. */
+    feePercentage: string;
+    maxRateChangePerUpdate: string;
+    maxTvl: string;
+    minWithdrawalShares: string;
+    /** Manifest only: readable from the vault account. */
+    rateUpdateInterval?: string;
+}
+/** The whole Solana deployment, as the manifest and the API carry it. */
+export interface ISolanaDeployment {
+    /**
+     * Which cluster this deployment lives on. Optional because a manifest read
+     * from disk may predate the field, not because the API omits it - the
+     * chain identifier is "solana" everywhere, so this is the only thing that
+     * distinguishes devnet from mainnet.
+     */
+    cluster?: SolanaCluster;
+    /** Manifest only: the endpoint the deploy ran through, not a property of
+     *  the deployment, so the API does not serve it. */
+    rpcUrl?: string;
+    program: ISolanaProgramInfo;
+    protocolConfig?: ISolanaProtocolConfig;
+    /** Keyed by symbol. */
+    tokens?: Record<string, ISolanaTokenInfo>;
+    /** Keyed by share mint. */
+    vaults?: Record<string, ISolanaVaultInfo>;
+}
+/** Alias matching the EVM and Sui naming, for the unified entry point. */
+export type SolanaProtocolInfo = ISolanaDeployment;
+/** The PDAs that hang off a vault, all derived from its share mint. */
+export interface ISolanaVaultPdas {
+    vault: PublicKey;
+    vaultCollateral: PublicKey;
+    vaultPendingShares: PublicKey;
+    withdrawalQueue: PublicKey;
+}
+/** `state::Rate`. */
+export interface ISolanaRate {
+    /** Shares per unit of collateral, 1e9 fixed point. Inverse to share value. */
+    value: bigint;
+    maxRateChangePerUpdate: bigint;
+    rateUpdateInterval: bigint;
+    lastUpdatedAt: bigint;
+}
+/**
+ * `state::WithdrawalFee`, the tail of `Vault`.
+ *
+ * Two fees that stack: a permanent one charged on every redemption, and a
+ * time-based one charged only while the holder is inside
+ * `timeBasedFeeThreshold` of their last deposit. Both are 1e9 fixed point,
+ * so 1% is 1e7.
+ */
+export interface ISolanaWithdrawalFee {
+    permanentFeePercentage: bigint;
+    timeBasedFeePercentage: bigint;
+    /** Milliseconds since the holder's last deposit. */
+    timeBasedFeeThreshold: bigint;
+    /** Addresses that pay neither fee. */
+    feeExempt: PublicKey[];
+}
+/** `state::PlatformFee`. */
+export interface ISolanaPlatformFee {
+    accrued: bigint;
+    lastChargedAt: bigint;
+}
+/** `state::Vault`, decoded. */
+export interface ISolanaVaultState {
+    name: string;
+    admin: PublicKey;
+    operator: PublicKey;
+    rateManager: PublicKey;
+    collateralMint: PublicKey;
+    shareMint: PublicKey;
+    blacklisted: PublicKey[];
+    paused: boolean;
+    pausedDeposits: boolean;
+    pausedWithdrawals: boolean;
+    pausedPrivileged: boolean;
+    subAccounts: PublicKey[];
+    rate: ISolanaRate;
+    feePercentage: bigint;
+    /** Mirrors the custody token account; the two must always agree. */
+    balance: bigint;
+    pendingSharesToBurn: bigint;
+    fee: ISolanaPlatformFee;
+    minWithdrawalShares: bigint;
+    maxTvl: bigint;
+    sequenceNumber: bigint;
+    /** `PublicKey.default` when no lot is bound. */
+    parkingLot: PublicKey;
+    depositUserList: PublicKey[];
+    withdrawalUserList: PublicKey[];
+    withdrawalFee: ISolanaWithdrawalFee;
+}
+/** `state::WithdrawalRequest`, the entry stored in the queue. */
+export interface ISolanaWithdrawalRequest {
+    owner: PublicKey;
+    receiver: PublicKey;
+    shares: bigint;
+    estimatedWithdrawAmount: bigint;
+    timestamp: bigint;
+    sequenceNumber: bigint;
+}
+/** `state::VaultAccount`: one per (vault, owner). */
+export interface ISolanaVaultAccount {
+    /** When this owner last deposited, for the time-based withdrawal fee. */
+    lastDepositTs: bigint;
+    totalPendingWithdrawalShares: bigint;
+    pendingWithdrawalRequests: ISolanaWithdrawalRequest[];
+    cancelWithdrawRequest: bigint[];
+    /** Seeds the owner's next request PDA; only ever increases. */
+    nextRequestNonce: bigint;
+}
+/** `state::WithdrawalRequestAccount`, one account per queued request. */
+export interface ISolanaWithdrawalRequestAccount {
+    address: PublicKey;
+    vault: PublicKey;
+    nonce: bigint;
+    queueIndex: bigint;
+    request: ISolanaWithdrawalRequest;
+}
+/** `state::WithdrawalQueue`: head and tail only, the entries live elsewhere. */
+export interface ISolanaWithdrawalQueue {
+    vault: PublicKey;
+    head: bigint;
+    tail: bigint;
+}
+/** `state::ProtocolConfig`, decoded. */
+export interface ISolanaProtocolConfigState {
+    admin: PublicKey;
+    /** Set by `transfer_protocol_admin`; `accept_protocol_admin` completes it. */
+    pendingAdmin: PublicKey;
+    guardian: PublicKey;
+    version: bigint;
+    /** The guardian's kill switch. Admin operations keep working. */
+    pauseNonAdminOperations: boolean;
+    platformFeeRecipient: PublicKey;
+    minRate: bigint;
+    maxRate: bigint;
+    defaultRate: bigint;
+    minRateInterval: bigint;
+    maxRateInterval: bigint;
+    maxFeePercentage: bigint;
+}

package/dist/src/solana-vaults/interfaces/index.js

@@ -0,0 +1,37 @@
+/**
+ * Solana vault interfaces.
+ *
+ * The on-chain program is `ember_vaults`, the Anchor port of the Move
+ * `vault` module. Three things differ from Sui and EVM and shape everything
+ * here:
+ *
+ * - **Every account a transaction touches must be named up front.** There is
+ *   no equivalent of Sui reaching through a shared object or EVM reading
+ *   storage mid-call, so the builders below take addresses the other chains
+ *   derive internally.
+ * - **The share mint is the vault's identity.** The vault PDA is
+ *   `["vault", share_mint]`, so one mint is one vault and every other address
+ *   follows from it.
+ * - **Withdrawals are asynchronous.** Redeeming queues a request and escrows
+ *   the shares; the operator settles the queue in FIFO order afterwards.
+ */
+/** 100% in the program's fixed point. Rates and percentages both use it. */
+export const RATE_ONE = 1000000000n;
+/** `PERCENT_DECIMALS` in the program: 1% is 1e7. */
+export const PERCENT_DECIMALS = 7;
+/** Seeds for every PDA the program owns, verbatim from `constants.rs`. */
+export const SOLANA_SEEDS = {
+    protocolConfig: "protocol_config",
+    vault: "vault",
+    vaultCollateral: "vault_collateral",
+    vaultPendingShares: "vault_pending_shares",
+    withdrawalQueue: "withdrawal_queue",
+    account: "account",
+    withdrawalRequest: "withdrawal_request",
+    parkingLot: "parking_lot",
+    parkingLotEscrow: "parking_lot_escrow",
+    depositRequest: "deposit_request"
+};
+// Call options and response types ship with the builders that take them, in
+// the phase that adds writes. Declaring them here first would be a public
+// surface nothing implements.