@heyanon/sdk 2.4.0 → 2.4.2

package/dist/adapter/types.d.ts

@@ -1,10 +1,10 @@
 import { OpenAI } from 'openai';
 import { EVM, Solana, TON, WalletType, Chain } from '../blockchain';
-import { Hex, PublicClient, SignMessageReturnType, SignTypedDataParameters as ViemSignTypedDataParameters, SignTypedDataReturnType, Address } from 'viem';
+import { PublicClient, SignMessageReturnType, SignTypedDataReturnType, Address } from 'viem';
 import { Connection, PublicKey, Transaction as SolanaTransaction, VersionedTransaction as SolanaVersionedTransaction } from '@solana/web3.js';
 import { AdapterTag } from './misc';
 import { Address as TonAddress } from '@ton/ton';
-import { DeployContractProps } from '../blockchain/evm/types';
+import { DeployContractProps, SignMessagesProps, SignTypedDatasProps } from '../blockchain/evm/types';
 import { Exchange, exchanges } from 'ccxt';
 /**
  * Result of adapter function execution
@@ -23,7 +23,6 @@ export interface FunctionReturn {
     /** Result data as string */
     readonly data: string;
 }
-type SignTypedDataParameters = Omit<ViemSignTypedDataParameters, 'account'>;
 /**
  * Options for working with EVM blockchains
  * @interface EvmFunctionOptions
@@ -47,9 +46,9 @@ export interface EvmFunctionOptions {
     /** Deploy smart contracts */
     readonly deployContracts?: (props: DeployContractProps) => Promise<Address[]>;
     /** Sign messages (optional) */
-    readonly signMessages?: (messages: Hex[]) => Promise<SignMessageReturnType[]>;
+    readonly signMessages?: (props: SignMessagesProps) => Promise<SignMessageReturnType[]>;
     /** Sign typed data (optional) */
-    readonly signTypedDatas?: (args: SignTypedDataParameters[]) => Promise<SignTypedDataReturnType[]>;
+    readonly signTypedDatas?: (props: SignTypedDatasProps) => Promise<SignTypedDataReturnType[]>;
 }
 /**
  * Options for working with Solana blockchain
@@ -71,7 +70,7 @@ export interface SolanaFunctionOptions {
     /** Send transactions */
     readonly sendTransactions: (props: Solana.types.SendTransactionProps) => Promise<Solana.types.TransactionReturn>;
     /** Sign transactions (optional) */
-    readonly signTransactions?: (transactions: Solana.types.SignTransactionProps[]) => Promise<(SolanaTransaction | SolanaVersionedTransaction)[]>;
+    readonly signTransactions?: (props: Solana.types.SignTransactionsProps) => Promise<(SolanaTransaction | SolanaVersionedTransaction)[]>;
 }
 /**
  * Options for working with TON blockchain
@@ -183,4 +182,3 @@ export interface AdapterExport {
     /** Tools for OpenAI integration */
     readonly tools: OpenAI.Chat.Completions.ChatCompletionTool[];
 }
-export {};

package/dist/blockchain/evm/types.d.ts

@@ -1,4 +1,4 @@
-import { Abi, Address, Hex } from 'viem';
+import { Abi, Address, Hex, SignTypedDataParameters } from 'viem';
 /**
  * Parameters for an EVM transaction
  * @interface TransactionParams
@@ -300,3 +300,96 @@ export interface DeployContractProps {
     /** Array of contracts to deploy */
     readonly contracts: ContractProps[];
 }
+/**
+ * Properties for signing one or multiple messages
+ * @interface SignMessagesProps
+ * @example
+ * ```typescript
+ * // Single message
+ * const signProps: SignMessagesProps = {
+ *   account: '0x742d35Cc6634C0532925a3b8D4C2CA1c1DfF0bE8',
+ *   messages: ['0x1234567890abcdef...']
+ * };
+ *
+ * // Batch messages (multi-sig)
+ * const batchSignProps: SignMessagesProps = {
+ *   account: '0x742d35Cc6634C0532925a3b8D4C2CA1c1DfF0bE8',
+ *   messages: ['0x1111...', '0x2222...', '0x3333...']
+ * };
+ * ```
+ */
+export interface SignMessagesProps {
+    /** Account address that will sign the messages */
+    readonly account: Address;
+    /** Array of messages to sign */
+    readonly messages: Hex[];
+}
+/**
+ * Properties for signing one or multiple typed data
+ * @interface SignTypedDatasProps
+ * @example
+ * ```typescript
+ * // Single typed data
+ * const signProps: SignTypedDatasProps = {
+ *   account: '0x742d35Cc6634C0532925a3b8D4C2CA1c1DfF0bE8',
+ *   datas: [{
+ *     domain: {
+ *       name: 'My Token',
+ *       version: '1.0.0',
+ *       chainId: 1,
+ *       verifyingContract: '0x1234567890abcdef...'
+ *     },
+ *     primaryType: 'MyToken',
+ *     message: {
+ *       name: 'My Token',
+ *       symbol: 'MTK',
+ *       decimals: 18,
+ *       totalSupply: parseUnits('1000000', 18)
+ *     }
+ *   }]
+ * };
+ *
+ * // Batch typed data (multi-sig)
+ * const batchSignProps: SignTypedDatasProps = {
+ *   account: '0x742d35Cc6634C0532925a3b8D4C2CA1c1DfF0bE8',
+ *   datas: [
+ *     {
+ *       domain: {
+ *         name: 'My Token',
+ *         version: '1.0.0',
+ *         chainId: 1,
+ *         verifyingContract: '0x1234567890abcdef...'
+ *       },
+ *       primaryType: 'MyToken',
+ *       message: {
+ *         name: 'My Token',
+ *         symbol: 'MTK',
+ *         decimals: 18,
+ *         totalSupply: parseUnits('1000000', 18)
+ *       }
+ *     },
+ *     {
+ *       domain: {
+ *         name: 'My Token',
+ *         version: '1.0.0',
+ *         chainId: 1,
+ *         verifyingContract: '0x1234567890abcdef...'
+ *       },
+ *       primaryType: 'MyToken',
+ *       message: {
+ *         name: 'My Token',
+ *         symbol: 'MTK',
+ *         decimals: 18,
+ *         totalSupply: parseUnits('1000000', 18)
+ *       }
+ *     }
+ *   ]
+ * };
+ * ```
+ */
+export interface SignTypedDatasProps {
+    /** Account address that will sign the typed data */
+    readonly account: Address;
+    /** Array of typed data to sign */
+    readonly datas: Omit<SignTypedDataParameters, 'account'>[];
+}

