@shogun-sdk/intents-sdk 1.0.0

package/src/core/sdk.ts

@@ -0,0 +1,154 @@
+import { chainIdToChainTypeMap } from '../chains.js';
+import { AUCTIONEER_URL } from '../constants.js';
+import { NetworkError } from '../errors/index.js';
+import type { CreateOrderParams, PreparedOrder, UserIntentRequest } from '../types/intent.js';
+import { Parsers } from '../utils/parsers.js';
+import { Order } from './order.js';
+
+/**
+ * Base SDK providing common functionality for all blockchain implementations
+ *
+ * This abstract class serves as the foundation for chain-specific SDK implementations
+ * (EVM, Solana, Sui), providing shared functionality for creating and sending orders
+ * across different blockchains.
+ */
+export abstract class BaseSDK {
+  /**
+   * Gets the user's wallet address derived from their private key
+   *
+   * @returns Promise resolving to the user's address as a string
+   * @abstract Must be implemented by each chain-specific SDK
+   */
+  public abstract getUserAddress(): Promise<string>;
+
+  /**
+   * Prepares an order for submission with chain-specific logic
+   *
+   * This method handles the chain-specific aspects of order creation, such as:
+   * - Creating and signing transactions
+   * - Interacting with blockchain-specific smart contracts
+   * - Generating proof of intent
+   *
+   * @param order The validated order to prepare
+   * @returns Promise resolving to a prepared order with chain-specific data
+   * @abstract Must be implemented by each chain-specific SDK
+   * @protected
+   */
+  protected abstract prepareOrder(order: Order): Promise<PreparedOrder>;
+
+  /**
+   * Creates a cross-chain swap order
+   *
+   * This method:
+   * 1. Gets the user's address from their private key
+   * 2. Creates and validates an Order instance
+   * 3. Delegates to chain-specific preparation logic
+   *
+   * @param params Parameters for order creation including source/destination chain details
+   * @returns Promise resolving to a prepared order ready for submission
+   * @throws {ValidationError} If order parameters are invalid
+   * @throws {OrderCreationError} If order creation fails
+   */
+  public async createOrder(params: CreateOrderParams): Promise<PreparedOrder> {
+    const userAddress = await this.getUserAddress();
+
+    // Order is validated upon creation
+    const order = await Order.create({
+      user: userAddress,
+      sourceChainId: params.sourceChainId,
+      sourceTokenAddress: params.sourceTokenAddress,
+      sourceTokenAmount: params.sourceTokenAmount,
+      minStablecoinAmount: params.minStablecoinAmount,
+      deadline: params.deadline,
+      destinationAddress: params.destinationAddress,
+      destinationChainId: params.destinationChainId,
+      destinationTokenAddress: params.destinationTokenAddress,
+      destinationTokenMinAmount: params.destinationTokenMinAmount,
+      extraTransfers: params.extraTransfers,
+    });
+
+    return this.prepareOrder(order);
+  }
+
+  /**
+   * Creates an order and sends it to the auctioneer in a single call
+   *
+   * Convenience method that combines order creation and submission
+   *
+   * @param params Parameters for order creation including source/destination chain details
+   * @returns Promise resolving to the auctioneer's HTTP response
+   * @throws {ValidationError} If order parameters are invalid
+   * @throws {OrderCreationError} If order creation fails
+   * @throws {NetworkError} If order submission fails
+   */
+  public async createAndSendOrder(params: CreateOrderParams): Promise<Response> {
+    const preparedOrder = await this.createOrder(params);
+    return this.sendOrder(preparedOrder);
+  }
+
+  /**
+   * Converts a prepared order into a user intent request format for the auctioneer
+   *
+   * The UserIntentRequest format includes:
+   * - Generic data common to all chains
+   * - Chain-specific data (signatures, nonces, etc.)
+   * - Execution details for the destination chain
+   *
+   * @param preparedOrder The prepared order with chain-specific data
+   * @returns User intent request object ready for submission to the auctioneer
+   * @throws {BaseError} If conversion fails
+   */
+  private getUserIntentRequest(preparedOrder: PreparedOrder): UserIntentRequest {
+    const sourceChain = preparedOrder.order.sourceChainId;
+    const sourceChainType = chainIdToChainTypeMap[sourceChain];
+    const executionDetails = preparedOrder.order.getExecutionDetails();
+
+    return {
+      genericData: preparedOrder.order.toSourceChainData(),
+      executionDetails: JSON.stringify(executionDetails, Parsers.bigIntReplacer),
+      chainSpecificData: {
+        [sourceChainType]: preparedOrder.preparedData,
+      },
+    };
+  }
+
+  /**
+   * Sends a prepared order to the auctioneer service
+   *
+   * This method:
+   * 1. Converts the prepared order to the auctioneer's expected format
+   * 2. Serializes the request with proper handling of bigint values
+   * 3. Submits the order to the auctioneer endpoint
+   * 4. Validates the response
+   *
+   * @param preparedOrder The prepared order with chain-specific data
+   * @returns Promise resolving to the specific-chain tx hash
+   * @throws {NetworkError} If the network request fails or returns an error
+   */
+  public async sendOrder(preparedOrder: PreparedOrder): Promise<Response> {
+    const intentRequest = this.getUserIntentRequest(preparedOrder);
+    const body = JSON.stringify(intentRequest, Parsers.bigIntReplacer);
+
+    const url = `${AUCTIONEER_URL}/user_intent`;
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body,
+    });
+
+    if (!response.ok) {
+      const errorJson = await response.json();
+
+      const extraErrorData = errorJson.extra_error_data;
+      throw new NetworkError(`Server error`, {
+        status: response.status,
+        statusText: response.statusText,
+        body: extraErrorData,
+      });
+    }
+
+    return response;
+  }
+}

