@kamino-finance/klend-sdk 5.0.4 → 5.0.5

package/src/idl_codegen_kamino_vault/types/TokenInfo.ts

@@ -1,104 +1,104 @@
-import { PublicKey } from '@solana/web3.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
-import BN from 'bn.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
-import * as types from '../types'; // eslint-disable-line @typescript-eslint/no-unused-vars
-import * as borsh from '@coral-xyz/borsh';
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
 
 export interface TokenInfoFields {
   /** UTF-8 encoded name of the token (null-terminated) */
-  name: Array<number>;
+  name: Array<number>
   /** Heuristics limits of acceptable price */
-  heuristic: types.PriceHeuristicFields;
+  heuristic: types.PriceHeuristicFields
   /** Max divergence between twap and price in bps */
-  maxTwapDivergenceBps: BN;
-  maxAgePriceSeconds: BN;
-  maxAgeTwapSeconds: BN;
+  maxTwapDivergenceBps: BN
+  maxAgePriceSeconds: BN
+  maxAgeTwapSeconds: BN
   /** Scope price configuration */
-  scopeConfiguration: types.ScopeConfigurationFields;
+  scopeConfiguration: types.ScopeConfigurationFields
   /** Switchboard configuration */
-  switchboardConfiguration: types.SwitchboardConfigurationFields;
+  switchboardConfiguration: types.SwitchboardConfigurationFields
   /** Pyth configuration */
-  pythConfiguration: types.PythConfigurationFields;
-  blockPriceUsage: number;
-  reserved: Array<number>;
-  padding: Array<BN>;
+  pythConfiguration: types.PythConfigurationFields
+  blockPriceUsage: number
+  reserved: Array<number>
+  padding: Array<BN>
 }
 
 export interface TokenInfoJSON {
   /** UTF-8 encoded name of the token (null-terminated) */
-  name: Array<number>;
+  name: Array<number>
   /** Heuristics limits of acceptable price */
-  heuristic: types.PriceHeuristicJSON;
+  heuristic: types.PriceHeuristicJSON
   /** Max divergence between twap and price in bps */
-  maxTwapDivergenceBps: string;
-  maxAgePriceSeconds: string;
-  maxAgeTwapSeconds: string;
+  maxTwapDivergenceBps: string
+  maxAgePriceSeconds: string
+  maxAgeTwapSeconds: string
   /** Scope price configuration */
-  scopeConfiguration: types.ScopeConfigurationJSON;
+  scopeConfiguration: types.ScopeConfigurationJSON
   /** Switchboard configuration */
-  switchboardConfiguration: types.SwitchboardConfigurationJSON;
+  switchboardConfiguration: types.SwitchboardConfigurationJSON
   /** Pyth configuration */
-  pythConfiguration: types.PythConfigurationJSON;
-  blockPriceUsage: number;
-  reserved: Array<number>;
-  padding: Array<string>;
+  pythConfiguration: types.PythConfigurationJSON
+  blockPriceUsage: number
+  reserved: Array<number>
+  padding: Array<string>
 }
 
 export class TokenInfo {
   /** UTF-8 encoded name of the token (null-terminated) */
-  readonly name: Array<number>;
+  readonly name: Array<number>
   /** Heuristics limits of acceptable price */
-  readonly heuristic: types.PriceHeuristic;
+  readonly heuristic: types.PriceHeuristic
   /** Max divergence between twap and price in bps */
-  readonly maxTwapDivergenceBps: BN;
-  readonly maxAgePriceSeconds: BN;
-  readonly maxAgeTwapSeconds: BN;
+  readonly maxTwapDivergenceBps: BN
+  readonly maxAgePriceSeconds: BN
+  readonly maxAgeTwapSeconds: BN
   /** Scope price configuration */
-  readonly scopeConfiguration: types.ScopeConfiguration;
+  readonly scopeConfiguration: types.ScopeConfiguration
   /** Switchboard configuration */
-  readonly switchboardConfiguration: types.SwitchboardConfiguration;
+  readonly switchboardConfiguration: types.SwitchboardConfiguration
   /** Pyth configuration */
-  readonly pythConfiguration: types.PythConfiguration;
-  readonly blockPriceUsage: number;
-  readonly reserved: Array<number>;
-  readonly padding: Array<BN>;
+  readonly pythConfiguration: types.PythConfiguration
+  readonly blockPriceUsage: number
+  readonly reserved: Array<number>
+  readonly padding: Array<BN>
 
   constructor(fields: TokenInfoFields) {
-    this.name = fields.name;
-    this.heuristic = new types.PriceHeuristic({ ...fields.heuristic });
-    this.maxTwapDivergenceBps = fields.maxTwapDivergenceBps;
-    this.maxAgePriceSeconds = fields.maxAgePriceSeconds;
-    this.maxAgeTwapSeconds = fields.maxAgeTwapSeconds;
+    this.name = fields.name
+    this.heuristic = new types.PriceHeuristic({ ...fields.heuristic })
+    this.maxTwapDivergenceBps = fields.maxTwapDivergenceBps
+    this.maxAgePriceSeconds = fields.maxAgePriceSeconds
+    this.maxAgeTwapSeconds = fields.maxAgeTwapSeconds
     this.scopeConfiguration = new types.ScopeConfiguration({
       ...fields.scopeConfiguration,
-    });
+    })
     this.switchboardConfiguration = new types.SwitchboardConfiguration({
       ...fields.switchboardConfiguration,
-    });
+    })
     this.pythConfiguration = new types.PythConfiguration({
       ...fields.pythConfiguration,
-    });
-    this.blockPriceUsage = fields.blockPriceUsage;
-    this.reserved = fields.reserved;
-    this.padding = fields.padding;
+    })
+    this.blockPriceUsage = fields.blockPriceUsage
+    this.reserved = fields.reserved
+    this.padding = fields.padding
   }
 
   static layout(property?: string) {
     return borsh.struct(
       [
-        borsh.array(borsh.u8(), 32, 'name'),
-        types.PriceHeuristic.layout('heuristic'),
-        borsh.u64('maxTwapDivergenceBps'),
-        borsh.u64('maxAgePriceSeconds'),
-        borsh.u64('maxAgeTwapSeconds'),
-        types.ScopeConfiguration.layout('scopeConfiguration'),
-        types.SwitchboardConfiguration.layout('switchboardConfiguration'),
-        types.PythConfiguration.layout('pythConfiguration'),
-        borsh.u8('blockPriceUsage'),
-        borsh.array(borsh.u8(), 7, 'reserved'),
-        borsh.array(borsh.u64(), 19, 'padding'),
+        borsh.array(borsh.u8(), 32, "name"),
+        types.PriceHeuristic.layout("heuristic"),
+        borsh.u64("maxTwapDivergenceBps"),
+        borsh.u64("maxAgePriceSeconds"),
+        borsh.u64("maxAgeTwapSeconds"),
+        types.ScopeConfiguration.layout("scopeConfiguration"),
+        types.SwitchboardConfiguration.layout("switchboardConfiguration"),
+        types.PythConfiguration.layout("pythConfiguration"),
+        borsh.u8("blockPriceUsage"),
+        borsh.array(borsh.u8(), 7, "reserved"),
+        borsh.array(borsh.u64(), 19, "padding"),
       ],
       property
-    );
+    )
   }
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -109,13 +109,19 @@ export class TokenInfo {
       maxTwapDivergenceBps: obj.maxTwapDivergenceBps,
       maxAgePriceSeconds: obj.maxAgePriceSeconds,
       maxAgeTwapSeconds: obj.maxAgeTwapSeconds,
-      scopeConfiguration: types.ScopeConfiguration.fromDecoded(obj.scopeConfiguration),
-      switchboardConfiguration: types.SwitchboardConfiguration.fromDecoded(obj.switchboardConfiguration),
-      pythConfiguration: types.PythConfiguration.fromDecoded(obj.pythConfiguration),
+      scopeConfiguration: types.ScopeConfiguration.fromDecoded(
+        obj.scopeConfiguration
+      ),
+      switchboardConfiguration: types.SwitchboardConfiguration.fromDecoded(
+        obj.switchboardConfiguration
+      ),
+      pythConfiguration: types.PythConfiguration.fromDecoded(
+        obj.pythConfiguration
+      ),
       blockPriceUsage: obj.blockPriceUsage,
       reserved: obj.reserved,
       padding: obj.padding,
-    });
+    })
   }
 
   static toEncodable(fields: TokenInfoFields) {
@@ -125,13 +131,19 @@ export class TokenInfo {
       maxTwapDivergenceBps: fields.maxTwapDivergenceBps,
       maxAgePriceSeconds: fields.maxAgePriceSeconds,
       maxAgeTwapSeconds: fields.maxAgeTwapSeconds,
-      scopeConfiguration: types.ScopeConfiguration.toEncodable(fields.scopeConfiguration),
-      switchboardConfiguration: types.SwitchboardConfiguration.toEncodable(fields.switchboardConfiguration),
-      pythConfiguration: types.PythConfiguration.toEncodable(fields.pythConfiguration),
+      scopeConfiguration: types.ScopeConfiguration.toEncodable(
+        fields.scopeConfiguration
+      ),
+      switchboardConfiguration: types.SwitchboardConfiguration.toEncodable(
+        fields.switchboardConfiguration
+      ),
+      pythConfiguration: types.PythConfiguration.toEncodable(
+        fields.pythConfiguration
+      ),
       blockPriceUsage: fields.blockPriceUsage,
       reserved: fields.reserved,
       padding: fields.padding,
-    };
+    }
   }
 
   toJSON(): TokenInfoJSON {
@@ -147,7 +159,7 @@ export class TokenInfo {
       blockPriceUsage: this.blockPriceUsage,
       reserved: this.reserved,
       padding: this.padding.map((item) => item.toString()),
-    };
+    }
   }
 
   static fromJSON(obj: TokenInfoJSON): TokenInfo {
@@ -157,16 +169,22 @@ export class TokenInfo {
       maxTwapDivergenceBps: new BN(obj.maxTwapDivergenceBps),
       maxAgePriceSeconds: new BN(obj.maxAgePriceSeconds),
       maxAgeTwapSeconds: new BN(obj.maxAgeTwapSeconds),
-      scopeConfiguration: types.ScopeConfiguration.fromJSON(obj.scopeConfiguration),
-      switchboardConfiguration: types.SwitchboardConfiguration.fromJSON(obj.switchboardConfiguration),
-      pythConfiguration: types.PythConfiguration.fromJSON(obj.pythConfiguration),
+      scopeConfiguration: types.ScopeConfiguration.fromJSON(
+        obj.scopeConfiguration
+      ),
+      switchboardConfiguration: types.SwitchboardConfiguration.fromJSON(
+        obj.switchboardConfiguration
+      ),
+      pythConfiguration: types.PythConfiguration.fromJSON(
+        obj.pythConfiguration
+      ),
       blockPriceUsage: obj.blockPriceUsage,
       reserved: obj.reserved,
       padding: obj.padding.map((item) => new BN(item)),
-    });
+    })
   }
 
   toEncodable() {
-    return TokenInfo.toEncodable(this);
+    return TokenInfo.toEncodable(this)
   }
 }

