@haven-fi/solauto-sdk 1.0.176 → 1.0.178

package/src/generated/errors/solauto.ts

@@ -32,18 +32,14 @@ export class IncorrectAccountsError extends ProgramError {
 codeToErrorMap.set(0x0, IncorrectAccountsError);
 nameToErrorMap.set('IncorrectAccounts', IncorrectAccountsError);
 
-/** FailedAccountDeserialization: Failed to deserialize account data, incorrect account was likely given */
+/** FailedAccountDeserialization: Failed to deserialize account data */
 export class FailedAccountDeserializationError extends ProgramError {
   override readonly name: string = 'FailedAccountDeserialization';
 
   readonly code: number = 0x1; // 1
 
   constructor(program: Program, cause?: Error) {
-    super(
-      'Failed to deserialize account data, incorrect account was likely given',
-      program,
-      cause
-    );
+    super('Failed to deserialize account data', program, cause);
   }
 }
 codeToErrorMap.set(0x1, FailedAccountDeserializationError);
@@ -52,154 +48,100 @@ nameToErrorMap.set(
   FailedAccountDeserializationError
 );
 
-/** InvalidPositionSettings: Invalid position settings given */
+/** InvalidPositionSettings: Invalid position settings provided */
 export class InvalidPositionSettingsError extends ProgramError {
   override readonly name: string = 'InvalidPositionSettings';
 
   readonly code: number = 0x2; // 2
 
   constructor(program: Program, cause?: Error) {
-    super('Invalid position settings given', program, cause);
+    super('Invalid position settings provided', program, cause);
   }
 }
 codeToErrorMap.set(0x2, InvalidPositionSettingsError);
 nameToErrorMap.set('InvalidPositionSettings', InvalidPositionSettingsError);
 
-/** InvalidDCASettings: Invalid DCA settings given */
+/** InvalidDCASettings: Invalid DCA configuration provided */
 export class InvalidDCASettingsError extends ProgramError {
   override readonly name: string = 'InvalidDCASettings';
 
   readonly code: number = 0x3; // 3
 
   constructor(program: Program, cause?: Error) {
-    super('Invalid DCA settings given', program, cause);
+    super('Invalid DCA configuration provided', program, cause);
   }
 }
 codeToErrorMap.set(0x3, InvalidDCASettingsError);
 nameToErrorMap.set('InvalidDCASettings', InvalidDCASettingsError);
 
-/** InvalidAutomationData: Invalid automation data given */
+/** InvalidAutomationData: Invalid automation settings provided */
 export class InvalidAutomationDataError extends ProgramError {
   override readonly name: string = 'InvalidAutomationData';
 
   readonly code: number = 0x4; // 4
 
   constructor(program: Program, cause?: Error) {
-    super('Invalid automation data given', program, cause);
+    super('Invalid automation settings provided', program, cause);
   }
 }
 codeToErrorMap.set(0x4, InvalidAutomationDataError);
 nameToErrorMap.set('InvalidAutomationData', InvalidAutomationDataError);
 
-/** StaleProtocolData: Stale protocol data. Refresh instruction must be invoked before taking a protocol action */
-export class StaleProtocolDataError extends ProgramError {
-  override readonly name: string = 'StaleProtocolData';
-
-  readonly code: number = 0x5; // 5
-
-  constructor(program: Program, cause?: Error) {
-    super(
-      'Stale protocol data. Refresh instruction must be invoked before taking a protocol action',
-      program,
-      cause
-    );
-  }
-}
-codeToErrorMap.set(0x5, StaleProtocolDataError);
-nameToErrorMap.set('StaleProtocolData', StaleProtocolDataError);
-
-/** UnableToRebalance: Unable to adjust position to the desired utilization rate */
-export class UnableToRebalanceError extends ProgramError {
-  override readonly name: string = 'UnableToRebalance';
-
-  readonly code: number = 0x6; // 6
-
-  constructor(program: Program, cause?: Error) {
-    super(
-      'Unable to adjust position to the desired utilization rate',
-      program,
-      cause
-    );
-  }
-}
-codeToErrorMap.set(0x6, UnableToRebalanceError);
-nameToErrorMap.set('UnableToRebalance', UnableToRebalanceError);
-
-/** ExceededValidUtilizationRate: Desired action brought the utilization rate to an unsafe amount */
-export class ExceededValidUtilizationRateError extends ProgramError {
-  override readonly name: string = 'ExceededValidUtilizationRate';
-
-  readonly code: number = 0x7; // 7
-
-  constructor(program: Program, cause?: Error) {
-    super(
-      'Desired action brought the utilization rate to an unsafe amount',
-      program,
-      cause
-    );
-  }
-}
-codeToErrorMap.set(0x7, ExceededValidUtilizationRateError);
-nameToErrorMap.set(
-  'ExceededValidUtilizationRate',
-  ExceededValidUtilizationRateError
-);
-
 /** InvalidRebalanceCondition: Invalid position condition to rebalance */
 export class InvalidRebalanceConditionError extends ProgramError {
   override readonly name: string = 'InvalidRebalanceCondition';
 
-  readonly code: number = 0x8; // 8
+  readonly code: number = 0x5; // 5
 
   constructor(program: Program, cause?: Error) {
     super('Invalid position condition to rebalance', program, cause);
   }
 }
-codeToErrorMap.set(0x8, InvalidRebalanceConditionError);
+codeToErrorMap.set(0x5, InvalidRebalanceConditionError);
 nameToErrorMap.set('InvalidRebalanceCondition', InvalidRebalanceConditionError);
 
 /** InstructionIsCPI: Unable to invoke instruction through a CPI */
 export class InstructionIsCPIError extends ProgramError {
   override readonly name: string = 'InstructionIsCPI';
 
-  readonly code: number = 0x9; // 9
+  readonly code: number = 0x6; // 6
 
   constructor(program: Program, cause?: Error) {
     super('Unable to invoke instruction through a CPI', program, cause);
   }
 }
-codeToErrorMap.set(0x9, InstructionIsCPIError);
+codeToErrorMap.set(0x6, InstructionIsCPIError);
 nameToErrorMap.set('InstructionIsCPI', InstructionIsCPIError);
 
-/** RebalanceAbuse: Too many rebalance instruction invocations in the same transaction */
-export class RebalanceAbuseError extends ProgramError {
-  override readonly name: string = 'RebalanceAbuse';
+/** IncorrectInstructions: Incorrect set of instructions in the transaction */
+export class IncorrectInstructionsError extends ProgramError {
+  override readonly name: string = 'IncorrectInstructions';
 
-  readonly code: number = 0xa; // 10
+  readonly code: number = 0x7; // 7
 
   constructor(program: Program, cause?: Error) {
-    super(
-      'Too many rebalance instruction invocations in the same transaction',
-      program,
-      cause
-    );
+    super('Incorrect set of instructions in the transaction', program, cause);
   }
 }
-codeToErrorMap.set(0xa, RebalanceAbuseError);
-nameToErrorMap.set('RebalanceAbuse', RebalanceAbuseError);
+codeToErrorMap.set(0x7, IncorrectInstructionsError);
+nameToErrorMap.set('IncorrectInstructions', IncorrectInstructionsError);
 
-/** IncorrectInstructions: Incorrect set of instructions in the transaction */
-export class IncorrectInstructionsError extends ProgramError {
-  override readonly name: string = 'IncorrectInstructions';
+/** IncorrectDebtAdjustment: Incorrect swap amount provided. Likely due to high price volatility */
+export class IncorrectDebtAdjustmentError extends ProgramError {
+  override readonly name: string = 'IncorrectDebtAdjustment';
 
-  readonly code: number = 0xb; // 11
+  readonly code: number = 0x8; // 8
 
   constructor(program: Program, cause?: Error) {
-    super('Incorrect set of instructions in the transaction', program, cause);
+    super(
+      'Incorrect swap amount provided. Likely due to high price volatility',
+      program,
+      cause
+    );
   }
 }
-codeToErrorMap.set(0xb, IncorrectInstructionsError);
-nameToErrorMap.set('IncorrectInstructions', IncorrectInstructionsError);
+codeToErrorMap.set(0x8, IncorrectDebtAdjustmentError);
+nameToErrorMap.set('IncorrectDebtAdjustment', IncorrectDebtAdjustmentError);
 
 /**
  * Attempts to resolve a custom program error from the provided error code.

package/src/index.ts

@@ -3,4 +3,6 @@ export * from './constants';
 export * from './generated';
 export * from './transactions';
 export * from './types';
-export * from './utils';
+export * from './utils';
+// export * from './marginfi-sdk';
+// export * from './jupiter-sdk';

package/src/jupiter-sdk/errors/index.ts

@@ -0,0 +1,9 @@
+/**
+ * This code was AUTOGENERATED using the kinobi library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun kinobi to update it.
+ *
+ * @see https://github.com/metaplex-foundation/kinobi
+ */
+
+export * from './jupiter';

package/src/jupiter-sdk/errors/jupiter.ts

@@ -0,0 +1,282 @@
+/**
+ * This code was AUTOGENERATED using the kinobi library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun kinobi to update it.
+ *
+ * @see https://github.com/metaplex-foundation/kinobi
+ */
+
+import { Program, ProgramError } from '@metaplex-foundation/umi';
+
+type ProgramErrorConstructor = new (
+  program: Program,
+  cause?: Error
+) => ProgramError;
+const codeToErrorMap: Map<number, ProgramErrorConstructor> = new Map();
+const nameToErrorMap: Map<string, ProgramErrorConstructor> = new Map();
+
+/** EmptyRoute: Empty route */
+export class EmptyRouteError extends ProgramError {
+  override readonly name: string = 'EmptyRoute';
+
+  readonly code: number = 0x1770; // 6000
+
+  constructor(program: Program, cause?: Error) {
+    super('Empty route', program, cause);
+  }
+}
+codeToErrorMap.set(0x1770, EmptyRouteError);
+nameToErrorMap.set('EmptyRoute', EmptyRouteError);
+
+/** SlippageToleranceExceeded: Slippage tolerance exceeded */
+export class SlippageToleranceExceededError extends ProgramError {
+  override readonly name: string = 'SlippageToleranceExceeded';
+
+  readonly code: number = 0x1771; // 6001
+
+  constructor(program: Program, cause?: Error) {
+    super('Slippage tolerance exceeded', program, cause);
+  }
+}
+codeToErrorMap.set(0x1771, SlippageToleranceExceededError);
+nameToErrorMap.set('SlippageToleranceExceeded', SlippageToleranceExceededError);
+
+/** InvalidCalculation: Invalid calculation */
+export class InvalidCalculationError extends ProgramError {
+  override readonly name: string = 'InvalidCalculation';
+
+  readonly code: number = 0x1772; // 6002
+
+  constructor(program: Program, cause?: Error) {
+    super('Invalid calculation', program, cause);
+  }
+}
+codeToErrorMap.set(0x1772, InvalidCalculationError);
+nameToErrorMap.set('InvalidCalculation', InvalidCalculationError);
+
+/** MissingPlatformFeeAccount: Missing platform fee account */
+export class MissingPlatformFeeAccountError extends ProgramError {
+  override readonly name: string = 'MissingPlatformFeeAccount';
+
+  readonly code: number = 0x1773; // 6003
+
+  constructor(program: Program, cause?: Error) {
+    super('Missing platform fee account', program, cause);
+  }
+}
+codeToErrorMap.set(0x1773, MissingPlatformFeeAccountError);
+nameToErrorMap.set('MissingPlatformFeeAccount', MissingPlatformFeeAccountError);
+
+/** InvalidSlippage: Invalid slippage */
+export class InvalidSlippageError extends ProgramError {
+  override readonly name: string = 'InvalidSlippage';
+
+  readonly code: number = 0x1774; // 6004
+
+  constructor(program: Program, cause?: Error) {
+    super('Invalid slippage', program, cause);
+  }
+}
+codeToErrorMap.set(0x1774, InvalidSlippageError);
+nameToErrorMap.set('InvalidSlippage', InvalidSlippageError);
+
+/** NotEnoughPercent: Not enough percent to 100 */
+export class NotEnoughPercentError extends ProgramError {
+  override readonly name: string = 'NotEnoughPercent';
+
+  readonly code: number = 0x1775; // 6005
+
+  constructor(program: Program, cause?: Error) {
+    super('Not enough percent to 100', program, cause);
+  }
+}
+codeToErrorMap.set(0x1775, NotEnoughPercentError);
+nameToErrorMap.set('NotEnoughPercent', NotEnoughPercentError);
+
+/** InvalidInputIndex: Token input index is invalid */
+export class InvalidInputIndexError extends ProgramError {
+  override readonly name: string = 'InvalidInputIndex';
+
+  readonly code: number = 0x1776; // 6006
+
+  constructor(program: Program, cause?: Error) {
+    super('Token input index is invalid', program, cause);
+  }
+}
+codeToErrorMap.set(0x1776, InvalidInputIndexError);
+nameToErrorMap.set('InvalidInputIndex', InvalidInputIndexError);
+
+/** InvalidOutputIndex: Token output index is invalid */
+export class InvalidOutputIndexError extends ProgramError {
+  override readonly name: string = 'InvalidOutputIndex';
+
+  readonly code: number = 0x1777; // 6007
+
+  constructor(program: Program, cause?: Error) {
+    super('Token output index is invalid', program, cause);
+  }
+}
+codeToErrorMap.set(0x1777, InvalidOutputIndexError);
+nameToErrorMap.set('InvalidOutputIndex', InvalidOutputIndexError);
+
+/** NotEnoughAccountKeys: Not Enough Account keys */
+export class NotEnoughAccountKeysError extends ProgramError {
+  override readonly name: string = 'NotEnoughAccountKeys';
+
+  readonly code: number = 0x1778; // 6008
+
+  constructor(program: Program, cause?: Error) {
+    super('Not Enough Account keys', program, cause);
+  }
+}
+codeToErrorMap.set(0x1778, NotEnoughAccountKeysError);
+nameToErrorMap.set('NotEnoughAccountKeys', NotEnoughAccountKeysError);
+
+/** NonZeroMinimumOutAmountNotSupported: Non zero minimum out amount not supported */
+export class NonZeroMinimumOutAmountNotSupportedError extends ProgramError {
+  override readonly name: string = 'NonZeroMinimumOutAmountNotSupported';
+
+  readonly code: number = 0x1779; // 6009
+
+  constructor(program: Program, cause?: Error) {
+    super('Non zero minimum out amount not supported', program, cause);
+  }
+}
+codeToErrorMap.set(0x1779, NonZeroMinimumOutAmountNotSupportedError);
+nameToErrorMap.set(
+  'NonZeroMinimumOutAmountNotSupported',
+  NonZeroMinimumOutAmountNotSupportedError
+);
+
+/** InvalidRoutePlan: Invalid route plan */
+export class InvalidRoutePlanError extends ProgramError {
+  override readonly name: string = 'InvalidRoutePlan';
+
+  readonly code: number = 0x177a; // 6010
+
+  constructor(program: Program, cause?: Error) {
+    super('Invalid route plan', program, cause);
+  }
+}
+codeToErrorMap.set(0x177a, InvalidRoutePlanError);
+nameToErrorMap.set('InvalidRoutePlan', InvalidRoutePlanError);
+
+/** InvalidReferralAuthority: Invalid referral authority */
+export class InvalidReferralAuthorityError extends ProgramError {
+  override readonly name: string = 'InvalidReferralAuthority';
+
+  readonly code: number = 0x177b; // 6011
+
+  constructor(program: Program, cause?: Error) {
+    super('Invalid referral authority', program, cause);
+  }
+}
+codeToErrorMap.set(0x177b, InvalidReferralAuthorityError);
+nameToErrorMap.set('InvalidReferralAuthority', InvalidReferralAuthorityError);
+
+/** LedgerTokenAccountDoesNotMatch: Token account doesn't match the ledger */
+export class LedgerTokenAccountDoesNotMatchError extends ProgramError {
+  override readonly name: string = 'LedgerTokenAccountDoesNotMatch';
+
+  readonly code: number = 0x177c; // 6012
+
+  constructor(program: Program, cause?: Error) {
+    super("Token account doesn't match the ledger", program, cause);
+  }
+}
+codeToErrorMap.set(0x177c, LedgerTokenAccountDoesNotMatchError);
+nameToErrorMap.set(
+  'LedgerTokenAccountDoesNotMatch',
+  LedgerTokenAccountDoesNotMatchError
+);
+
+/** InvalidTokenLedger: Invalid token ledger */
+export class InvalidTokenLedgerError extends ProgramError {
+  override readonly name: string = 'InvalidTokenLedger';
+
+  readonly code: number = 0x177d; // 6013
+
+  constructor(program: Program, cause?: Error) {
+    super('Invalid token ledger', program, cause);
+  }
+}
+codeToErrorMap.set(0x177d, InvalidTokenLedgerError);
+nameToErrorMap.set('InvalidTokenLedger', InvalidTokenLedgerError);
+
+/** IncorrectTokenProgramID: Token program ID is invalid */
+export class IncorrectTokenProgramIDError extends ProgramError {
+  override readonly name: string = 'IncorrectTokenProgramID';
+
+  readonly code: number = 0x177e; // 6014
+
+  constructor(program: Program, cause?: Error) {
+    super('Token program ID is invalid', program, cause);
+  }
+}
+codeToErrorMap.set(0x177e, IncorrectTokenProgramIDError);
+nameToErrorMap.set('IncorrectTokenProgramID', IncorrectTokenProgramIDError);
+
+/** TokenProgramNotProvided: Token program not provided */
+export class TokenProgramNotProvidedError extends ProgramError {
+  override readonly name: string = 'TokenProgramNotProvided';
+
+  readonly code: number = 0x177f; // 6015
+
+  constructor(program: Program, cause?: Error) {
+    super('Token program not provided', program, cause);
+  }
+}
+codeToErrorMap.set(0x177f, TokenProgramNotProvidedError);
+nameToErrorMap.set('TokenProgramNotProvided', TokenProgramNotProvidedError);
+
+/** SwapNotSupported: Swap not supported */
+export class SwapNotSupportedError extends ProgramError {
+  override readonly name: string = 'SwapNotSupported';
+
+  readonly code: number = 0x1780; // 6016
+
+  constructor(program: Program, cause?: Error) {
+    super('Swap not supported', program, cause);
+  }
+}
+codeToErrorMap.set(0x1780, SwapNotSupportedError);
+nameToErrorMap.set('SwapNotSupported', SwapNotSupportedError);
+
+/** ExactOutAmountNotMatched: Exact out amount doesn't match */
+export class ExactOutAmountNotMatchedError extends ProgramError {
+  override readonly name: string = 'ExactOutAmountNotMatched';
+
+  readonly code: number = 0x1781; // 6017
+
+  constructor(program: Program, cause?: Error) {
+    super("Exact out amount doesn't match", program, cause);
+  }
+}
+codeToErrorMap.set(0x1781, ExactOutAmountNotMatchedError);
+nameToErrorMap.set('ExactOutAmountNotMatched', ExactOutAmountNotMatchedError);
+
+/**
+ * Attempts to resolve a custom program error from the provided error code.
+ * @category Errors
+ */
+export function getJupiterErrorFromCode(
+  code: number,
+  program: Program,
+  cause?: Error
+): ProgramError | null {
+  const constructor = codeToErrorMap.get(code);
+  return constructor ? new constructor(program, cause) : null;
+}
+
+/**
+ * Attempts to resolve a custom program error from the provided error name, i.e. 'Unauthorized'.
+ * @category Errors
+ */
+export function getJupiterErrorFromName(
+  name: string,
+  program: Program,
+  cause?: Error
+): ProgramError | null {
+  const constructor = nameToErrorMap.get(name);
+  return constructor ? new constructor(program, cause) : null;
+}

package/src/jupiter-sdk/index.ts

@@ -0,0 +1,10 @@
+/**
+ * This code was AUTOGENERATED using the kinobi library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun kinobi to update it.
+ *
+ * @see https://github.com/metaplex-foundation/kinobi
+ */
+
+export * from './errors';
+export * from './programs';

package/src/jupiter-sdk/programs/index.ts

@@ -0,0 +1,9 @@
+/**
+ * This code was AUTOGENERATED using the kinobi library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun kinobi to update it.
+ *
+ * @see https://github.com/metaplex-foundation/kinobi
+ */
+
+export * from './jupiter';

package/src/jupiter-sdk/programs/jupiter.ts

@@ -0,0 +1,52 @@
+/**
+ * This code was AUTOGENERATED using the kinobi library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun kinobi to update it.
+ *
+ * @see https://github.com/metaplex-foundation/kinobi
+ */
+
+import {
+  ClusterFilter,
+  Context,
+  Program,
+  PublicKey,
+} from '@metaplex-foundation/umi';
+import { getJupiterErrorFromCode, getJupiterErrorFromName } from '../errors';
+
+export const JUPITER_PROGRAM_ID =
+  'JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4' as PublicKey<'JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4'>;
+
+export function createJupiterProgram(): Program {
+  return {
+    name: 'jupiter',
+    publicKey: JUPITER_PROGRAM_ID,
+    getErrorFromCode(code: number, cause?: Error) {
+      return getJupiterErrorFromCode(code, this, cause);
+    },
+    getErrorFromName(name: string, cause?: Error) {
+      return getJupiterErrorFromName(name, this, cause);
+    },
+    isOnCluster() {
+      return true;
+    },
+  };
+}
+
+export function getJupiterProgram<T extends Program = Program>(
+  context: Pick<Context, 'programs'>,
+  clusterFilter?: ClusterFilter
+): T {
+  return context.programs.get<T>('jupiter', clusterFilter);
+}
+
+export function getJupiterProgramId(
+  context: Pick<Context, 'programs'>,
+  clusterFilter?: ClusterFilter
+): PublicKey {
+  return context.programs.getPublicKey(
+    'jupiter',
+    JUPITER_PROGRAM_ID,
+    clusterFilter
+  );
+}