package/src/core/solana/client.ts

@@ -0,0 +1,37 @@
+import {
+  createSolanaRpc,
+  createSolanaRpcSubscriptions,
+  type Rpc,
+  type RpcSubscriptions,
+  type SolanaRpcApiMainnet,
+  type SolanaRpcSubscriptionsApi,
+  sendAndConfirmTransactionFactory,
+} from '@solana/kit';
+import type { SolanaConfig } from '../../config.js';
+
+export type SolanaClient = {
+  privateKey: string;
+  rpc: Rpc<SolanaRpcApiMainnet>;
+  rpcSubscriptions: RpcSubscriptions<SolanaRpcSubscriptionsApi>;
+  sendAndConfirmTransaction: ReturnType<typeof sendAndConfirmTransactionFactory>;
+};
+
+export function createSolanaClient(config: SolanaConfig): SolanaClient {
+  const rpc = config.rpcProviderUrl ? createSolanaRpc(config.rpcProviderUrl) : getDefaultSolanaRPC();
+  const rpcSubscriptions = createSolanaRpcSubscriptions('wss://api.mainnet-beta.solana.com');
+  const sendAndConfirmTransaction = sendAndConfirmTransactionFactory({
+    rpc,
+    rpcSubscriptions,
+  });
+
+  return {
+    privateKey: config.privateKey,
+    rpc,
+    rpcSubscriptions,
+    sendAndConfirmTransaction,
+  };
+}
+
+export function getDefaultSolanaRPC(): Rpc<SolanaRpcApiMainnet> {
+  return createSolanaRpc('https://api.mainnet-beta.solana.com');
+}

package/src/core/solana/generated/accounts/adminSingleton.ts