package/src/idl_codegen_kamino_vault/types/VaultAllocation.ts

@@ -1,115 +1,133 @@
-import { PublicKey } from '@solana/web3.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
-import BN from 'bn.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
-import * as types from '../types'; // eslint-disable-line @typescript-eslint/no-unused-vars
-import * as borsh from '@coral-xyz/borsh';
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
 
 export interface VaultAllocationFields {
-  reserve: PublicKey;
-  targetAllocationWeight: BN;
+  reserve: PublicKey
+  ctokenVault: PublicKey
+  targetAllocationWeight: BN
   /** Maximum token invested in this reserve */
-  tokenAllocationCap: BN;
-  configPadding: Array<BN>;
-  cTokenAllocation: BN;
-  tokenTargetAllocation: BN;
-  statePadding: Array<BN>;
+  tokenAllocationCap: BN
+  configPadding: Array<BN>
+  cTokenAllocation: BN
+  lastInvestSlot: BN
+  tokenTargetAllocationSf: BN
+  statePadding: Array<BN>
 }
 
 export interface VaultAllocationJSON {
-  reserve: string;
-  targetAllocationWeight: string;
+  reserve: string
+  ctokenVault: string
+  targetAllocationWeight: string
   /** Maximum token invested in this reserve */
-  tokenAllocationCap: string;
-  configPadding: Array<string>;
-  cTokenAllocation: string;
-  tokenTargetAllocation: string;
-  statePadding: Array<string>;
+  tokenAllocationCap: string
+  configPadding: Array<string>
+  cTokenAllocation: string
+  lastInvestSlot: string
+  tokenTargetAllocationSf: string
+  statePadding: Array<string>
 }
 
 export class VaultAllocation {
-  readonly reserve: PublicKey;
-  readonly targetAllocationWeight: BN;
+  readonly reserve: PublicKey
+  readonly ctokenVault: PublicKey
+  readonly targetAllocationWeight: BN
   /** Maximum token invested in this reserve */
-  readonly tokenAllocationCap: BN;
-  readonly configPadding: Array<BN>;
-  readonly cTokenAllocation: BN;
-  readonly tokenTargetAllocation: BN;
-  readonly statePadding: Array<BN>;
+  readonly tokenAllocationCap: BN
+  readonly configPadding: Array<BN>
+  readonly cTokenAllocation: BN
+  readonly lastInvestSlot: BN
+  readonly tokenTargetAllocationSf: BN
+  readonly statePadding: Array<BN>
 
   constructor(fields: VaultAllocationFields) {
-    this.reserve = fields.reserve;
-    this.targetAllocationWeight = fields.targetAllocationWeight;
-    this.tokenAllocationCap = fields.tokenAllocationCap;
-    this.configPadding = fields.configPadding;
-    this.cTokenAllocation = fields.cTokenAllocation;
-    this.tokenTargetAllocation = fields.tokenTargetAllocation;
-    this.statePadding = fields.statePadding;
+    this.reserve = fields.reserve
+    this.ctokenVault = fields.ctokenVault
+    this.targetAllocationWeight = fields.targetAllocationWeight
+    this.tokenAllocationCap = fields.tokenAllocationCap
+    this.configPadding = fields.configPadding
+    this.cTokenAllocation = fields.cTokenAllocation
+    this.lastInvestSlot = fields.lastInvestSlot
+    this.tokenTargetAllocationSf = fields.tokenTargetAllocationSf
+    this.statePadding = fields.statePadding
   }
 
   static layout(property?: string) {
     return borsh.struct(
       [
-        borsh.publicKey('reserve'),
-        borsh.u64('targetAllocationWeight'),
-        borsh.u64('tokenAllocationCap'),
-        borsh.array(borsh.u128(), 64, 'configPadding'),
-        borsh.u64('cTokenAllocation'),
-        borsh.u64('tokenTargetAllocation'),
-        borsh.array(borsh.u128(), 64, 'statePadding'),
+        borsh.publicKey("reserve"),
+        borsh.publicKey("ctokenVault"),
+        borsh.u64("targetAllocationWeight"),
+        borsh.u64("tokenAllocationCap"),
+        borsh.array(borsh.u64(), 128, "configPadding"),
+        borsh.u64("cTokenAllocation"),
+        borsh.u64("lastInvestSlot"),
+        borsh.u128("tokenTargetAllocationSf"),
+        borsh.array(borsh.u64(), 128, "statePadding"),
       ],
       property
-    );
+    )
   }
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   static fromDecoded(obj: any) {
     return new VaultAllocation({
       reserve: obj.reserve,
+      ctokenVault: obj.ctokenVault,
       targetAllocationWeight: obj.targetAllocationWeight,
       tokenAllocationCap: obj.tokenAllocationCap,
       configPadding: obj.configPadding,
       cTokenAllocation: obj.cTokenAllocation,
-      tokenTargetAllocation: obj.tokenTargetAllocation,
+      lastInvestSlot: obj.lastInvestSlot,
+      tokenTargetAllocationSf: obj.tokenTargetAllocationSf,
       statePadding: obj.statePadding,
-    });
+    })
   }
 
   static toEncodable(fields: VaultAllocationFields) {
     return {
       reserve: fields.reserve,
+      ctokenVault: fields.ctokenVault,
       targetAllocationWeight: fields.targetAllocationWeight,
       tokenAllocationCap: fields.tokenAllocationCap,
       configPadding: fields.configPadding,
       cTokenAllocation: fields.cTokenAllocation,
-      tokenTargetAllocation: fields.tokenTargetAllocation,
+      lastInvestSlot: fields.lastInvestSlot,
+      tokenTargetAllocationSf: fields.tokenTargetAllocationSf,
       statePadding: fields.statePadding,
-    };
+    }
   }
 
   toJSON(): VaultAllocationJSON {
     return {
       reserve: this.reserve.toString(),
+      ctokenVault: this.ctokenVault.toString(),
       targetAllocationWeight: this.targetAllocationWeight.toString(),
       tokenAllocationCap: this.tokenAllocationCap.toString(),
       configPadding: this.configPadding.map((item) => item.toString()),
       cTokenAllocation: this.cTokenAllocation.toString(),
-      tokenTargetAllocation: this.tokenTargetAllocation.toString(),
+      lastInvestSlot: this.lastInvestSlot.toString(),
+      tokenTargetAllocationSf: this.tokenTargetAllocationSf.toString(),
       statePadding: this.statePadding.map((item) => item.toString()),
-    };
+    }
   }
 
   static fromJSON(obj: VaultAllocationJSON): VaultAllocation {
     return new VaultAllocation({
       reserve: new PublicKey(obj.reserve),
+      ctokenVault: new PublicKey(obj.ctokenVault),
       targetAllocationWeight: new BN(obj.targetAllocationWeight),
       tokenAllocationCap: new BN(obj.tokenAllocationCap),
       configPadding: obj.configPadding.map((item) => new BN(item)),
       cTokenAllocation: new BN(obj.cTokenAllocation),
-      tokenTargetAllocation: new BN(obj.tokenTargetAllocation),
+      lastInvestSlot: new BN(obj.lastInvestSlot),
+      tokenTargetAllocationSf: new BN(obj.tokenTargetAllocationSf),
       statePadding: obj.statePadding.map((item) => new BN(item)),
-    });
+    })
   }
 
   toEncodable() {
-    return VaultAllocation.toEncodable(this);
+    return VaultAllocation.toEncodable(this)
   }
 }