@glamsystems/glam-sdk 1.0.2 → 1.0.3-alpha.0

package/src/deser/kaminoLayouts.d.ts

@@ -1,7 +1,8 @@
 import { BN } from "@coral-xyz/anchor";
 import { PublicKey } from "@solana/web3.js";
-export declare const VaultAllocationLayout: any;
-export declare const KVaultStateLayout: any;
+import { BigFractionBytes } from "../utils";
+import { Decodable } from "./base";
+import Decimal from "decimal.js";
 export interface KVaultAllocation {
     reserve: PublicKey;
     ctokenVault: PublicKey;
@@ -14,7 +15,7 @@ export interface KVaultAllocation {
     tokenTargetAllocationSf: BN;
     statePadding: BN[];
 }
-export interface KVaultState {
+export declare class KVaultState extends Decodable {
     discriminator: number[];
     vaultAdminAuthority: PublicKey;
     baseVaultAuthority: PublicKey;
@@ -52,4 +53,205 @@ export interface KVaultState {
     padding2: BN;
     allocationAdmin: PublicKey;
     padding3: BN[];
+    static _layout: any;
+    get nameStr(): string;
 }
+interface LastUpdate {
+    slot: BN;
+    stale: number;
+    priceStatus: number;
+    placeholder: number[];
+}
+interface PriceHeuristic {
+    lower: BN;
+    upper: BN;
+    exp: BN;
+}
+interface ScopeConfiguration {
+    priceFeed: PublicKey;
+    priceChain: number[];
+    twapChain: number[];
+}
+interface SwitchboardConfiguration {
+    priceAggregator: PublicKey;
+    twapAggregator: PublicKey;
+}
+interface PythConfiguration {
+    price: PublicKey;
+}
+interface TokenInfo {
+    name: number[];
+    heuristic: PriceHeuristic;
+    maxTwapDivergenceBps: BN;
+    maxAgePriceSeconds: BN;
+    maxAgeTwapSeconds: BN;
+    scopeConfiguration: ScopeConfiguration;
+    switchboardConfiguration: SwitchboardConfiguration;
+    pythConfiguration: PythConfiguration;
+    blockPriceUsage: number;
+    reserved: number[];
+    padding: BN[];
+}
+interface ReserveFees {
+    borrowFeeSf: BN;
+    flashLoanFeeSf: BN;
+    padding: number[];
+}
+interface CurvePoint {
+    utilizationRateBps: number;
+    borrowRateBps: number;
+}
+interface BorrowRateCurve {
+    points: CurvePoint[];
+}
+interface WithdrawalCaps {
+    configCapacity: BN;
+    currentTotal: BN;
+    lastIntervalStartTimestamp: BN;
+    configIntervalLengthSeconds: BN;
+}
+interface ReserveLiquidity {
+    mintPubkey: PublicKey;
+    supplyVault: PublicKey;
+    feeVault: PublicKey;
+    availableAmount: BN;
+    borrowedAmountSf: BN;
+    marketPriceSf: BN;
+    marketPriceLastUpdatedTs: BN;
+    mintDecimals: BN;
+    depositLimitCrossedTimestamp: BN;
+    borrowLimitCrossedTimestamp: BN;
+    cumulativeBorrowRateBsf: BigFractionBytes;
+    accumulatedProtocolFeesSf: BN;
+    accumulatedReferrerFeesSf: BN;
+    pendingReferrerFeesSf: BN;
+    absoluteReferralRateSf: BN;
+    tokenProgram: PublicKey;
+    padding2: BN[];
+    padding3: BN[];
+}
+interface ReserveCollateral {
+    mintPubkey: PublicKey;
+    mintTotalSupply: BN;
+    supplyVault: PublicKey;
+    padding1: BN[];
+    padding2: BN[];
+}
+interface ReserveConfig {
+    status: number;
+    assetTier: number;
+    hostFixedInterestRateBps: number;
+    reserved2: number[];
+    protocolOrderExecutionFeePct: number;
+    protocolTakeRatePct: number;
+    protocolLiquidationFeePct: number;
+    loanToValuePct: number;
+    liquidationThresholdPct: number;
+    minLiquidationBonusBps: number;
+    maxLiquidationBonusBps: number;
+    badDebtLiquidationBonusBps: number;
+    deleveragingMarginCallPeriodSecs: BN;
+    deleveragingThresholdDecreaseBpsPerDay: BN;
+    fees: ReserveFees;
+    borrowRateCurve: BorrowRateCurve;
+    borrowFactorPct: BN;
+    depositLimit: BN;
+    borrowLimit: BN;
+    tokenInfo: TokenInfo;
+    depositWithdrawalCap: WithdrawalCaps;
+    debtWithdrawalCap: WithdrawalCaps;
+    elevationGroups: number[];
+    disableUsageAsCollOutsideEmode: number;
+    utilizationLimitBlockBorrowingAbovePct: number;
+    autodeleverageEnabled: number;
+    reserved1: number[];
+    borrowLimitOutsideElevationGroup: BN;
+    borrowLimitAgainstThisCollateralInElevationGroup: BN[];
+}
+export declare class Reserve extends Decodable {
+    discriminator: number[];
+    version: BN;
+    lastUpdate: LastUpdate;
+    lendingMarket: PublicKey;
+    farmCollateral: PublicKey;
+    farmDebt: PublicKey;
+    liquidity: ReserveLiquidity;
+    reserveLiquidityPadding: BN[];
+    collateral: ReserveCollateral;
+    reserveCollateralPadding: BN[];
+    config: ReserveConfig;
+    configPadding: BN[];
+    borrowedAmountOutsideElevationGroup: BN;
+    borrowedAmountsAgainstThisReserveInElevationGroups: BN[];
+    padding: BN[];
+    static _layout: any;
+    get cumulativeBorrowRate(): Decimal;
+    /**
+     * @returns the stale exchange rate between the collateral tokens and the liquidity - this is a decimal number scaled by 1e18
+     */
+    get collateralExchangeRate(): Decimal;
+    get totalSupply(): Decimal;
+    get borrowedAmount(): Decimal;
+    get accumulatedProtocolFees(): Decimal;
+    get accumulatedReferrerFees(): Decimal;
+    get pendingReferrerFees(): Decimal;
+}
+interface ObligationCollateral {
+    depositReserve: PublicKey;
+    depositedAmount: BN;
+    marketValueSf: BN;
+    borrowedAmountAgainstThisCollateralInElevationGroup: BN;
+    padding: BN[];
+}
+interface ObligationLiquidity {
+    borrowReserve: PublicKey;
+    cumulativeBorrowRateBsf: BigFractionBytes;
+    padding: BN;
+    borrowedAmountSf: BN;
+    marketValueSf: BN;
+    borrowFactorAdjustedMarketValueSf: BN;
+    borrowedAmountOutsideElevationGroups: BN;
+    padding2: BN[];
+}
+interface ObligationOrder {
+    conditionThresholdSf: BN;
+    opportunityParameterSf: BN;
+    minExecutionBonusBps: number;
+    maxExecutionBonusBps: number;
+    conditionType: number;
+    opportunityType: number;
+    padding1: number[];
+    padding2: BN[];
+}
+export declare class Obligation extends Decodable {
+    discriminator: number[];
+    tag: BN;
+    lastUpdate: LastUpdate;
+    lendingMarket: PublicKey;
+    owner: PublicKey;
+    deposits: ObligationCollateral[];
+    lowestReserveDepositLiquidationLtv: BN;
+    depositedValueSf: BN;
+    borrows: ObligationLiquidity[];
+    borrowFactorAdjustedDebtValueSf: BN;
+    borrowedAssetsMarketValueSf: BN;
+    allowedBorrowValueSf: BN;
+    unhealthyBorrowValueSf: BN;
+    depositsAssetTiers: number[];
+    borrowsAssetTiers: number[];
+    elevationGroup: number;
+    numOfObsoleteDepositReserves: number;
+    hasDebt: number;
+    referrer: PublicKey;
+    borrowingDisabled: number;
+    autodeleverageTargetLtvPct: number;
+    lowestReserveDepositMaxLtvPct: number;
+    numOfObsoleteBorrowReserves: number;
+    reserved: number[];
+    highestBorrowFactorPct: BN;
+    autodeleverageMarginCallStartedTimestamp: BN;
+    orders: ObligationOrder[];
+    padding3: BN[];
+    static _layout: any;
+}
+export {};

package/src/index.d.ts

@@ -5,6 +5,7 @@ export * from "./client";
 export * from "./client/jupiter";
 export * from "./client/drift";
 export * from "./client/timelock";
+export * from "./client/cctp";
 export * from "./deser/integrationPolicies";
 export * from "./client/base";
 export * from "./assets";

package/src/models/mint.d.ts

@@ -56,3 +56,9 @@ export declare class RequestType {
         redemption: {};
     };
 }
+export type OracleConfigsType = IdlTypes<GlamProtocol>["oracleConfigs"];
+export declare class OracleConfigs implements OracleConfigsType {
+    readonly maxAgesSeconds: number[][];
+    padding: number[];
+    constructor(maxAgesSeconds: number[][]);
+}

package/src/models/types.d.ts

@@ -1,6 +1,5 @@
 import { IdlTypes } from "@coral-xyz/anchor";
 import { GlamMint } from "../glamExports";
-import { PublicKey } from "@solana/web3.js";
 export type RequestQueue = IdlTypes<GlamMint>["requestQueue"];
 export type PendingRequest = IdlTypes<GlamMint>["pendingRequest"];
 export declare class PriceDenom {
@@ -10,21 +9,6 @@ export declare class PriceDenom {
     static readonly USD: {
         usd: {};
     };
-    static readonly ASSET: {
-        asset6: {};
-    };
-    static fromAsset(asset: PublicKey): {
-        sol: {};
-    } | {
-        usd: {};
-    } | {
-        asset6: {};
-    };
-    static fromString(str: string): {
-        sol: {};
-    } | {
-        usd: {};
-    };
 }
 export declare class TimeUnit {
     static readonly Slot: {

package/src/utils/common.d.ts

@@ -1,3 +1,4 @@
+import { BN } from "@coral-xyz/anchor";
 /**
  * Compares two sets for equality
  */
@@ -10,3 +11,4 @@ export declare function charsToName(chars: number[] | Buffer): string;
  * Converts a string to an array of character codes (max 32 bytes)
  */
 export declare function nameToChars(name: string): number[];
+export declare function toUiAmount(amount: BN, decimals: number): number;

package/src/utils/fraction.d.ts

@@ -0,0 +1,29 @@
+import { BN } from "@coral-xyz/anchor";
+import Decimal from "decimal.js";
+export interface BigFractionBytes {
+    value: BN[];
+    padding: BN[];
+}
+/**
+ * Replicates the Fraction class from the klend-sdk:
+ * https://github.com/Kamino-Finance/klend-sdk/blob/2fbc31a5b165aca3e2ca2e3d0e6162848743192d/src/classes/fraction.ts#L26
+ */
+export declare class Fraction {
+    static MAX_SIZE_F: number;
+    static MAX_SIZE_BF: number;
+    static FRACTIONS: number;
+    static MULTIPLIER: Decimal;
+    static MAX_F_BN: any;
+    static MAX_BF_BN: any;
+    static MIN_BN: any;
+    valueSf: BN;
+    constructor(valueSf: BN);
+    toDecimal(): Decimal;
+    getValue(): BN;
+    gt(x: Fraction): boolean;
+    lt(x: Fraction): boolean;
+    gte(x: Fraction): boolean;
+    lte(x: Fraction): boolean;
+    eq(x: Fraction): boolean;
+}
+export declare function bfToDecimal(x: BigFractionBytes): Decimal;

package/src/utils/index.d.ts

@@ -13,3 +13,6 @@ export * from "./rpc";
 export * from "./timelock";
 export * from "./transaction";
 export * from "./drift";
+export * from "./pkmap";
+export * from "./pkset";
+export * from "./fraction";

package/src/utils/pkmap.d.ts

@@ -0,0 +1,82 @@
+import { PublicKey } from "@solana/web3.js";
+/**
+ * A Map implementation that uses PublicKey as keys.
+ *
+ * This class extends the standard Map and allows using PublicKey objects
+ * as keys by converting them to base58 strings internally. This solves the
+ * problem of PublicKey object reference equality - two PublicKey objects
+ * with the same address would normally be considered different keys in a Map.
+ *
+ * @example
+ * ```typescript
+ * // Create empty map
+ * const map = new PkMap<string>();
+ * const key = new PublicKey("11111111111111111111111111111111");
+ * map.set(key, "value");
+ *
+ * // Create with initial entries
+ * const map2 = new PkMap<string>([
+ *   [new PublicKey("11111111111111111111111111111111"), "value1"],
+ *   [new PublicKey("22222222222222222222222222222222"), "value2"]
+ * ]);
+ *
+ * // Can retrieve with a different PublicKey object with same address
+ * const sameKey = new PublicKey("11111111111111111111111111111111");
+ * console.log(map.get(sameKey)); // "value"
+ * ```
+ */
+export declare class PkMap<V> {
+    private readonly _map;
+    /**
+     * Creates a new PkMap instance.
+     * @param entries - Optional initial entries as [PublicKey, V] pairs
+     */
+    constructor(entries?: readonly (readonly [PublicKey, V])[] | null);
+    /**
+     * Associates the specified value with the specified PublicKey in this map.
+     * @param key - The PublicKey to use as the key
+     * @param value - The value to associate with the key
+     * @returns This PkMap instance for chaining
+     */
+    set(key: PublicKey, value: V): this;
+    /**
+     * Returns the value associated with the specified PublicKey, or undefined if not found.
+     * @param key - The PublicKey whose associated value is to be returned
+     * @returns The value associated with the specified key, or undefined
+     */
+    get(key: PublicKey): V | undefined;
+    /**
+     * Returns true if this map contains a mapping for the specified PublicKey.
+     * @param key - The PublicKey whose presence in this map is to be tested
+     * @returns true if this map contains a mapping for the specified key
+     */
+    has(key: PublicKey): boolean;
+    /**
+     * Removes the mapping for the specified PublicKey from this map if present.
+     * @param key - The PublicKey whose mapping is to be removed
+     * @returns true if the element was removed, false otherwise
+     */
+    delete(key: PublicKey): boolean;
+    /**
+     * Returns an iterator of all PublicKey keys in this map.
+     * Note: This reconstructs PublicKey objects from the stored base58 strings.
+     * @returns An iterator of PublicKey objects
+     */
+    pkKeys(): IterableIterator<PublicKey>;
+    /**
+     * Returns an iterator of [PublicKey, value] pairs for every entry in the map.
+     * Note: This reconstructs PublicKey objects from the stored base58 strings.
+     * @returns An iterator of [PublicKey, V] tuples
+     */
+    pkEntries(): IterableIterator<[PublicKey, V]>;
+    /**
+     * Executes a provided function once per each PublicKey/value pair in the Map.
+     * @param callbackfn - Function to execute for each entry
+     * @param thisArg - Value to use as this when executing callback
+     */
+    forEachPk(callbackfn: (value: V, key: PublicKey, map: PkMap<V>) => void, thisArg?: any): void;
+    get size(): number;
+    clear(): void;
+    values(): IterableIterator<V>;
+    [Symbol.iterator](): IterableIterator<[PublicKey, V]>;
+}

package/src/utils/pkset.d.ts

@@ -0,0 +1,73 @@
+import { PublicKey } from "@solana/web3.js";
+/**
+ * A Set implementation that uses PublicKey as values.
+ *
+ * This class extends the standard Set and allows using PublicKey objects
+ * as values by converting them to base58 strings internally. This solves the
+ * problem of PublicKey object reference equality - two PublicKey objects
+ * with the same address would normally be considered different values in a Set.
+ *
+ * @example
+ * ```typescript
+ * // Create empty set
+ * const set = new PkSet();
+ * const key = new PublicKey("11111111111111111111111111111111");
+ * set.add(key);
+ *
+ * // Create with initial values
+ * const set2 = new PkSet([
+ *   new PublicKey("11111111111111111111111111111111"),
+ *   new PublicKey("22222222222222222222222222222222")
+ * ]);
+ *
+ * // Can check with a different PublicKey object with same address
+ * const sameKey = new PublicKey("11111111111111111111111111111111");
+ * console.log(set.has(sameKey)); // true
+ * ```
+ */
+export declare class PkSet {
+    private readonly _set;
+    /**
+     * Creates a new PkSet instance.
+     * @param values - Optional initial values as PublicKey array
+     */
+    constructor(values?: readonly PublicKey[] | null);
+    /**
+     * Adds the specified PublicKey to this set.
+     * @param value - The PublicKey to add to the set
+     * @returns This PkSet instance for chaining
+     */
+    add(value: PublicKey): this;
+    /**
+     * Returns true if this set contains the specified PublicKey.
+     * @param value - The PublicKey whose presence in this set is to be tested
+     * @returns true if this set contains the specified PublicKey
+     */
+    has(value: PublicKey): boolean;
+    /**
+     * Removes the specified PublicKey from this set if present.
+     * @param value - The PublicKey to be removed
+     * @returns true if the element was removed, false otherwise
+     */
+    delete(value: PublicKey): boolean;
+    /**
+     * Returns an iterator of all PublicKey values in this set.
+     * Note: This reconstructs PublicKey objects from the stored base58 strings.
+     * @returns An iterator of PublicKey objects
+     */
+    pkValues(): IterableIterator<PublicKey>;
+    /**
+     * Executes a provided function once per each PublicKey in the Set.
+     * @param callbackfn - Function to execute for each value
+     * @param thisArg - Value to use as this when executing callback
+     */
+    forEachPk(callbackfn: (value: PublicKey, value2: PublicKey, set: PkSet) => void, thisArg?: any): void;
+    get size(): number;
+    clear(): void;
+    [Symbol.iterator](): IterableIterator<PublicKey>;
+    equals(other: PkSet): boolean;
+    /**
+     * @returns true if this set contains all the PublicKeys in the other set
+     */
+    includes(other: PkSet): boolean;
+}