@ember-finance/sdk 2.39.0 → 2.42.0

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

@@ -22,6 +22,8 @@ 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
@@ -54,13 +56,16 @@ export interface EvmInitOptions {
  * Solana-specific initialization options.
  *
  * `connection` rather than a provider: web3.js has no provider abstraction,
- * and every read below goes through it. No signer yet - this slice is
- * read-only, and the signer shape (wallet adapter vs Keypair) is settled when
- * the write builders land.
+ * 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
@@ -76,8 +81,8 @@ export type EmberVaultsInitOptions = SuiInitOptions | EvmInitOptions | SolanaIni
 /**
  * Solana-specific EmberVaults instance type.
  *
- * Narrower than its Sui and EVM counterparts on purpose: reads only. The
- * admin, operator, vaultAdmin, user and txBuilder surfaces follow, and the
+ * 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 {
@@ -86,6 +91,7 @@ export interface SolanaEmberVaults {
     parser: SolanaDeploymentParser;
     walletAddress?: string;
     reader: SolanaVaultReader;
+    user: SolanaUserCalls;
     deployment: ISolanaDeployment;
 }
 /**
@@ -178,6 +184,8 @@ export declare class EmberVaults {
     private _solanaParser?;
     private _solanaDeployment?;
     private _solanaVaultReader?;
+    private _solanaUser?;
+    private _solanaSigner?;
     private _walletAddress?;
     private _chainIdentifier?;
     constructor(options: EmberVaultsInitOptions);
@@ -221,7 +229,7 @@ export declare class EmberVaults {
     get admin(): SuiAdminCalls | EVMAdminCalls;
     get operator(): SuiOperatorCalls | EVMOperatorCalls;
     get vaultAdmin(): SuiVaultAdminCalls | EVMVaultAdminCalls;
-    get user(): SuiUserCalls | EVMUserCalls;
+    get user(): SuiUserCalls | EVMUserCalls | SolanaUserCalls;
     get deployment(): ISuiDeployment | EvmProtocolInfo | ISolanaDeployment;
     /**
      * Check if this is a SUI instance

package/dist/src/ember-vaults.js

@@ -16,6 +16,7 @@ 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
@@ -73,10 +74,12 @@ export class EmberVaults {
     _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) {
@@ -157,6 +160,12 @@ export class EmberVaults {
             // 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);
             }
@@ -234,7 +243,8 @@ export class EmberVaults {
      */
     notOnSolana(surface) {
         throw new Error(`${surface} is not available for Solana yet. ` +
-            `The Solana module currently exposes reads only: use .reader, .parser or .deployment.`);
+            `The Solana module exposes reads and the user writes: ` +
+            `use .reader, .user, .parser or .deployment.`);
     }
     // ============================================
     // Solana Getters
