@shogun-sdk/intents-sdk 1.2.6-test → 1.2.6-test.2

package/src/core/evm/cross-chain-limit-order.ts

@@ -1,16 +1,16 @@
-import { ethers, type TypedDataField, type AddressLike, type BigNumberish } from "ethers";
-import { SignatureTransfer } from "./permit2-signature-transfer.js";
+import { ethers, type TypedDataField, type AddressLike, type BigNumberish } from 'ethers';
+import { SignatureTransfer } from '@uniswap/permit2-sdk';
 
 export const OrderInfoType: Record<string, TypedDataField[]> = {
   OrderInfo: [
-    { name: "user", type: "address" },
-    { name: "tokenIn", type: "address" },
-    { name: "srcChainId", type: "uint32" },
-    { name: "deadline", type: "uint32" },
-    { name: "amountIn", type: "uint128" },
-    { name: "minStablecoinsAmount", type: "uint128" },
-    { name: "executionDetailsHash", type: "bytes32" },
-    { name: "nonce", type: "uint256" },
+    { name: 'user', type: 'address' },
+    { name: 'tokenIn', type: 'address' },
+    { name: 'srcChainId', type: 'uint32' },
+    { name: 'deadline', type: 'uint32' },
+    { name: 'amountIn', type: 'uint128' },
+    { name: 'minStablecoinsAmount', type: 'uint128' },
+    { name: 'executionDetailsHash', type: 'bytes32' },
+    { name: 'nonce', type: 'uint256' },
   ],
 };
 
@@ -33,7 +33,7 @@ export async function signCrossChainLimitOrder(
   orderInfo: OrderInfoStruct,
   chainId: number,
   guardAddress: string,
-  permit2Address: string
+  permit2Address: string,
 ): Promise<{
   domain: any;
   types: any;
@@ -54,9 +54,9 @@ export async function signCrossChainLimitOrder(
     chainId,
     {
       witness: orderInfo,
-      witnessTypeName: "OrderInfo",
+      witnessTypeName: 'OrderInfo',
       witnessType: OrderInfoType,
-    }
+    },
   );
 
   return {
@@ -70,7 +70,7 @@ export async function signCrossChainLimitOrder(
         verifyingContract: permitData.domain.verifyingContract,
       },
       permitData.types,
-      permitData.values
+      permitData.values,
     ),
   };
 }

package/src/core/evm/intent-helpers.ts

@@ -1,10 +1,18 @@
 import type { SupportedEvmChain } from '../../chains.js';
-import type { SingleChainUserIntentRequest, CrossChainUserIntentRequest, DcaSingleChainUserIntentRequest } from '../../types/intent.js';
+import type {
+  SingleChainUserIntentRequest,
+  CrossChainUserIntentRequest,
+  DcaSingleChainUserIntentRequest,
+} from '../../types/intent.js';
 import type { SingleChainOrder } from '../orders/single-chain.js';
 import type { CrossChainOrder } from '../orders/cross-chain.js';
 import type { DcaSingleChainOrder } from '../orders/dca-single-chain.js';
 import type { ExtraTransfer } from '../orders/common.js';
-import { getEVMCrossChainOrderTypedData, getEVMSingleChainOrderTypedData, getEVMDcaSingleChainOrderTypedData } from './order-signature.js';
+import {
+  getEVMCrossChainOrderTypedData,
+  getEVMSingleChainOrderTypedData,
+  getEVMDcaSingleChainOrderTypedData,
+} from './order-signature.js';
 import { generateExecutionDetailsHash } from '../../utils/generate-execution-details-hash.js';
 import { Parsers } from '../../utils/parsers.js';
 
