@goplausible/algorand-mcp 3.0.7

package/dist/tools/transactionManager/accountTransactions.js

@@ -0,0 +1,177 @@
+import algosdk, { makePaymentTxnWithSuggestedParamsFromObject, makeKeyRegistrationTxnWithSuggestedParamsFromObject } from 'algosdk';
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
+import { getAlgodClient, extractNetwork } from '../../algorand-client.js';
+import { withCommonParams } from '../commonParams.js';
+// Tool schemas
+export const accountTransactionSchemas = {
+    makePaymentTxn: {
+        type: 'object',
+        description: 'Create a payment transaction with proper Algorand address strings',
+        properties: {
+            from: {
+                type: 'string',
+                description: 'Sender address in standard Algorand format (58 characters)'
+            },
+            to: {
+                type: 'string',
+                description: 'Receiver address in standard Algorand format (58 characters)'
+            },
+            amount: {
+                type: 'integer',
+                description: 'Amount in microAlgos'
+            },
+            note: {
+                type: 'string',
+                optional: true,
+                description: 'Optional transaction note'
+            },
+            closeRemainderTo: {
+                type: 'string',
+                optional: true,
+                description: 'Optional close remainder to address in standard Algorand format'
+            },
+            rekeyTo: {
+                type: 'string',
+                optional: true,
+                description: 'Optional rekey to address in standard Algorand format'
+            }
+        },
+        required: ['from', 'to', 'amount']
+    },
+    makeKeyRegTxn: {
+        type: 'object',
+        properties: {
+            from: { type: 'string', description: 'Sender address in standard Algorand format (58 characters)' },
+            voteKey: { type: 'string', description: 'The root participation public key (58 bytes base64 encoded)' },
+            selectionKey: { type: 'string', description: 'VRF public key (32 bytes base64 encoded)' },
+            stateProofKey: { type: 'string', description: 'State proof public key (64 bytes base64 encoded)' },
+            voteFirst: { type: 'integer', description: 'First round this participation key is valid' },
+            voteLast: { type: 'integer', description: 'Last round this participation key is valid' },
+            voteKeyDilution: { type: 'integer', description: 'Dilution for the 2-level participation key' },
+            nonParticipation: { type: 'boolean', optional: true, description: 'Mark account as nonparticipating for rewards' },
+            note: { type: 'string', optional: true, description: 'Transaction note field (up to 1000 bytes)' },
+            rekeyTo: { type: 'string', optional: true, description: 'Address to rekey the sender account to' }
+        },
+        required: ['from', 'voteKey', 'selectionKey', 'stateProofKey', 'voteFirst', 'voteLast', 'voteKeyDilution']
+    }
+};
+// Tool definitions
+export const accountTransactionTools = [
+    {
+        name: 'make_payment_txn',
+        description: 'Create a payment transaction',
+        inputSchema: withCommonParams(accountTransactionSchemas.makePaymentTxn),
+    },
+    {
+        name: 'make_keyreg_txn',
+        description: 'Create a key registration transaction',
+        inputSchema: withCommonParams(accountTransactionSchemas.makeKeyRegTxn),
+    }
+];
+export class AccountTransactionManager {
+    /**
+     * Creates a payment transaction
+     */
+    static makePaymentTxn(txn) {
+        return makePaymentTxnWithSuggestedParamsFromObject(txn);
+    }
+    /**
+     * Creates a key registration transaction
+     */
+    static makeKeyRegTxn(txn) {
+        // Convert string keys to Uint8Array if needed
+        const params = {
+            ...txn,
+            voteKey: typeof txn.voteKey === 'string' ? algosdk.base64ToBytes(txn.voteKey) : txn.voteKey,
+            selectionKey: typeof txn.selectionKey === 'string' ? algosdk.base64ToBytes(txn.selectionKey) : txn.selectionKey,
+            stateProofKey: typeof txn.stateProofKey === 'string' ? algosdk.base64ToBytes(txn.stateProofKey) : txn.stateProofKey,
+        };
+        return makeKeyRegistrationTxnWithSuggestedParamsFromObject(params);
+    }
+    // Tool handlers
+    static async handleTool(name, args) {
+        const network = extractNetwork(args);
+        const algodClient = getAlgodClient(network);
+        const suggestedParams = await algodClient.getTransactionParams().do();
+        switch (name) {
+            case 'make_payment_txn':
+                if (!args.from || !args.to || typeof args.amount !== 'number') {
+                    throw new McpError(ErrorCode.InvalidParams, 'Invalid payment transaction parameters');
+                }
+                try {
+                    // Create payment transaction using SDK's maker function
+                    const txn = AccountTransactionManager.makePaymentTxn({
+                        sender: String(args.from),
+                        receiver: String(args.to),
+                        amount: Number(args.amount),
+                        note: typeof args.note === 'string' ? new TextEncoder().encode(args.note) : undefined,
+                        closeRemainderTo: typeof args.closeRemainderTo === 'string' ? args.closeRemainderTo : undefined,
+                        rekeyTo: typeof args.rekeyTo === 'string' ? args.rekeyTo : undefined,
+                        suggestedParams
+                    });
+                    // Create a clean transaction object for JSON serialization
+                    const cleanTxn = {
+                        sender: String(args.from),
+                        receiver: String(args.to),
+                        amount: Number(args.amount),
+                        fee: suggestedParams.fee,
+                        firstValid: suggestedParams.firstValid,
+                        lastValid: suggestedParams.lastValid,
+                        genesisID: suggestedParams.genesisID,
+                        genesisHash: suggestedParams.genesisHash instanceof Uint8Array
+                            ? algosdk.bytesToBase64(suggestedParams.genesisHash)
+                            : suggestedParams.genesisHash,
+                        type: 'pay'
+                    };
+                    // Add note if provided
+                    if (typeof args.note === 'string') {
+                        const noteBytes = new TextEncoder().encode(args.note);
+                        cleanTxn['note'] = algosdk.bytesToBase64(noteBytes);
+                    }
+                    // Add optional parameters if they exist
+                    if (args.closeRemainderTo) {
+                        cleanTxn['closeRemainderTo'] = String(args.closeRemainderTo);
+                    }
+                    if (args.rekeyTo) {
+                        cleanTxn['rekeyTo'] = String(args.rekeyTo);
+                    }
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify(cleanTxn, null, 2),
+                            }],
+                    };
+                }
+                catch (error) {
+                    throw new McpError(ErrorCode.InvalidParams, `Failed to create payment transaction: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            case 'make_keyreg_txn':
+                if (!args.from || !args.voteKey || !args.selectionKey || !args.stateProofKey ||
+                    typeof args.voteFirst !== 'number' || typeof args.voteLast !== 'number' ||
+                    typeof args.voteKeyDilution !== 'number') {
+                    throw new McpError(ErrorCode.InvalidParams, 'Invalid key registration parameters');
+                }
+                const keyRegTxn = AccountTransactionManager.makeKeyRegTxn({
+                    sender: String(args.from),
+                    voteKey: String(args.voteKey),
+                    selectionKey: String(args.selectionKey),
+                    stateProofKey: String(args.stateProofKey),
+                    voteFirst: Number(args.voteFirst),
+                    voteLast: Number(args.voteLast),
+                    voteKeyDilution: Number(args.voteKeyDilution),
+                    nonParticipation: typeof args.nonParticipation === 'boolean' ? args.nonParticipation : undefined,
+                    note: typeof args.note === 'string' ? new TextEncoder().encode(args.note) : undefined,
+                    rekeyTo: typeof args.rekeyTo === 'string' ? args.rekeyTo : undefined,
+                    suggestedParams,
+                });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(keyRegTxn, null, 2),
+                        }],
+                };
+            default:
+                throw new McpError(ErrorCode.MethodNotFound, `Unknown account transaction tool: ${name}`);
+        }
+    }
+}

package/dist/tools/transactionManager/appTransactions/callTxn.d.ts

@@ -0,0 +1,17 @@
+import { Transaction } from 'algosdk';
+import { AppCallTxnParams } from './types.js';
+/**
+ * Creates an application call (NoOp) transaction
+ * @param params The parameters for calling the application
+ * @returns The created transaction
+ * @throws {McpError} If the transaction creation fails
+ */
+export declare function makeApplicationCallTxn(params: AppCallTxnParams): Transaction;
+/**
+ * Handles the application call tool request
+ * @param args The tool arguments
+ * @param suggestedParams The suggested transaction parameters
+ * @returns The transaction parameters
+ * @throws {McpError} If the parameters are invalid
+ */
+export declare function handleCallTxn(args: Record<string, unknown>, suggestedParams: any): Record<string, any>;

package/dist/tools/transactionManager/appTransactions/callTxn.js

@@ -0,0 +1,95 @@
+import algosdk, { makeApplicationNoOpTxnFromObject, OnApplicationComplete } from 'algosdk';
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Creates an application call (NoOp) transaction
+ * @param params The parameters for calling the application
+ * @returns The created transaction
+ * @throws {McpError} If the transaction creation fails
+ */
+export function makeApplicationCallTxn(params) {
+    try {
+        // Create a new object with the required structure
+        const txnParams = {
+            sender: params.sender,
+            appIndex: params.appIndex,
+            suggestedParams: params.suggestedParams,
+            note: params.note,
+            lease: params.lease,
+            rekeyTo: params.rekeyTo,
+            appArgs: params.appArgs,
+            accounts: params.accounts,
+            foreignApps: params.foreignApps,
+            foreignAssets: params.foreignAssets,
+            boxes: params.boxes
+        };
+        return makeApplicationNoOpTxnFromObject(txnParams);
+    }
+    catch (error) {
+        console.error('[MCP Error] Failed to create application call transaction:', error);
+        throw new McpError(ErrorCode.InternalError, `Failed to create application call transaction: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Handles the application call tool request
+ * @param args The tool arguments
+ * @param suggestedParams The suggested transaction parameters
+ * @returns The transaction parameters
+ * @throws {McpError} If the parameters are invalid
+ */
+export function handleCallTxn(args, suggestedParams) {
+    try {
+        if (!args.from || !args.appIndex) {
+            console.error('[MCP Error] Invalid application call parameters');
+            throw new McpError(ErrorCode.InvalidParams, 'Invalid application call parameters');
+        }
+        // Create transaction with proper parameter handling
+        const txnParams = {
+            sender: String(args.from),
+            appIndex: Number(args.appIndex),
+            fee: suggestedParams.fee,
+            firstValid: suggestedParams.firstValid,
+            lastValid: suggestedParams.lastValid,
+            genesisID: suggestedParams.genesisID,
+            genesisHash: suggestedParams.genesisHash instanceof Uint8Array
+                ? algosdk.bytesToBase64(suggestedParams.genesisHash)
+                : suggestedParams.genesisHash,
+            type: 'appl',
+            onComplete: OnApplicationComplete.NoOpOC
+        };
+        // Handle optional fields
+        if (typeof args.note === 'string') {
+            const noteBytes = new TextEncoder().encode(args.note);
+            txnParams.note = algosdk.bytesToBase64(noteBytes);
+        }
+        if (typeof args.lease === 'string') {
+            const leaseBytes = new TextEncoder().encode(args.lease);
+            txnParams.lease = algosdk.bytesToBase64(leaseBytes);
+        }
+        if (typeof args.rekeyTo === 'string') {
+            txnParams.rekeyTo = String(args.rekeyTo);
+        }
+        if (Array.isArray(args.appArgs)) {
+            txnParams.appArgs = args.appArgs.map(arg => {
+                const bytes = new TextEncoder().encode(String(arg));
+                return algosdk.bytesToBase64(bytes);
+            });
+        }
+        if (Array.isArray(args.accounts)) {
+            txnParams.accounts = args.accounts.filter((acc) => typeof acc === 'string');
+        }
+        if (Array.isArray(args.foreignApps)) {
+            txnParams.foreignApps = args.foreignApps.filter((app) => typeof app === 'number');
+        }
+        if (Array.isArray(args.foreignAssets)) {
+            txnParams.foreignAssets = args.foreignAssets.filter((asset) => typeof asset === 'number');
+        }
+        return txnParams;
+    }
+    catch (error) {
+        if (error instanceof McpError) {
+            throw error;
+        }
+        console.error('[MCP Error] Failed to handle application call:', error);
+        throw new McpError(ErrorCode.InternalError, `Failed to handle application call: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/tools/transactionManager/appTransactions/clearTxn.d.ts

@@ -0,0 +1,17 @@
+import { Transaction } from 'algosdk';
+import { AppClearStateTxnParams } from './types.js';
+/**
+ * Creates an application clear state transaction
+ * @param params The parameters for clearing application state
+ * @returns The created transaction
+ * @throws {McpError} If the transaction creation fails
+ */
+export declare function makeApplicationClearStateTxn(params: AppClearStateTxnParams): Transaction;
+/**
+ * Handles the application clear state tool request
+ * @param args The tool arguments
+ * @param suggestedParams The suggested transaction parameters
+ * @returns The transaction parameters
+ * @throws {McpError} If the parameters are invalid
+ */
+export declare function handleClearTxn(args: Record<string, unknown>, suggestedParams: any): Record<string, any>;

package/dist/tools/transactionManager/appTransactions/clearTxn.js

@@ -0,0 +1,95 @@
+import algosdk, { makeApplicationClearStateTxnFromObject, OnApplicationComplete } from 'algosdk';
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Creates an application clear state transaction
+ * @param params The parameters for clearing application state
+ * @returns The created transaction
+ * @throws {McpError} If the transaction creation fails
+ */
+export function makeApplicationClearStateTxn(params) {
+    try {
+        // Create a new object with the required structure
+        const txnParams = {
+            sender: params.sender,
+            appIndex: params.appIndex,
+            suggestedParams: params.suggestedParams,
+            note: params.note,
+            lease: params.lease,
+            rekeyTo: params.rekeyTo,
+            appArgs: params.appArgs,
+            accounts: params.accounts,
+            foreignApps: params.foreignApps,
+            foreignAssets: params.foreignAssets,
+            boxes: params.boxes
+        };
+        return makeApplicationClearStateTxnFromObject(txnParams);
+    }
+    catch (error) {
+        console.error('[MCP Error] Failed to create application clear state transaction:', error);
+        throw new McpError(ErrorCode.InternalError, `Failed to create application clear state transaction: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Handles the application clear state tool request
+ * @param args The tool arguments
+ * @param suggestedParams The suggested transaction parameters
+ * @returns The transaction parameters
+ * @throws {McpError} If the parameters are invalid
+ */
+export function handleClearTxn(args, suggestedParams) {
+    try {
+        if (!args.from || !args.appIndex) {
+            console.error('[MCP Error] Invalid application clear state parameters');
+            throw new McpError(ErrorCode.InvalidParams, 'Invalid application clear state parameters');
+        }
+        // Create transaction with proper parameter handling
+        const txnParams = {
+            sender: String(args.from),
+            appIndex: Number(args.appIndex),
+            fee: suggestedParams.fee,
+            firstValid: suggestedParams.firstValid,
+            lastValid: suggestedParams.lastValid,
+            genesisID: suggestedParams.genesisID,
+            genesisHash: suggestedParams.genesisHash instanceof Uint8Array
+                ? algosdk.bytesToBase64(suggestedParams.genesisHash)
+                : suggestedParams.genesisHash,
+            type: 'appl',
+            onComplete: OnApplicationComplete.ClearStateOC
+        };
+        // Handle optional fields
+        if (typeof args.note === 'string') {
+            const noteBytes = new TextEncoder().encode(args.note);
+            txnParams.note = algosdk.bytesToBase64(noteBytes);
+        }
+        if (typeof args.lease === 'string') {
+            const leaseBytes = new TextEncoder().encode(args.lease);
+            txnParams.lease = algosdk.bytesToBase64(leaseBytes);
+        }
+        if (typeof args.rekeyTo === 'string') {
+            txnParams.rekeyTo = String(args.rekeyTo);
+        }
+        if (Array.isArray(args.appArgs)) {
+            txnParams.appArgs = args.appArgs.map(arg => {
+                const bytes = new TextEncoder().encode(String(arg));
+                return algosdk.bytesToBase64(bytes);
+            });
+        }
+        if (Array.isArray(args.accounts)) {
+            txnParams.accounts = args.accounts.filter((acc) => typeof acc === 'string');
+        }
+        if (Array.isArray(args.foreignApps)) {
+            txnParams.foreignApps = args.foreignApps.filter((app) => typeof app === 'number');
+        }
+        if (Array.isArray(args.foreignAssets)) {
+            txnParams.foreignAssets = args.foreignAssets.filter((asset) => typeof asset === 'number');
+        }
+        return txnParams;
+    }
+    catch (error) {
+        if (error instanceof McpError) {
+            throw error;
+        }
+        console.error('[MCP Error] Failed to handle application clear state:', error);
+        throw new McpError(ErrorCode.InternalError, `Failed to handle application clear state: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/tools/transactionManager/appTransactions/closeOutTxn.d.ts

@@ -0,0 +1,17 @@
+import { Transaction } from 'algosdk';
+import { AppCloseOutTxnParams } from './types.js';
+/**
+ * Creates an application close-out transaction
+ * @param params The parameters for closing out from the application
+ * @returns The created transaction
+ * @throws {McpError} If the transaction creation fails
+ */
+export declare function makeApplicationCloseOutTxn(params: AppCloseOutTxnParams): Transaction;
+/**
+ * Handles the application close-out tool request
+ * @param args The tool arguments
+ * @param suggestedParams The suggested transaction parameters
+ * @returns The transaction parameters
+ * @throws {McpError} If the parameters are invalid
+ */
+export declare function handleCloseOutTxn(args: Record<string, unknown>, suggestedParams: any): Record<string, any>;

package/dist/tools/transactionManager/appTransactions/closeOutTxn.js

@@ -0,0 +1,95 @@
+import algosdk, { makeApplicationCloseOutTxnFromObject, OnApplicationComplete } from 'algosdk';
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Creates an application close-out transaction
+ * @param params The parameters for closing out from the application
+ * @returns The created transaction
+ * @throws {McpError} If the transaction creation fails
+ */
+export function makeApplicationCloseOutTxn(params) {
+    try {
+        // Create a new object with the required structure
+        const txnParams = {
+            sender: params.sender,
+            appIndex: params.appIndex,
+            suggestedParams: params.suggestedParams,
+            note: params.note,
+            lease: params.lease,
+            rekeyTo: params.rekeyTo,
+            appArgs: params.appArgs,
+            accounts: params.accounts,
+            foreignApps: params.foreignApps,
+            foreignAssets: params.foreignAssets,
+            boxes: params.boxes
+        };
+        return makeApplicationCloseOutTxnFromObject(txnParams);
+    }
+    catch (error) {
+        console.error('[MCP Error] Failed to create application close-out transaction:', error);
+        throw new McpError(ErrorCode.InternalError, `Failed to create application close-out transaction: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Handles the application close-out tool request
+ * @param args The tool arguments
+ * @param suggestedParams The suggested transaction parameters
+ * @returns The transaction parameters
+ * @throws {McpError} If the parameters are invalid
+ */
+export function handleCloseOutTxn(args, suggestedParams) {
+    try {
+        if (!args.from || !args.appIndex) {
+            console.error('[MCP Error] Invalid application close-out parameters');
+            throw new McpError(ErrorCode.InvalidParams, 'Invalid application close-out parameters');
+        }
+        // Create transaction with proper parameter handling
+        const txnParams = {
+            sender: String(args.from),
+            appIndex: Number(args.appIndex),
+            fee: suggestedParams.fee,
+            firstValid: suggestedParams.firstValid,
+            lastValid: suggestedParams.lastValid,
+            genesisID: suggestedParams.genesisID,
+            genesisHash: suggestedParams.genesisHash instanceof Uint8Array
+                ? algosdk.bytesToBase64(suggestedParams.genesisHash)
+                : suggestedParams.genesisHash,
+            type: 'appl',
+            onComplete: OnApplicationComplete.CloseOutOC
+        };
+        // Handle optional fields
+        if (typeof args.note === 'string') {
+            const noteBytes = new TextEncoder().encode(args.note);
+            txnParams.note = algosdk.bytesToBase64(noteBytes);
+        }
+        if (typeof args.lease === 'string') {
+            const leaseBytes = new TextEncoder().encode(args.lease);
+            txnParams.lease = algosdk.bytesToBase64(leaseBytes);
+        }
+        if (typeof args.rekeyTo === 'string') {
+            txnParams.rekeyTo = String(args.rekeyTo);
+        }
+        if (Array.isArray(args.appArgs)) {
+            txnParams.appArgs = args.appArgs.map(arg => {
+                const bytes = new TextEncoder().encode(String(arg));
+                return algosdk.bytesToBase64(bytes);
+            });
+        }
+        if (Array.isArray(args.accounts)) {
+            txnParams.accounts = args.accounts.filter((acc) => typeof acc === 'string');
+        }
+        if (Array.isArray(args.foreignApps)) {
+            txnParams.foreignApps = args.foreignApps.filter((app) => typeof app === 'number');
+        }
+        if (Array.isArray(args.foreignAssets)) {
+            txnParams.foreignAssets = args.foreignAssets.filter((asset) => typeof asset === 'number');
+        }
+        return txnParams;
+    }
+    catch (error) {
+        if (error instanceof McpError) {
+            throw error;
+        }
+        console.error('[MCP Error] Failed to handle application close-out:', error);
+        throw new McpError(ErrorCode.InternalError, `Failed to handle application close-out: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/tools/transactionManager/appTransactions/createTxn.d.ts

@@ -0,0 +1,17 @@
+import { Transaction } from 'algosdk';
+import { AppCreateTxnParams } from './types.js';
+/**
+ * Creates an application creation transaction
+ * @param params The parameters for creating the application
+ * @returns The created transaction
+ * @throws {McpError} If the transaction creation fails
+ */
+export declare function makeApplicationCreateTxn(params: AppCreateTxnParams): Transaction;
+/**
+ * Handles the application creation tool request
+ * @param args The tool arguments
+ * @param suggestedParams The suggested transaction parameters
+ * @returns The transaction parameters
+ * @throws {McpError} If the parameters are invalid
+ */
+export declare function handleCreateTxn(args: Record<string, unknown>, suggestedParams: any): Record<string, any>;

package/dist/tools/transactionManager/appTransactions/createTxn.js

@@ -0,0 +1,128 @@
+import algosdk, { makeApplicationCreateTxnFromObject, OnApplicationComplete } from 'algosdk';
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Creates an application creation transaction
+ * @param params The parameters for creating the application
+ * @returns The created transaction
+ * @throws {McpError} If the transaction creation fails
+ */
+export function makeApplicationCreateTxn(params) {
+    try {
+        // Validate schema parameters
+        if (typeof params.numGlobalInts !== 'number' || params.numGlobalInts < 0) {
+            throw new Error('Invalid numGlobalInts');
+        }
+        if (typeof params.numGlobalByteSlices !== 'number' || params.numGlobalByteSlices < 0) {
+            throw new Error('Invalid numGlobalByteSlices');
+        }
+        if (typeof params.numLocalInts !== 'number' || params.numLocalInts < 0) {
+            throw new Error('Invalid numLocalInts');
+        }
+        if (typeof params.numLocalByteSlices !== 'number' || params.numLocalByteSlices < 0) {
+            throw new Error('Invalid numLocalByteSlices');
+        }
+        // Create a new object with the required structure
+        const txnParams = {
+            sender: params.sender,
+            approvalProgram: params.approvalProgram,
+            clearProgram: params.clearProgram,
+            suggestedParams: params.suggestedParams,
+            note: params.note,
+            lease: params.lease,
+            rekeyTo: params.rekeyTo,
+            appArgs: params.appArgs,
+            accounts: params.accounts,
+            foreignApps: params.foreignApps,
+            foreignAssets: params.foreignAssets,
+            boxes: params.boxes,
+            extraPages: params.extraPages,
+            onComplete: OnApplicationComplete.NoOpOC,
+            // Schema parameters
+            numGlobalInts: params.numGlobalInts,
+            numGlobalByteSlices: params.numGlobalByteSlices,
+            numLocalInts: params.numLocalInts,
+            numLocalByteSlices: params.numLocalByteSlices
+        };
+        return makeApplicationCreateTxnFromObject(txnParams);
+    }
+    catch (error) {
+        console.error('[MCP Error] Failed to create application transaction:', error);
+        throw new McpError(ErrorCode.InternalError, `Failed to create application transaction: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Handles the application creation tool request
+ * @param args The tool arguments
+ * @param suggestedParams The suggested transaction parameters
+ * @returns The transaction parameters
+ * @throws {McpError} If the parameters are invalid
+ */
+export function handleCreateTxn(args, suggestedParams) {
+    try {
+        if (!args.from || !args.approvalProgram || !args.clearProgram ||
+            typeof args.numGlobalInts !== 'number' || typeof args.numGlobalByteSlices !== 'number' ||
+            typeof args.numLocalInts !== 'number' || typeof args.numLocalByteSlices !== 'number') {
+            console.error('[MCP Error] Invalid application creation parameters');
+            throw new McpError(ErrorCode.InvalidParams, 'Invalid application creation parameters');
+        }
+        // Create transaction with proper parameter handling
+        const txnParams = {
+            sender: String(args.from),
+            fee: suggestedParams.fee,
+            firstValid: suggestedParams.firstValid,
+            lastValid: suggestedParams.lastValid,
+            genesisID: suggestedParams.genesisID,
+            genesisHash: suggestedParams.genesisHash instanceof Uint8Array
+                ? algosdk.bytesToBase64(suggestedParams.genesisHash)
+                : suggestedParams.genesisHash,
+            type: 'appl',
+            onComplete: OnApplicationComplete.NoOpOC,
+            // Schema parameters
+            numGlobalInts: Number(args.numGlobalInts),
+            numGlobalByteSlices: Number(args.numGlobalByteSlices),
+            numLocalInts: Number(args.numLocalInts),
+            numLocalByteSlices: Number(args.numLocalByteSlices)
+        };
+        // Handle required program fields - keep as base64 strings
+        txnParams.approvalProgram = args.approvalProgram;
+        txnParams.clearProgram = args.clearProgram;
+        // Handle optional fields
+        if (typeof args.extraPages === 'number') {
+            txnParams.extraPages = args.extraPages;
+        }
+        if (typeof args.note === 'string') {
+            const noteBytes = new TextEncoder().encode(args.note);
+            txnParams.note = algosdk.bytesToBase64(noteBytes);
+        }
+        if (typeof args.lease === 'string') {
+            const leaseBytes = new TextEncoder().encode(args.lease);
+            txnParams.lease = algosdk.bytesToBase64(leaseBytes);
+        }
+        if (typeof args.rekeyTo === 'string') {
+            txnParams.rekeyTo = String(args.rekeyTo);
+        }
+        if (Array.isArray(args.appArgs)) {
+            txnParams.appArgs = args.appArgs.map(arg => {
+                const bytes = new TextEncoder().encode(String(arg));
+                return algosdk.bytesToBase64(bytes);
+            });
+        }
+        if (Array.isArray(args.accounts)) {
+            txnParams.accounts = args.accounts.filter((acc) => typeof acc === 'string');
+        }
+        if (Array.isArray(args.foreignApps)) {
+            txnParams.foreignApps = args.foreignApps.filter((app) => typeof app === 'number');
+        }
+        if (Array.isArray(args.foreignAssets)) {
+            txnParams.foreignAssets = args.foreignAssets.filter((asset) => typeof asset === 'number');
+        }
+        return txnParams;
+    }
+    catch (error) {
+        if (error instanceof McpError) {
+            throw error;
+        }
+        console.error('[MCP Error] Failed to handle application creation:', error);
+        throw new McpError(ErrorCode.InternalError, `Failed to handle application creation: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}