@@ -276,8 +286,11 @@ export class EmberVaults {
         return this.chainType === "sui" ? this._suiVaultAdmin : this._evmVaultAdmin;
     }
     get user() {
-        if (this.chainType === "solana")
-            this.notOnSolana("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() {
@@ -360,12 +373,16 @@ export class EmberVaults {
         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/solana-vaults/index.d.ts

@@ -1,3 +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

@@ -1,3 +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

@@ -32,6 +32,9 @@ export declare const SOLANA_SEEDS: {
     readonly parkingLot: "parking_lot";
     readonly parkingLotEscrow: "parking_lot_escrow";
     readonly depositRequest: "deposit_request";
+    readonly depositUser: "deposit_user";
+    readonly withdrawalUser: "withdrawal_user";
+    readonly parkingLotUser: "parking_lot_user";
 };
 /** A cluster the deployment manifest can describe. */
 export type SolanaCluster = "localnet" | "devnet" | "testnet" | "mainnet";
@@ -204,8 +207,13 @@ export interface ISolanaVaultState {
     sequenceNumber: bigint;
     /** `PublicKey.default` when no lot is bound. */
     parkingLot: PublicKey;
-    depositUserList: PublicKey[];
-    withdrawalUserList: PublicKey[];
+    /**
+     * Sizes of the two allow lists, not their members: each list is unbounded
+     * and lives in one PDA per account. 0 means open to all. Test one account
+     * with `deriveDepositUser` / `deriveWithdrawalUser`.
+     */
+    depositUserCount: bigint;
+    withdrawalUserCount: bigint;
     withdrawalFee: ISolanaWithdrawalFee;
 }
 /** `state::WithdrawalRequest`, the entry stored in the queue. */
@@ -241,6 +249,62 @@ export interface ISolanaWithdrawalQueue {
     head: bigint;
     tail: bigint;
 }
+/**
+ * `state::DepositParkingLot`: where async deposits wait to be forwarded.
+ *
+ * A FIFO addressed by sequence number rather than by position: `sequenceNumber`
+ * is the last handed out (the tail) and `queueStartIndex` the last settled (the
+ * head). Neither is ever reset, so `head === tail` means drained, not empty.
+ */
+export interface ISolanaParkingLotState {
+    address: PublicKey;
+    bump: number;
+    /** The bound vault. Immutable after construction. */
+    vault: PublicKey;
+    /** Runs `process_deposits` and the allow list. Rotated by the vault admin. */
+    operator: PublicKey;
+    /** Blocks new parks. Processing and cancellation stay live. */
+    depositsPaused: boolean;
+    /** Blocks cancellation. Parking and processing stay live. */
+    cancellationsPaused: boolean;
+    /** FIFO tail: the last sequence number handed out. */
+    sequenceNumber: bigint;
+    /** FIFO head: the last sequence number settled. Never reset. */
+    queueStartIndex: bigint;
+    /** Collateral escrowed for requests still pending. */
+    totalPendingAssets: bigint;
+    /**
+     * Solana-only: collateral owed to depositors whose refund could not be
+     * delivered, awaiting `claim_refund`. The escrow token account holds
+     * `totalPendingAssets + totalClaimableAssets`.
+     */
+    totalClaimableAssets: bigint;
+    /** Empty means open to all; otherwise only these may park. */
+    /**
+     * How many accounts the deposit allow list holds, not the accounts
+     * themselves: the list is unbounded and lives in one PDA per member, so
+     * there is nothing bounded to put here. 0 means the lot is open to all.
+     * Use `deriveParkingLotUser` to test one account.
+     */
+    depositAllowListCount: bigint;
+}
+/** `state::DepositRequest`: one parked deposit. */
+export interface ISolanaDepositRequest {
+    address: PublicKey;
+    bump: number;
+    parkingLot: PublicKey;
+    /** Its place in the lot's FIFO, and the seed of this account. */
+    sequenceNumber: bigint;
+    /** Escrowed the collateral; receives refunds and the rent. */
+    depositor: PublicKey;
+    /** Receives the minted vault shares. */
+    receiver: PublicKey;
+    assets: bigint;
+    /** Park time in ms. Informational, as in Move. */
+    timestamp: bigint;
+    /** Settled, but its refund is waiting to be claimed. */
+    claimable: boolean;
+}
 /** `state::ProtocolConfig`, decoded. */
 export interface ISolanaProtocolConfigState {
     admin: PublicKey;

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

@@ -30,7 +30,13 @@ export const SOLANA_SEEDS = {
     withdrawalRequest: "withdrawal_request",
     parkingLot: "parking_lot",
     parkingLotEscrow: "parking_lot_escrow",
-    depositRequest: "deposit_request"
+    depositRequest: "deposit_request",
+    // One entry PDA per allow-listed account. The lists are unbounded, so
+    // membership is the existence of this account rather than a Vec on the
+    // vault; every gated instruction takes the caller's entry, present or not.
+    depositUser: "deposit_user",
+    withdrawalUser: "withdrawal_user",
+    parkingLotUser: "parking_lot_user"
 };
 // 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

package/dist/src/solana-vaults/on-chain-calls/index.d.ts

@@ -1 +1,3 @@
+export * from "./tx-builder.js";
+export * from "./user.js";
 export * from "./vault-reader.js";

package/dist/src/solana-vaults/on-chain-calls/index.js

@@ -1 +1,3 @@
+export * from "./tx-builder.js";
+export * from "./user.js";
 export * from "./vault-reader.js";

package/dist/src/solana-vaults/on-chain-calls/tx-builder.d.ts

@@ -0,0 +1,135 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+/** Everything an instruction needs that cannot be derived from the share mint. */
+export interface ISolanaVaultContext {
+    programId: PublicKey;
+    shareMint: PublicKey;
+    collateralMint: PublicKey;
+    /** The owning program of each mint; they need not be the same one. */
+    shareProgram: PublicKey;
+    collateralProgram: PublicKey;
+}
+/**
+ * Builds the program's user instructions. Pure: it derives addresses and
+ * encodes data, and never touches the network or signs.
+ *
+ * Kept separate from SolanaUserCalls so a caller can batch several of these
+ * into one transaction, add their own instructions around them, or hand the
+ * result to a different sender — the same split the EVM side has.
+ */
+export declare class SolanaTxBuilder {
+    /**
+     * Creates an associated token account only if it is missing.
+     *
+     * `tokenProgram` is a parameter rather than a constant: an ATA's address
+     * derives from it, so a Token-2022 mint resolves somewhere else entirely
+     * and passing the SPL Token default would create an account at an address
+     * the program will not accept.
+     */
+    static createAtaIdempotent(payer: PublicKey, owner: PublicKey, mint: PublicKey, tokenProgram?: PublicKey): TransactionInstruction;
+    /**
+     * `deposit_asset`: moves collateral in and mints shares at the live rate.
+     *
+     * `minShares` is the slippage floor and is enforced on chain. It matters
+     * only if the rate manager moves the rate between quoting and landing.
+     */
+    static depositAsset(ctx: ISolanaVaultContext, depositor: PublicKey, amount: bigint, minShares: bigint): TransactionInstruction;
+    /**
+     * `mint_shares`: the same movement expressed the other way round — an exact
+     * share count out, with `maxAmount` capping the collateral it may consume.
+     */
+    static mintShares(ctx: ISolanaVaultContext, depositor: PublicKey, shares: bigint, maxAmount: bigint): TransactionInstruction;
+    /**
+     * `redeem_shares`: burns nothing yet — it escrows the shares into the
+     * vault's pending account and appends a request to the withdrawal queue.
+     * The operator settles it later, so this returns no collateral.
+     *
+     * `requestIndex` identifies the request account and must be the owner's
+     * next index; SolanaUserCalls reads it so callers do not have to.
+     */
+    static redeemShares(ctx: ISolanaVaultContext, owner: PublicKey, shares: bigint, requestNonce: bigint, receiver: PublicKey): TransactionInstruction;
+    /**
+     * `cancel_pending_withdrawal_request`: withdraws the request from the
+     * queue, identified by its `sequenceNumber`.
+     *
+     * Only four accounts, none of them token accounts. The escrowed shares are
+     * not moved here — the request is marked cancelled on the owner's
+     * VaultAccount and the operator returns the shares when it next settles —
+     * so neither the share mint, the pending-shares escrow nor the request's
+     * own account appear. Matches CancelWithdrawalRequest in withdraw.rs: note
+     * that `vault` and `owner` are both read-only.
+     */
+    static cancelPendingWithdrawalRequest(ctx: ISolanaVaultContext, owner: PublicKey, sequenceNumber: bigint): TransactionInstruction;
+    /** The lot and its escrow, derived from the vault's share mint. */
+    private static lotAccounts;
+    /**
+     * `parking_lot_deposit`: escrows collateral and queues a request.
+     *
+     * `sequenceNumber` MUST be the lot's current `sequence_number + 1`, since
+     * the program increments before it writes. That makes this racy by
+     * construction — if another park lands first the address is taken and the
+     * transaction fails — so it is read fresh in SolanaUserCalls rather than
+     * cached.
+     *
+     * `receiver` takes the minted shares when the request is forwarded; the
+     * depositor keeps the refund and the rent.
+     */
+    static parkingLotDeposit(ctx: ISolanaVaultContext, depositor: PublicKey, assets: bigint, sequenceNumber: bigint, receiver: PublicKey): TransactionInstruction;
+    /**
+     * `parking_lot_cancel_deposit`: withdraws a request before it settles and
+     * returns the escrowed collateral, closing the account to refund its rent.
+     *
+     * Takes the request's OWN sequence number, not the lot's next one.
+     */
+    static parkingLotCancelDeposit(ctx: ISolanaVaultContext, depositor: PublicKey, sequenceNumber: bigint): TransactionInstruction;
+    /**
+     * `parking_lot_claim_refund`: collects a refund that settlement could not
+     * deliver, for a request whose `claimable` flag is set.
+     *
+     * Identical account list to cancel — same four accounts, same order — so
+     * the two differ only in their discriminator and in what the program will
+     * accept.
+     */
+    static parkingLotClaimRefund(ctx: ISolanaVaultContext, depositor: PublicKey, sequenceNumber: bigint): TransactionInstruction;
+    private static refundLike;
+    /**
+     * `parking_lot_process_deposits`: forwards up to `numRequests` from the
+     * head of the queue into the vault, minting shares to each receiver.
+     *
+     * Operator-signed. The per-request accounts are not listed here: the
+     * program walks the queue from `queue_start_index` and reads each request
+     * through remaining_accounts, which the caller appends.
+     */
+    static parkingLotProcessDeposits(ctx: ISolanaVaultContext, operator: PublicKey, numRequests: bigint, remaining?: TransactionInstruction["keys"]): TransactionInstruction;
+    /** `parking_lot_process_deposits_up_to`: the same, bounded by sequence number. */
+    static parkingLotProcessDepositsUpTo(ctx: ISolanaVaultContext, operator: PublicKey, upToSequenceNumber: bigint, remaining?: TransactionInstruction["keys"]): TransactionInstruction;
+    private static processLike;
+    /**
+     * The four admin settings, which share one account list: config, vault,
+     * the lot, and the signer. They do NOT share one authority — the program
+     * decides, and the shapes being identical hides that:
+     *
+     * - `set_operator` — the vault admin.
+     * - `set_deposits_paused`, `set_cancellations_paused` — the GUARDIAN, via
+     *   `verify_guardian`, which also fails closed while no guardian is set.
+     * - `set_deposit_allow_list` — the lot's operator.
+     *
+     * Signing a pause with the vault admin key is rejected on chain.
+     */
+    private static lotSetting;
+    /** `parking_lot_set_operator`. */
+    static parkingLotSetOperator(ctx: ISolanaVaultContext, signer: PublicKey, newOperator: PublicKey): TransactionInstruction;
+    /** `parking_lot_set_deposits_paused`: blocks new parks only. */
+    static parkingLotSetDepositsPaused(ctx: ISolanaVaultContext, signer: PublicKey, paused: boolean): TransactionInstruction;
+    /** `parking_lot_set_cancellations_paused`: blocks cancellation only. */
+    static parkingLotSetCancellationsPaused(ctx: ISolanaVaultContext, signer: PublicKey, paused: boolean): TransactionInstruction;
+    /**
+     * `parking_lot_set_deposit_allow_list`: adds or removes one account.
+     * An empty list means the lot is open to everyone.
+     *
+     * Not built through `lotSetting`, unlike its three siblings: the list is
+     * unbounded, so adding an account CREATES its entry PDA and removing one
+     * closes it. That needs the entry and the system program, and makes the
+     * signer writable - it pays the rent, and is refunded on removal.
+     */
+    static parkingLotSetDepositAllowList(ctx: ISolanaVaultContext, signer: PublicKey, account: PublicKey, allowed: boolean): TransactionInstruction;
+}