@@ -65,7 +73,7 @@ export type CreateEvmCrossChainOrderIntentParams = {
  * @returns Formatted intent request ready to send to auctioneer
  */
 export function createEvmSingleChainLimitOrderIntentRequest(
-  params: CreateEvmSingleChainLimitOrderIntentParams
+  params: CreateEvmSingleChainLimitOrderIntentParams,
 ): SingleChainUserIntentRequest {
   const order: SingleChainOrder = {
     user: params.user,
@@ -98,7 +106,7 @@ export function createEvmSingleChainLimitOrderIntentRequest(
  * @returns Formatted intent request ready to send to auctioneer
  */
 export function createEvmSingleChainDcaOrderIntentRequest(
-  params: CreateEvmSingleChainDcaOrderIntentParams
+  params: CreateEvmSingleChainDcaOrderIntentParams,
 ): DcaSingleChainUserIntentRequest {
   const order: DcaSingleChainOrder = {
     user: params.user,
@@ -132,7 +140,7 @@ export function createEvmSingleChainDcaOrderIntentRequest(
  * @returns Formatted intent request ready to send to auctioneer
  */
 export function createEvmCrossChainOrderIntentRequest(
-  params: CreateEvmCrossChainOrderIntentParams
+  params: CreateEvmCrossChainOrderIntentParams,
 ): CrossChainUserIntentRequest {
   const executionDetails = {
     destChainId: params.destinationChainId,
@@ -146,9 +154,7 @@ export function createEvmCrossChainOrderIntentRequest(
   const executionDetailsString = JSON.stringify(executionDetails, Parsers.bigIntReplacer);
 
   // Calculate execution details hash
-  const executionDetailsHash = generateExecutionDetailsHash(
-    executionDetails
-  );
+  const executionDetailsHash = generateExecutionDetailsHash(executionDetails);
 
   const genericData = {
     user: params.user,

package/src/core/evm/single-chain-dca-order.ts

@@ -1,20 +1,20 @@
-import { ethers, type TypedDataField, type AddressLike, type BigNumberish, type BytesLike } from "ethers";
-import { SignatureTransfer } from "./permit2-signature-transfer.js";
-import { TransferDataType, type TransferDataStruct } from "./types.js";
+import { ethers, type TypedDataField, type AddressLike, type BigNumberish, type BytesLike } from 'ethers';
+import { SignatureTransfer } from '@uniswap/permit2-sdk';
+import { TransferDataType, type TransferDataStruct } from './types.js';
 
 export const SingleChainDcaOrderType: Record<string, TypedDataField[]> = {
   SingleChainDcaOrder: [
-    { type: "address", name: "user" },
-    { type: "address", name: "tokenIn" },
-    { type: "uint32", name: "startTime" },
-    { type: "uint256", name: "amountInPerInterval" },
-    { type: "uint24", name: "totalIntervals" },
-    { type: "uint32", name: "intervalDuration" },
-    { type: "TransferData", name: "requestedOutput" },
-    { type: "TransferData[]", name: "extraTransfers" },
-    { type: "bytes", name: "encodedExternalCallData" },
-    { type: "uint32", name: "deadline" },
-    { type: "uint256", name: "nonce" },
+    { type: 'address', name: 'user' },
+    { type: 'address', name: 'tokenIn' },
+    { type: 'uint32', name: 'startTime' },
+    { type: 'uint256', name: 'amountInPerInterval' },
+    { type: 'uint24', name: 'totalIntervals' },
+    { type: 'uint32', name: 'intervalDuration' },
+    { type: 'TransferData', name: 'requestedOutput' },
+    { type: 'TransferData[]', name: 'extraTransfers' },
+    { type: 'bytes', name: 'encodedExternalCallData' },
+    { type: 'uint32', name: 'deadline' },
+    { type: 'uint256', name: 'nonce' },
   ],
   TransferData: TransferDataType.TransferData!,
 };
@@ -41,7 +41,7 @@ export async function signSingleChainDcaOrder(
   order: SingleChainDcaOrderStruct,
   chainId: number,
   guardAddress: string,
-  permit2Address: string
+  permit2Address: string,
 ): Promise<{
   domain: any;
   types: any;
@@ -63,9 +63,9 @@ export async function signSingleChainDcaOrder(
     chainId,
     {
       witness: order,
-      witnessTypeName: "SingleChainDcaOrder",
+      witnessTypeName: 'SingleChainDcaOrder',
       witnessType: SingleChainDcaOrderType,
-    }
+    },
   );
 
   return {
@@ -79,7 +79,7 @@ export async function signSingleChainDcaOrder(
         verifyingContract: permitData.domain.verifyingContract,
       },
       permitData.types,
-      permitData.values
+      permitData.values,
     ),
   };
 }

package/src/core/evm/single-chain-limit-order.ts

@@ -1,17 +1,17 @@
-import { ethers, type TypedDataField, type AddressLike, type BigNumberish, type BytesLike } from "ethers";
-import { SignatureTransfer } from "./permit2-signature-transfer.js";
-import { TransferDataType, type TransferDataStruct } from "./types.js";
+import { ethers, type TypedDataField, type AddressLike, type BigNumberish, type BytesLike } from 'ethers';
+import { SignatureTransfer } from '@uniswap/permit2-sdk';
+import { TransferDataType, type TransferDataStruct } from './types.js';
 
 export const SingleChainLimitOrderType: Record<string, TypedDataField[]> = {
   SingleChainLimitOrder: [
-    { type: "address", name: "user" },
-    { type: "address", name: "tokenIn" },
-    { type: "uint256", name: "amountIn" },
-    { type: "TransferData", name: "requestedOutput" },
-    { type: "TransferData[]", name: "extraTransfers" },
-    { type: "bytes", name: "encodedExternalCallData" },
-    { type: "uint32", name: "deadline" },
-    { type: "uint256", name: "nonce" },
+    { type: 'address', name: 'user' },
+    { type: 'address', name: 'tokenIn' },
+    { type: 'uint256', name: 'amountIn' },
+    { type: 'TransferData', name: 'requestedOutput' },
+    { type: 'TransferData[]', name: 'extraTransfers' },
+    { type: 'bytes', name: 'encodedExternalCallData' },
+    { type: 'uint32', name: 'deadline' },
+    { type: 'uint256', name: 'nonce' },
   ],
   TransferData: TransferDataType.TransferData!,
 };
@@ -35,7 +35,7 @@ export async function signSingleChainLimitOrder(
   order: SingleChainLimitOrderStruct,
   chainId: number,
   guardAddress: string,
-  permit2Address: string
+  permit2Address: string,
 ): Promise<{
   domain: any;
   types: any;
@@ -56,9 +56,9 @@ export async function signSingleChainLimitOrder(
     chainId,
     {
       witness: order,
-      witnessTypeName: "SingleChainLimitOrder",
+      witnessTypeName: 'SingleChainLimitOrder',
       witnessType: SingleChainLimitOrderType,
-    }
+    },
   );
 
   return {
@@ -72,7 +72,7 @@ export async function signSingleChainLimitOrder(
         verifyingContract: permitData.domain.verifyingContract,
       },
       permitData.types,
-      permitData.values
+      permitData.values,
     ),
   };
 }

package/src/core/evm/types.ts

@@ -1,10 +1,10 @@
-import type { AddressLike, BigNumberish, TypedDataField } from "ethers";
+import type { AddressLike, BigNumberish, TypedDataField } from 'ethers';
 
 export const TransferDataType: Record<string, TypedDataField[]> = {
   TransferData: [
-    { type: "address", name: "token" },
-    { type: "address", name: "receiver" },
-    { type: "uint256", name: "amount" },
+    { type: 'address', name: 'token' },
+    { type: 'address', name: 'receiver' },
+    { type: 'uint256', name: 'amount' },
   ],
 };
 

package/src/core/solana/client.ts

@@ -5,7 +5,7 @@ import {
   type RpcSubscriptions,
   type SolanaRpcApiMainnet,
   type SolanaRpcSubscriptionsApi,
-  sendAndConfirmTransactionFactory
+  sendAndConfirmTransactionFactory,
 } from '@solana/kit';
 import type { SolanaConfig } from '../../config.js';
 

package/src/core/solana/dca/single-chain-dca-order.ts

@@ -1,7 +1,7 @@
-import { BN } from "bn.js";
-import { PublicKey } from "@solana/web3.js";
-import type { ExtraTransfer } from "./single-chain-limit-order.js";
-import pkg from "js-sha3";
+import { BN } from 'bn.js';
+import { PublicKey } from '@solana/web3.js';
+import type { ExtraTransfer } from './single-chain-limit-order.js';
+import pkg from 'js-sha3';
 const { keccak256 } = pkg;
 /**
  * Generate secret number and prepare secret hash for single chain DCA orders
@@ -9,24 +9,21 @@ const { keccak256 } = pkg;
  * @param receiver Token OUT receiver Pubkey
  * @param extraTransfers Requested extra transfers
  */
-export function prepareDcaSecretData(
-  tokenOut: PublicKey,
-  receiver: PublicKey,
-  extraTransfers: ExtraTransfer[],
-) {
+export function prepareDcaSecretData(tokenOut: PublicKey, receiver: PublicKey, extraTransfers: ExtraTransfer[]) {
   const secretNumber = new BN(crypto.getRandomValues(new Uint8Array(8)));
-  const secretHash = [...Uint8Array.from(Buffer.from(
-    keccak256([
-      ...tokenOut.toBuffer(),
-      ...receiver.toBuffer(),
-      ...Buffer.concat(extraTransfers.map(t => Buffer.concat([
-        t.token.toBuffer(),
-        t.receiver.toBuffer(),
-      ]))),
-      ...secretNumber.toBuffer('le', 8),
-    ]),
-    'hex'
-  ))];
+  const secretHash = [
+    ...Uint8Array.from(
+      Buffer.from(
+        keccak256([
+          ...tokenOut.toBuffer(),
+          ...receiver.toBuffer(),
+          ...Buffer.concat(extraTransfers.map((t) => Buffer.concat([t.token.toBuffer(), t.receiver.toBuffer()]))),
+          ...secretNumber.toBuffer('le', 8),
+        ]),
+        'hex',
+      ),
+    ),
+  ];
 
   return { secretHash, secretNumber };
 }

package/src/core/solana/dca/single-chain-limit-order.ts

@@ -1,6 +1,6 @@
-import { BN } from "bn.js";
-import { PublicKey } from "@solana/web3.js";
-import pkg from "js-sha3";
+import { BN } from 'bn.js';
+import { PublicKey } from '@solana/web3.js';
+import pkg from 'js-sha3';
 const { keccak256 } = pkg;
 
 export type ExtraTransfer = {
@@ -15,31 +15,28 @@ export type ExtraTransfer = {
  * @param receiver Token OUT receiver Pubkey
  * @param extraTransfers Requested extra transfers
  */
-export function prepareSecretData(
-  tokenOut: PublicKey,
-  receiver: PublicKey,
-  extraTransfers: ExtraTransfer[],
-) {
+export function prepareSecretData(tokenOut: PublicKey, receiver: PublicKey, extraTransfers: ExtraTransfer[]) {
   const secretNumber = new BN(crypto.getRandomValues(new Uint8Array(8)));
-  const secretHash = [...Uint8Array.from(Buffer.from(
-    keccak256([
-      ...tokenOut.toBuffer(),
-      ...receiver.toBuffer(),
-      ...Buffer.concat(extraTransfers.map(t => Buffer.concat([
-        t.token.toBuffer(),
-        t.receiver.toBuffer(),
-      ]))),
-      ...secretNumber.toBuffer('le', 8),
-    ]),
-    'hex'
-  ))];
+  const secretHash = [
+    ...Uint8Array.from(
+      Buffer.from(
+        keccak256([
+          ...tokenOut.toBuffer(),
+          ...receiver.toBuffer(),
+          ...Buffer.concat(extraTransfers.map((t) => Buffer.concat([t.token.toBuffer(), t.receiver.toBuffer()]))),
+          ...secretNumber.toBuffer('le', 8),
+        ]),
+        'hex',
+      ),
+    ),
+  ];
 
   return { secretHash, secretNumber };
 }
 
 export function formatTokenPubkey(token: PublicKey) {
-  if (token.equals(new PublicKey("So11111111111111111111111111111111111111111"))) {
-    return PublicKey.default
+  if (token.equals(new PublicKey('So11111111111111111111111111111111111111111'))) {
+    return PublicKey.default;
   }
 
   return token;

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

@@ -37,9 +37,7 @@ import {
   type ReadonlyUint8Array,
 } from '@solana/codecs';
 
-export const ADMIN_SINGLETON_DISCRIMINATOR = new Uint8Array([
-  179, 22, 254, 245, 204, 230, 222, 194,
-]);
+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);
@@ -72,7 +70,7 @@ export function getAdminSingletonEncoder(): FixedSizeEncoder<AdminSingletonArgs>
       ['pendingAdmin', getAddressEncoder()],
       ['bump', getU8Encoder()],
     ]),
-    (value) => ({ ...value, discriminator: ADMIN_SINGLETON_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: ADMIN_SINGLETON_DISCRIMINATOR }),
   );
 }
 
@@ -90,13 +88,13 @@ export function getAdminSingletonCodec(): FixedSizeCodec<AdminSingletonArgs, Adm
 }
 
 export function decodeAdminSingleton<TAddress extends string = string>(
-  encodedAccount: EncodedAccount<TAddress>
+  encodedAccount: EncodedAccount<TAddress>,
 ): Account<AdminSingleton, TAddress>;
 export function decodeAdminSingleton<TAddress extends string = string>(
-  encodedAccount: MaybeEncodedAccount<TAddress>
+  encodedAccount: MaybeEncodedAccount<TAddress>,
 ): MaybeAccount<AdminSingleton, TAddress>;
 export function decodeAdminSingleton<TAddress extends string = string>(
-  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>
+  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
 ): Account<AdminSingleton, TAddress> | MaybeAccount<AdminSingleton, TAddress> {
   return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getAdminSingletonDecoder());
 }
@@ -104,7 +102,7 @@ export function decodeAdminSingleton<TAddress extends string = string>(
 export async function fetchAdminSingleton<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
   address: Address<TAddress>,
-  config?: FetchAccountConfig
+  config?: FetchAccountConfig,
 ): Promise<Account<AdminSingleton, TAddress>> {
   const maybeAccount = await fetchMaybeAdminSingleton(rpc, address, config);
   assertAccountExists(maybeAccount);
@@ -114,7 +112,7 @@ export async function fetchAdminSingleton<TAddress extends string = string>(
 export async function fetchMaybeAdminSingleton<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
   address: Address<TAddress>,
-  config?: FetchAccountConfig
+  config?: FetchAccountConfig,
 ): Promise<MaybeAccount<AdminSingleton, TAddress>> {
   const maybeAccount = await fetchEncodedAccount(rpc, address, config);
   return decodeAdminSingleton(maybeAccount);
@@ -123,7 +121,7 @@ export async function fetchMaybeAdminSingleton<TAddress extends string = string>
 export async function fetchAllAdminSingleton(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
   addresses: Array<Address>,
-  config?: FetchAccountsConfig
+  config?: FetchAccountsConfig,
 ): Promise<Account<AdminSingleton>[]> {
   const maybeAccounts = await fetchAllMaybeAdminSingleton(rpc, addresses, config);
   assertAccountsExist(maybeAccounts);
@@ -133,7 +131,7 @@ export async function fetchAllAdminSingleton(
 export async function fetchAllMaybeAdminSingleton(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
   addresses: Array<Address>,
-  config?: FetchAccountsConfig
+  config?: FetchAccountsConfig,
 ): Promise<MaybeAccount<AdminSingleton>[]> {
   const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
   return maybeAccounts.map((maybeAccount) => decodeAdminSingleton(maybeAccount));

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

@@ -160,7 +160,7 @@ export function getDcaOrderEncoder(): FixedSizeEncoder<DcaOrderArgs> {
       ['totalExecutedIntervals', getU32Encoder()],
       ['lastExecutedIntervalIndex', getU32Encoder()],
     ]),
-    (value) => ({ ...value, discriminator: DCA_ORDER_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: DCA_ORDER_DISCRIMINATOR }),
   );
 }
 
@@ -194,13 +194,13 @@ export function getDcaOrderCodec(): FixedSizeCodec<DcaOrderArgs, DcaOrder> {
 }
 
 export function decodeDcaOrder<TAddress extends string = string>(
-  encodedAccount: EncodedAccount<TAddress>
+  encodedAccount: EncodedAccount<TAddress>,
 ): Account<DcaOrder, TAddress>;
 export function decodeDcaOrder<TAddress extends string = string>(
-  encodedAccount: MaybeEncodedAccount<TAddress>
+  encodedAccount: MaybeEncodedAccount<TAddress>,
 ): MaybeAccount<DcaOrder, TAddress>;
 export function decodeDcaOrder<TAddress extends string = string>(
-  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>
+  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
 ): Account<DcaOrder, TAddress> | MaybeAccount<DcaOrder, TAddress> {
   return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getDcaOrderDecoder());
 }
@@ -208,7 +208,7 @@ export function decodeDcaOrder<TAddress extends string = string>(
 export async function fetchDcaOrder<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
   address: Address<TAddress>,
-  config?: FetchAccountConfig
+  config?: FetchAccountConfig,
 ): Promise<Account<DcaOrder, TAddress>> {
   const maybeAccount = await fetchMaybeDcaOrder(rpc, address, config);
   assertAccountExists(maybeAccount);
@@ -218,7 +218,7 @@ export async function fetchDcaOrder<TAddress extends string = string>(
 export async function fetchMaybeDcaOrder<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
   address: Address<TAddress>,
-  config?: FetchAccountConfig
+  config?: FetchAccountConfig,
 ): Promise<MaybeAccount<DcaOrder, TAddress>> {
   const maybeAccount = await fetchEncodedAccount(rpc, address, config);
   return decodeDcaOrder(maybeAccount);
@@ -227,7 +227,7 @@ export async function fetchMaybeDcaOrder<TAddress extends string = string>(
 export async function fetchAllDcaOrder(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
   addresses: Array<Address>,
-  config?: FetchAccountsConfig
+  config?: FetchAccountsConfig,
 ): Promise<Account<DcaOrder>[]> {
   const maybeAccounts = await fetchAllMaybeDcaOrder(rpc, addresses, config);
   assertAccountsExist(maybeAccounts);
@@ -237,7 +237,7 @@ export async function fetchAllDcaOrder(
 export async function fetchAllMaybeDcaOrder(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
   addresses: Array<Address>,
-  config?: FetchAccountsConfig
+  config?: FetchAccountsConfig,
 ): Promise<MaybeAccount<DcaOrder>[]> {
   const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
   return maybeAccounts.map((maybeAccount) => decodeDcaOrder(maybeAccount));

package/src/core/solana/generated/cross-chain/accounts/guard.ts

@@ -87,7 +87,7 @@ export function getGuardEncoder(): FixedSizeEncoder<GuardArgs> {
       ['auctioneerPubKey', getAddressEncoder()],
       ['collectedFees', getU64Encoder()],
     ]),
-    (value) => ({ ...value, discriminator: GUARD_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: GUARD_DISCRIMINATOR }),
   );
 }
 
@@ -108,13 +108,13 @@ export function getGuardCodec(): FixedSizeCodec<GuardArgs, Guard> {
 }
 
 export function decodeGuard<TAddress extends string = string>(
-  encodedAccount: EncodedAccount<TAddress>
+  encodedAccount: EncodedAccount<TAddress>,
 ): Account<Guard, TAddress>;
 export function decodeGuard<TAddress extends string = string>(
-  encodedAccount: MaybeEncodedAccount<TAddress>
+  encodedAccount: MaybeEncodedAccount<TAddress>,
 ): MaybeAccount<Guard, TAddress>;
 export function decodeGuard<TAddress extends string = string>(
-  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>
+  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
 ): Account<Guard, TAddress> | MaybeAccount<Guard, TAddress> {
   return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getGuardDecoder());
 }
@@ -122,7 +122,7 @@ export function decodeGuard<TAddress extends string = string>(
 export async function fetchGuard<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
   address: Address<TAddress>,
-  config?: FetchAccountConfig
+  config?: FetchAccountConfig,
 ): Promise<Account<Guard, TAddress>> {
   const maybeAccount = await fetchMaybeGuard(rpc, address, config);
   assertAccountExists(maybeAccount);
@@ -132,7 +132,7 @@ export async function fetchGuard<TAddress extends string = string>(
 export async function fetchMaybeGuard<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
   address: Address<TAddress>,
-  config?: FetchAccountConfig
+  config?: FetchAccountConfig,
 ): Promise<MaybeAccount<Guard, TAddress>> {
   const maybeAccount = await fetchEncodedAccount(rpc, address, config);
   return decodeGuard(maybeAccount);
@@ -141,7 +141,7 @@ export async function fetchMaybeGuard<TAddress extends string = string>(
 export async function fetchAllGuard(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
   addresses: Array<Address>,
-  config?: FetchAccountsConfig
+  config?: FetchAccountsConfig,
 ): Promise<Account<Guard>[]> {
   const maybeAccounts = await fetchAllMaybeGuard(rpc, addresses, config);
   assertAccountsExist(maybeAccounts);
@@ -151,7 +151,7 @@ export async function fetchAllGuard(
 export async function fetchAllMaybeGuard(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
   addresses: Array<Address>,
-  config?: FetchAccountsConfig
+  config?: FetchAccountsConfig,
 ): Promise<MaybeAccount<Guard>[]> {
   const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
   return maybeAccounts.map((maybeAccount) => decodeGuard(maybeAccount));

package/src/core/solana/generated/cross-chain/accounts/order.ts

@@ -136,7 +136,7 @@ export function getOrderEncoder(): FixedSizeEncoder<OrderArgs> {
       ['activeSolver', getAddressEncoder()],
       ['executionDeadline', getU32Encoder()],
     ]),
-    (value) => ({ ...value, discriminator: ORDER_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: ORDER_DISCRIMINATOR }),
   );
 }
 
@@ -164,13 +164,13 @@ export function getOrderCodec(): FixedSizeCodec<OrderArgs, Order> {
 }
 
 export function decodeOrder<TAddress extends string = string>(
-  encodedAccount: EncodedAccount<TAddress>
+  encodedAccount: EncodedAccount<TAddress>,
 ): Account<Order, TAddress>;
 export function decodeOrder<TAddress extends string = string>(
-  encodedAccount: MaybeEncodedAccount<TAddress>
+  encodedAccount: MaybeEncodedAccount<TAddress>,
 ): MaybeAccount<Order, TAddress>;
 export function decodeOrder<TAddress extends string = string>(
-  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>
+  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
 ): Account<Order, TAddress> | MaybeAccount<Order, TAddress> {
   return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getOrderDecoder());
 }
@@ -178,7 +178,7 @@ export function decodeOrder<TAddress extends string = string>(
 export async function fetchOrder<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
   address: Address<TAddress>,
-  config?: FetchAccountConfig
+  config?: FetchAccountConfig,
 ): Promise<Account<Order, TAddress>> {
   const maybeAccount = await fetchMaybeOrder(rpc, address, config);
   assertAccountExists(maybeAccount);
@@ -188,7 +188,7 @@ export async function fetchOrder<TAddress extends string = string>(
 export async function fetchMaybeOrder<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
   address: Address<TAddress>,
-  config?: FetchAccountConfig
+  config?: FetchAccountConfig,
 ): Promise<MaybeAccount<Order, TAddress>> {
   const maybeAccount = await fetchEncodedAccount(rpc, address, config);
   return decodeOrder(maybeAccount);
@@ -197,7 +197,7 @@ export async function fetchMaybeOrder<TAddress extends string = string>(
 export async function fetchAllOrder(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
   addresses: Array<Address>,
-  config?: FetchAccountsConfig
+  config?: FetchAccountsConfig,
 ): Promise<Account<Order>[]> {
   const maybeAccounts = await fetchAllMaybeOrder(rpc, addresses, config);
   assertAccountsExist(maybeAccounts);
@@ -207,7 +207,7 @@ export async function fetchAllOrder(
 export async function fetchAllMaybeOrder(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
   addresses: Array<Address>,
-  config?: FetchAccountsConfig
+  config?: FetchAccountsConfig,
 ): Promise<MaybeAccount<Order>[]> {
   const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
   return maybeAccounts.map((maybeAccount) => decodeOrder(maybeAccount));

package/src/core/solana/generated/cross-chain/errors/sourceChainGuard.ts

@@ -183,13 +183,8 @@ export function getSourceChainGuardErrorMessage(code: SourceChainGuardError): st
 export function isSourceChainGuardError<TProgramErrorCode extends SourceChainGuardError>(
   error: unknown,
   transactionMessage: { instructions: Record<number, { programAddress: Address }> },
-  code?: TProgramErrorCode
+  code?: TProgramErrorCode,
 ): error is SolanaError<typeof SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM> &
   Readonly<{ context: Readonly<{ code: TProgramErrorCode }> }> {
-  return isProgramError<TProgramErrorCode>(
-    error,
-    transactionMessage,
-    SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS,
-    code
-  );
+  return isProgramError<TProgramErrorCode>(error, transactionMessage, SOURCE_CHAIN_GUARD_PROGRAM_ADDRESS, code);
 }