@shogun-sdk/intents-sdk 1.0.2 → 1.1.1

package/src/core/solana/generated/{instructions → cross-chain/instructions}/setAdmin.ts

@@ -6,20 +6,20 @@
  * @see https://github.com/codama-idl/codama
  */
 
-import { type Address, getAddressDecoder, getAddressEncoder, getProgramDerivedAddress } from '@solana/kit';
+import { getAddressDecoder, getAddressEncoder, getProgramDerivedAddress, type Address } from '@solana/kit';
 import {
-  type Codec,
   combineCodec,
-  type Decoder,
-  type Encoder,
   fixDecoderSize,
   fixEncoderSize,
   getBytesDecoder,
   getBytesEncoder,
   getStructDecoder,
   getStructEncoder,
-  type ReadonlyUint8Array,
   transformEncoder,
+  type Codec,
+  type Decoder,
+  type Encoder,
+  type ReadonlyUint8Array,
 } from '@solana/kit';
 import {
   type IAccountMeta,
@@ -90,7 +90,7 @@ export type SetAdminAsyncInput<
 > = {
   /** Admin signer */
   admin: TransactionSigner<TAccountAdmin>;
-  /** Admin singleton account that grants access to */
+  /** Admin singleton account that grants access to admin functions */
   adminSingleton?: Address<TAccountAdminSingleton>;
   newAdmin: SetAdminInstructionDataArgs['newAdmin'];
 };
@@ -137,7 +137,7 @@ export async function getSetAdminInstructionAsync<
 export type SetAdminInput<TAccountAdmin extends string = string, TAccountAdminSingleton extends string = string> = {
   /** Admin signer */
   admin: TransactionSigner<TAccountAdmin>;
-  /** Admin singleton account that grants access to */
+  /** Admin singleton account that grants access to admin functions */
   adminSingleton: Address<TAccountAdminSingleton>;
   newAdmin: SetAdminInstructionDataArgs['newAdmin'];
 };
@@ -181,7 +181,7 @@ export type ParsedSetAdminInstruction<
   accounts: {
     /** Admin signer */
     admin: TAccountMetas[0];
-    /** Admin singleton account that grants access to */
+    /** Admin singleton account that grants access to admin functions */
     adminSingleton: TAccountMetas[1];
   };
   data: SetAdminInstructionData;

package/src/core/solana/generated/{instructions → cross-chain/instructions}/setAuctioneerPubKey.ts

@@ -6,20 +6,20 @@
  * @see https://github.com/codama-idl/codama
  */
 
-import { type Address, getAddressDecoder, getAddressEncoder, getProgramDerivedAddress } from '@solana/kit';
+import { getAddressDecoder, getAddressEncoder, getProgramDerivedAddress, type Address } from '@solana/kit';
 import {
-  type Codec,
   combineCodec,
-  type Decoder,
-  type Encoder,
   fixDecoderSize,
   fixEncoderSize,
   getBytesDecoder,
   getBytesEncoder,
   getStructDecoder,
   getStructEncoder,
-  type ReadonlyUint8Array,
   transformEncoder,
+  type Codec,
+  type Decoder,
+  type Encoder,
+  type ReadonlyUint8Array,
 } from '@solana/kit';
 import {
   type IAccountMeta,
@@ -102,7 +102,7 @@ export type SetAuctioneerPubKeyAsyncInput<
 > = {
   /** Admin signer */
   admin: TransactionSigner<TAccountAdmin>;
-  /** Admin singleton account that grants access to */
+  /** Admin singleton account that grants access to admin functions */
   adminSingleton?: Address<TAccountAdminSingleton>;
   /** Guard account */
   guard: Address<TAccountGuard>;
@@ -157,7 +157,7 @@ export type SetAuctioneerPubKeyInput<
 > = {
   /** Admin signer */
   admin: TransactionSigner<TAccountAdmin>;
-  /** Admin singleton account that grants access to */
+  /** Admin singleton account that grants access to admin functions */
   adminSingleton: Address<TAccountAdminSingleton>;
   /** Guard account */
   guard: Address<TAccountGuard>;
@@ -205,7 +205,7 @@ export type ParsedSetAuctioneerPubKeyInstruction<
   accounts: {
     /** Admin signer */
     admin: TAccountMetas[0];
-    /** Admin singleton account that grants access to */
+    /** Admin singleton account that grants access to admin functions */
     adminSingleton: TAccountMetas[1];
     /** Guard account */
     guard: TAccountMetas[2];

package/src/core/solana/generated/{programs → cross-chain/programs}/sourceChainGuard.ts

@@ -9,6 +9,7 @@
 import { type Address } from '@solana/kit';
 import { containsBytes, fixEncoderSize, getBytesEncoder, type ReadonlyUint8Array } from '@solana/kit';
 import {
+  type ParsedAcceptAdminInstruction,
   type ParsedCancelOrderInstruction,
   type ParsedClaimTokensInstruction,
   type ParsedCollectProtocolFeesInstruction,
@@ -23,7 +24,7 @@ import {
 } from '../instructions/index.js';
 
 export const SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS =
-  '98nJKivvrpkaPiLky1ZK4HPZxvAgV3Nk3Zk7CqbBiXwX' as Address<'98nJKivvrpkaPiLky1ZK4HPZxvAgV3Nk3Zk7CqbBiXwX'>;
+  '43cctGU9QJ4WEPzLoNEvo3TPiv6nMUG9puN2pXQSnB6V' as Address<'43cctGU9QJ4WEPzLoNEvo3TPiv6nMUG9puN2pXQSnB6V'>;
 
 export enum SourceChainGuardAccount {
   AdminSingleton,
@@ -66,6 +67,7 @@ export function identifySourceChainGuardAccount(
 }
 
 export enum SourceChainGuardInstruction {
+  AcceptAdmin,
   CancelOrder,
   ClaimTokens,
   CollectProtocolFees,
@@ -83,6 +85,15 @@ export function identifySourceChainGuardInstruction(
   instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
 ): SourceChainGuardInstruction {
   const data = 'data' in instruction ? instruction.data : instruction;
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([112, 42, 45, 90, 116, 181, 13, 170])),
+      0,
+    )
+  ) {
+    return SourceChainGuardInstruction.AcceptAdmin;
+  }
   if (
     containsBytes(
       data,
@@ -186,8 +197,11 @@ export function identifySourceChainGuardInstruction(
 }
 
 export type ParsedSourceChainGuardInstruction<
-  TProgram extends string = '98nJKivvrpkaPiLky1ZK4HPZxvAgV3Nk3Zk7CqbBiXwX',
+  TProgram extends string = '43cctGU9QJ4WEPzLoNEvo3TPiv6nMUG9puN2pXQSnB6V',
 > =
+  | ({
+      instructionType: SourceChainGuardInstruction.AcceptAdmin;
+    } & ParsedAcceptAdminInstruction<TProgram>)
   | ({
       instructionType: SourceChainGuardInstruction.CancelOrder;
     } & ParsedCancelOrderInstruction<TProgram>)

package/src/core/solana/generated/{shared → cross-chain/shared}/index.ts

@@ -6,11 +6,11 @@
  * @see https://github.com/codama-idl/codama
  */
 
-import { type Address, isProgramDerivedAddress, type ProgramDerivedAddress } from '@solana/kit';
+import { isProgramDerivedAddress, type Address, type ProgramDerivedAddress } from '@solana/kit';
 import { AccountRole, type IAccountMeta, upgradeRoleToSigner } from '@solana/kit';
 import {
-  type IAccountSignerMeta,
   isTransactionSigner as kitIsTransactionSigner,
+  type IAccountSignerMeta,
   type TransactionSigner,
 } from '@solana/kit';
 

package/src/core/solana/generated/cross-chain/types/adminUpdateStarted.ts

@@ -0,0 +1,35 @@
+/**
+ * This code was AUTOGENERATED using the codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+  combineCodec,
+  getAddressDecoder,
+  getAddressEncoder,
+  getStructDecoder,
+  getStructEncoder,
+  type Address,
+  type Codec,
+  type Decoder,
+  type Encoder,
+} from '@solana/kit';
+
+export type AdminUpdateStarted = { newAdmin: Address };
+
+export type AdminUpdateStartedArgs = AdminUpdateStarted;
+
+export function getAdminUpdateStartedEncoder(): Encoder<AdminUpdateStartedArgs> {
+  return getStructEncoder([['newAdmin', getAddressEncoder()]]);
+}
+
+export function getAdminUpdateStartedDecoder(): Decoder<AdminUpdateStarted> {
+  return getStructDecoder([['newAdmin', getAddressDecoder()]]);
+}
+
+export function getAdminUpdateStartedCodec(): Codec<AdminUpdateStartedArgs, AdminUpdateStarted> {
+  return combineCodec(getAdminUpdateStartedEncoder(), getAdminUpdateStartedDecoder());
+}

package/src/core/solana/generated/{types → cross-chain/types}/index.ts

@@ -7,6 +7,7 @@
  */
 
 export * from './adminUpdated.js';
+export * from './adminUpdateStarted.js';
 export * from './auctioneerPubkeyUpdated.js';
 export * from './executionStarted.js';
 export * from './guardCreated.js';

package/src/core/solana/generated/single-chain/accounts/adminSingleton.ts

@@ -0,0 +1,142 @@
+/**
+ * This code was AUTOGENERATED using the codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+  assertAccountExists,
+  assertAccountsExist,
+  decodeAccount,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  type Account,
+  type EncodedAccount,
+  type FetchAccountConfig,
+  type FetchAccountsConfig,
+  type MaybeAccount,
+  type MaybeEncodedAccount,
+} from '@solana/kit';
+import { getAddressDecoder, getAddressEncoder, type Address } from '@solana/kit';
+import {
+  combineCodec,
+  fixDecoderSize,
+  fixEncoderSize,
+  getBytesDecoder,
+  getBytesEncoder,
+  getStructDecoder,
+  getStructEncoder,
+  getU8Decoder,
+  getU8Encoder,
+  transformEncoder,
+  type Codec,
+  type Decoder,
+  type Encoder,
+  type ReadonlyUint8Array,
+} from '@solana/kit';
+
+export const ADMIN_SINGLETON_DISCRIMINATOR = new Uint8Array([179, 22, 254, 245, 204, 230, 222, 194]);
+
+export function getAdminSingletonDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(ADMIN_SINGLETON_DISCRIMINATOR);
+}
+
+export type AdminSingleton = {
+  discriminator: ReadonlyUint8Array;
+  /** Guard admin */
+  admin: Address;
+  /** Pending guard admin */
+  pendingAdmin: Address;
+  /** PDA bump */
+  bump: number;
+};
+
+export type AdminSingletonArgs = {
+  /** Guard admin */
+  admin: Address;
+  /** Pending guard admin */
+  pendingAdmin: Address;
+  /** PDA bump */
+  bump: number;
+};
+
+export function getAdminSingletonEncoder(): Encoder<AdminSingletonArgs> {
+  return transformEncoder(
+    getStructEncoder([
+      ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
+      ['admin', getAddressEncoder()],
+      ['pendingAdmin', getAddressEncoder()],
+      ['bump', getU8Encoder()],
+    ]),
+    (value) => ({ ...value, discriminator: ADMIN_SINGLETON_DISCRIMINATOR }),
+  );
+}
+
+export function getAdminSingletonDecoder(): Decoder<AdminSingleton> {
+  return getStructDecoder([
+    ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
+    ['admin', getAddressDecoder()],
+    ['pendingAdmin', getAddressDecoder()],
+    ['bump', getU8Decoder()],
+  ]);
+}
+
+export function getAdminSingletonCodec(): Codec<AdminSingletonArgs, AdminSingleton> {
+  return combineCodec(getAdminSingletonEncoder(), getAdminSingletonDecoder());
+}
+
+export function decodeAdminSingleton<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress>,
+): Account<AdminSingleton, TAddress>;
+export function decodeAdminSingleton<TAddress extends string = string>(
+  encodedAccount: MaybeEncodedAccount<TAddress>,
+): MaybeAccount<AdminSingleton, TAddress>;
+export function decodeAdminSingleton<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+): Account<AdminSingleton, TAddress> | MaybeAccount<AdminSingleton, TAddress> {
+  return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getAdminSingletonDecoder());
+}
+
+export async function fetchAdminSingleton<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<Account<AdminSingleton, TAddress>> {
+  const maybeAccount = await fetchMaybeAdminSingleton(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function fetchMaybeAdminSingleton<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<MaybeAccount<AdminSingleton, TAddress>> {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeAdminSingleton(maybeAccount);
+}
+
+export async function fetchAllAdminSingleton(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<Account<AdminSingleton>[]> {
+  const maybeAccounts = await fetchAllMaybeAdminSingleton(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+
+export async function fetchAllMaybeAdminSingleton(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<MaybeAccount<AdminSingleton>[]> {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeAdminSingleton(maybeAccount));
+}
+
+export function getAdminSingletonSize(): number {
+  return 73;
+}

package/src/core/solana/generated/single-chain/accounts/dcaOrder.ts

@@ -0,0 +1,222 @@
+/**
+ * This code was AUTOGENERATED using the codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+  assertAccountExists,
+  assertAccountsExist,
+  decodeAccount,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  type Account,
+  type EncodedAccount,
+  type FetchAccountConfig,
+  type FetchAccountsConfig,
+  type MaybeAccount,
+  type MaybeEncodedAccount,
+} from '@solana/kit';
+import { getAddressDecoder, getAddressEncoder, type Address } from '@solana/kit';
+import {
+  combineCodec,
+  fixDecoderSize,
+  fixEncoderSize,
+  getArrayDecoder,
+  getArrayEncoder,
+  getBytesDecoder,
+  getBytesEncoder,
+  getStructDecoder,
+  getStructEncoder,
+  getU32Decoder,
+  getU32Encoder,
+  getU64Decoder,
+  getU64Encoder,
+  transformEncoder,
+  type Codec,
+  type Decoder,
+  type Encoder,
+  type ReadonlyUint8Array,
+} from '@solana/kit';
+
+export const DCA_ORDER_DISCRIMINATOR = new Uint8Array([55, 1, 103, 253, 215, 66, 27, 57]);
+
+export function getDcaOrderDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(DCA_ORDER_DISCRIMINATOR);
+}
+
+export type DcaOrder = {
+  discriminator: ReadonlyUint8Array;
+  /** User address, that created this order */
+  user: Address;
+  /** Guard address, that will protect this order execution */
+  guard: Address;
+  /** Token IN that user wants to spend */
+  tokenInMint: Address;
+  /** Amount of tokens IN user is willing to spend per interval/trade */
+  amountInPerInterval: bigint;
+  /** Minimum amount of tokens OUT to receive PER INTERVAL */
+  amountOutMin: bigint;
+  /** Timestamp (in seconds) when the user created and submitted the DCA order */
+  startTime: number;
+  /** Deadline for the operation, in Unix timestamp format, in SECONDS */
+  deadline: number;
+  /** Total number of intervals over which the DCA order will be executed */
+  totalIntervals: number;
+  /** DCA interval duration, in seconds */
+  intervalDuration: number;
+  /**
+   * Keccak256 hash of (token_out,receiver,extra_transfers_tokens_and_receivers,secret_number)
+   * Since we want to hide tokens OUT right until execution moment to protect user from
+   * any sort of MEV attack
+   */
+  secretHash: ReadonlyUint8Array;
+  /**
+   * Array of requested extra transfers amounts
+   * Since we want to hide tokens OUT and receivers right until execution moment
+   * to protect user from any sort of MEV attack
+   * Tokens and receivers will be collected from `remaining_accounts`
+   * during fulfillment and checked against `secret_hash` value
+   */
+  extraTransfersAmounts: Array<bigint>;
+  /** Total number of already executed intervals */
+  totalExecutedIntervals: number;
+  /** INDEX of last executed interval */
+  lastExecutedIntervalIndex: number;
+};
+
+export type DcaOrderArgs = {
+  /** User address, that created this order */
+  user: Address;
+  /** Guard address, that will protect this order execution */
+  guard: Address;
+  /** Token IN that user wants to spend */
+  tokenInMint: Address;
+  /** Amount of tokens IN user is willing to spend per interval/trade */
+  amountInPerInterval: number | bigint;
+  /** Minimum amount of tokens OUT to receive PER INTERVAL */
+  amountOutMin: number | bigint;
+  /** Timestamp (in seconds) when the user created and submitted the DCA order */
+  startTime: number;
+  /** Deadline for the operation, in Unix timestamp format, in SECONDS */
+  deadline: number;
+  /** Total number of intervals over which the DCA order will be executed */
+  totalIntervals: number;
+  /** DCA interval duration, in seconds */
+  intervalDuration: number;
+  /**
+   * Keccak256 hash of (token_out,receiver,extra_transfers_tokens_and_receivers,secret_number)
+   * Since we want to hide tokens OUT right until execution moment to protect user from
+   * any sort of MEV attack
+   */
+  secretHash: ReadonlyUint8Array;
+  /**
+   * Array of requested extra transfers amounts
+   * Since we want to hide tokens OUT and receivers right until execution moment
+   * to protect user from any sort of MEV attack
+   * Tokens and receivers will be collected from `remaining_accounts`
+   * during fulfillment and checked against `secret_hash` value
+   */
+  extraTransfersAmounts: Array<number | bigint>;
+  /** Total number of already executed intervals */
+  totalExecutedIntervals: number;
+  /** INDEX of last executed interval */
+  lastExecutedIntervalIndex: number;
+};
+
+export function getDcaOrderEncoder(): Encoder<DcaOrderArgs> {
+  return transformEncoder(
+    getStructEncoder([
+      ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
+      ['user', getAddressEncoder()],
+      ['guard', getAddressEncoder()],
+      ['tokenInMint', getAddressEncoder()],
+      ['amountInPerInterval', getU64Encoder()],
+      ['amountOutMin', getU64Encoder()],
+      ['startTime', getU32Encoder()],
+      ['deadline', getU32Encoder()],
+      ['totalIntervals', getU32Encoder()],
+      ['intervalDuration', getU32Encoder()],
+      ['secretHash', fixEncoderSize(getBytesEncoder(), 32)],
+      ['extraTransfersAmounts', getArrayEncoder(getU64Encoder())],
+      ['totalExecutedIntervals', getU32Encoder()],
+      ['lastExecutedIntervalIndex', getU32Encoder()],
+    ]),
+    (value) => ({ ...value, discriminator: DCA_ORDER_DISCRIMINATOR }),
+  );
+}
+
+export function getDcaOrderDecoder(): Decoder<DcaOrder> {
+  return getStructDecoder([
+    ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
+    ['user', getAddressDecoder()],
+    ['guard', getAddressDecoder()],
+    ['tokenInMint', getAddressDecoder()],
+    ['amountInPerInterval', getU64Decoder()],
+    ['amountOutMin', getU64Decoder()],
+    ['startTime', getU32Decoder()],
+    ['deadline', getU32Decoder()],
+    ['totalIntervals', getU32Decoder()],
+    ['intervalDuration', getU32Decoder()],
+    ['secretHash', fixDecoderSize(getBytesDecoder(), 32)],
+    ['extraTransfersAmounts', getArrayDecoder(getU64Decoder())],
+    ['totalExecutedIntervals', getU32Decoder()],
+    ['lastExecutedIntervalIndex', getU32Decoder()],
+  ]);
+}
+
+export function getDcaOrderCodec(): Codec<DcaOrderArgs, DcaOrder> {
+  return combineCodec(getDcaOrderEncoder(), getDcaOrderDecoder());
+}
+
+export function decodeDcaOrder<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress>,
+): Account<DcaOrder, TAddress>;
+export function decodeDcaOrder<TAddress extends string = string>(
+  encodedAccount: MaybeEncodedAccount<TAddress>,
+): MaybeAccount<DcaOrder, TAddress>;
+export function decodeDcaOrder<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+): Account<DcaOrder, TAddress> | MaybeAccount<DcaOrder, TAddress> {
+  return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getDcaOrderDecoder());
+}
+
+export async function fetchDcaOrder<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<Account<DcaOrder, TAddress>> {
+  const maybeAccount = await fetchMaybeDcaOrder(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function fetchMaybeDcaOrder<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<MaybeAccount<DcaOrder, TAddress>> {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeDcaOrder(maybeAccount);
+}
+
+export async function fetchAllDcaOrder(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<Account<DcaOrder>[]> {
+  const maybeAccounts = await fetchAllMaybeDcaOrder(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+
+export async function fetchAllMaybeDcaOrder(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<MaybeAccount<DcaOrder>[]> {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeDcaOrder(maybeAccount));
+}