package/dist/blockchain/solana/types.d.ts

@@ -187,121 +187,44 @@ export interface SendTransactionProps {
     readonly transactions: VersionedTransaction[];
 }
 /**
- * Properties for signing Solana transactions
- * @interface SignTransactionProps
+ * Properties for signing a single transaction
+ * @interface SignTransaction
  * @example
  * ```typescript
- * // Sign a versioned transaction (default)
- * const signProps: SignTransactionProps = {
+ * const signTransaction: SignTransaction = {
  *   transaction: await buildV0Transaction({
  *     connection: options.solana.getConnection(),
  *     payer: userPublicKey,
- *     instructions: [transferInstruction]
- *   })
- * };
- *
- * // Sign with specific method
- * const partialSignProps: SignTransactionProps = {
- *   transaction: versionedTransaction,
- *   signName: 'partialSign' // For multi-sig scenarios
- * };
- *
- * // Sign legacy transaction
- * const legacySignProps: SignTransactionProps = {
- *   transaction: new Transaction().add(transferInstruction),
+ *     instructions: [SystemProgram.transfer({
+ *       fromPubkey: userPublicKey,
+ *       toPubkey: recipientPublicKey,
+ *       lamports: 0.1 * LAMPORTS_PER_SOL
+ *     })]
+ *   }),
  *   signName: 'sign'
  * };
- *
- * // Multi-signature workflow
- * async function multiSigTransactionFlow(
- *   transaction: VersionedTransaction,
- *   signers: PublicKey[]
- * ) {
- *   const signatures: (VersionedTransaction | Transaction)[] = [];
- *
- *   // Each signer partially signs the transaction
- *   for (const signer of signers) {
- *     const signedTx = await options.solana.signTransactions([{
- *       transaction,
- *       signName: 'partialSign'
- *     }]);
- *
- *     signatures.push(signedTx[0]);
- *   }
- *
- *   return signatures;
- * }
- *
- * // Batch signing
- * async function signMultipleTransactions(
- *   transactions: (VersionedTransaction | Transaction)[]
- * ) {
- *   const signProps = transactions.map(tx => ({
- *     transaction: tx,
- *     signName: 'sign' as const
- *   }));
- *
- *   return await options.solana.signTransactions(signProps);
- * }
- *
- * // Conditional signing based on transaction type
- * function createSignProps(
- *   transaction: VersionedTransaction | Transaction,
- *   isMultiSig: boolean = false
- * ): SignTransactionProps {
- *   return {
- *     transaction,
- *     signName: isMultiSig ? 'partialSign' : 'sign'
- *   };
- * }
- *
- * // Prepare transaction for signing
- * async function prepareAndSignTransaction(
- *   instructions: TransactionInstruction[],
- *   requiresPartialSign: boolean = false
- * ) {
- *   const transaction = await buildV0Transaction({
- *     connection: options.solana.getConnection(),
- *     payer: await options.solana.getPublicKey(),
- *     instructions
- *   });
- *
- *   const signProps: SignTransactionProps = {
- *     transaction,
- *     signName: requiresPartialSign ? 'partialSign' : 'sign'
- *   };
- *
- *   const [signedTransaction] = await options.solana.signTransactions([signProps]);
- *   return signedTransaction;
- * }
- *
- * // Integration with wallet adapters
- * async function signTransactionWithWallet(
- *   transaction: VersionedTransaction,
- *   walletType: 'phantom' | 'solflare' | 'backpack'
- * ) {
- *   const signProps: SignTransactionProps = {
- *     transaction,
- *     signName: 'sign'
- *   };
- *
- *   // Different wallets might have different signing patterns
- *   switch (walletType) {
- *     case 'phantom':
- *       return await options.solana.signTransactions([signProps]);
- *     case 'solflare':
- *       return await options.solana.signTransactions([signProps]);
- *     case 'backpack':
- *       return await options.solana.signTransactions([signProps]);
- *     default:
- *       throw new Error(`Unsupported wallet: ${walletType}`);
- *   }
- * }
  * ```
  */
-export interface SignTransactionProps {
+export interface SignTransaction {
     /** Transaction to sign (versioned or legacy) */
     readonly transaction: VersionedTransaction | Transaction;
     /** Signing method - 'sign' for full signature, 'partialSign' for multi-sig scenarios */
     readonly signName?: 'sign' | 'partialSign';
 }
+/**
+ * Properties for signing one or multiple transactions
+ * @interface SignTransactionsProps
+ * @example
+ * ```typescript
+ * const signTransactions: SignTransactionsProps = {
+ *   account: userPublicKey,
+ *   transactions: [signTransaction]
+ * };
+ * ```
+ */
+export interface SignTransactionsProps {
+    /** Account that will sign the transactions */
+    readonly account: PublicKey;
+    /** Array of transactions to sign */
+    readonly transactions: SignTransaction[];
+}