@@ -0,0 +1,136 @@
+/**
+ * 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 {
+  type Account,
+  assertAccountExists,
+  assertAccountsExist,
+  decodeAccount,
+  type EncodedAccount,
+  type FetchAccountConfig,
+  type FetchAccountsConfig,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  type MaybeAccount,
+  type MaybeEncodedAccount,
+} from '@solana/kit';
+import { type Address, getAddressDecoder, getAddressEncoder } from '@solana/kit';
+import {
+  type Codec,
+  combineCodec,
+  type Decoder,
+  type Encoder,
+  fixDecoderSize,
+  fixEncoderSize,
+  getBytesDecoder,
+  getBytesEncoder,
+  getStructDecoder,
+  getStructEncoder,
+  getU8Decoder,
+  getU8Encoder,
+  type ReadonlyUint8Array,
+  transformEncoder,
+} 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;
+  /** PDA bump */
+  bump: number;
+};
+
+export type AdminSingletonArgs = {
+  /** Guard admin */
+  admin: Address;
+  /** PDA bump */
+  bump: number;
+};
+
+export function getAdminSingletonEncoder(): Encoder<AdminSingletonArgs> {
+  return transformEncoder(
+    getStructEncoder([
+      ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
+      ['admin', getAddressEncoder()],
+      ['bump', getU8Encoder()],
+    ]),
+    (value) => ({ ...value, discriminator: ADMIN_SINGLETON_DISCRIMINATOR }),
+  );
+}
+
+export function getAdminSingletonDecoder(): Decoder<AdminSingleton> {
+  return getStructDecoder([
+    ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
+    ['admin', 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 41;
+}

package/src/core/solana/generated/accounts/guard.ts

@@ -0,0 +1,156 @@
+/**
+ * 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 {
+  type Account,
+  assertAccountExists,
+  assertAccountsExist,
+  decodeAccount,
+  type EncodedAccount,
+  type FetchAccountConfig,
+  type FetchAccountsConfig,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  type MaybeAccount,
+  type MaybeEncodedAccount,
+} from '@solana/kit';
+import { type Address, getAddressDecoder, getAddressEncoder } from '@solana/kit';
+import {
+  type Codec,
+  combineCodec,
+  type Decoder,
+  type Encoder,
+  fixDecoderSize,
+  fixEncoderSize,
+  getBytesDecoder,
+  getBytesEncoder,
+  getStructDecoder,
+  getStructEncoder,
+  getU8Decoder,
+  getU8Encoder,
+  getU64Decoder,
+  getU64Encoder,
+  type ReadonlyUint8Array,
+  transformEncoder,
+} from '@solana/kit';
+
+export const GUARD_DISCRIMINATOR = new Uint8Array([54, 187, 84, 137, 192, 15, 74, 248]);
+
+export function getGuardDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(GUARD_DISCRIMINATOR);
+}
+
+export type Guard = {
+  discriminator: ReadonlyUint8Array;
+  /** Token that is used as collateral and fees */
+  collateralToken: Address;
+  /** Token that is used as token OUT when swapping Token IN during order execution start */
+  stablecoinToken: Address;
+  /** PDA bump */
+  bump: number;
+  /** Public key of auctioneer that signs permissions and confirmations */
+  auctioneerPubKey: Address;
+  /** Amount of collected fees, in collateral tokens */
+  collectedFees: bigint;
+};
+
+export type GuardArgs = {
+  /** Token that is used as collateral and fees */
+  collateralToken: Address;
+  /** Token that is used as token OUT when swapping Token IN during order execution start */
+  stablecoinToken: Address;
+  /** PDA bump */
+  bump: number;
+  /** Public key of auctioneer that signs permissions and confirmations */
+  auctioneerPubKey: Address;
+  /** Amount of collected fees, in collateral tokens */
+  collectedFees: number | bigint;
+};
+
+export function getGuardEncoder(): Encoder<GuardArgs> {
+  return transformEncoder(
+    getStructEncoder([
+      ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
+      ['collateralToken', getAddressEncoder()],
+      ['stablecoinToken', getAddressEncoder()],
+      ['bump', getU8Encoder()],
+      ['auctioneerPubKey', getAddressEncoder()],
+      ['collectedFees', getU64Encoder()],
+    ]),
+    (value) => ({ ...value, discriminator: GUARD_DISCRIMINATOR }),
+  );
+}
+
+export function getGuardDecoder(): Decoder<Guard> {
+  return getStructDecoder([
+    ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
+    ['collateralToken', getAddressDecoder()],
+    ['stablecoinToken', getAddressDecoder()],
+    ['bump', getU8Decoder()],
+    ['auctioneerPubKey', getAddressDecoder()],
+    ['collectedFees', getU64Decoder()],
+  ]);
+}
+
+export function getGuardCodec(): Codec<GuardArgs, Guard> {
+  return combineCodec(getGuardEncoder(), getGuardDecoder());
+}
+
+export function decodeGuard<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress>,
+): Account<Guard, TAddress>;
+export function decodeGuard<TAddress extends string = string>(
+  encodedAccount: MaybeEncodedAccount<TAddress>,
+): MaybeAccount<Guard, TAddress>;
+export function decodeGuard<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+): Account<Guard, TAddress> | MaybeAccount<Guard, TAddress> {
+  return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getGuardDecoder());
+}
+
+export async function fetchGuard<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<Account<Guard, TAddress>> {
+  const maybeAccount = await fetchMaybeGuard(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function fetchMaybeGuard<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<MaybeAccount<Guard, TAddress>> {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeGuard(maybeAccount);
+}
+
+export async function fetchAllGuard(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<Account<Guard>[]> {
+  const maybeAccounts = await fetchAllMaybeGuard(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+
+export async function fetchAllMaybeGuard(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<MaybeAccount<Guard>[]> {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeGuard(maybeAccount));
+}
+
+export function getGuardSize(): number {
+  return 113;
+}

package/src/core/solana/generated/accounts/index.ts

@@ -0,0 +1,11 @@
+/**
+ * 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
+ */
+
+export * from './adminSingleton.js';
+export * from './guard.js';
+export * from './order.js';