near-kit 0.0.0 → 0.2.0

package/dist/core/schema.d.ts

@@ -0,0 +1,1188 @@
+/**
+ * Borsh serialization schemas for NEAR transactions using Zorsh
+ * Based on NEAR Protocol specification and near-api-js implementation
+ *
+ * This module handles the low-level binary serialization details and keeps
+ * all Zorsh-specific types internal. External code should only use the
+ * serializeTransaction and serializeSignedTransaction functions.
+ */
+import { b } from "@zorsh/zorsh";
+import type { DelegateAction, SignedDelegate } from "./actions.js";
+import type { Ed25519PublicKey, Ed25519Signature, PublicKey, Secp256k1PublicKey, Secp256k1Signature, Signature, SignedTransaction, Transaction } from "./types.js";
+/**
+ * Prefix for delegate actions (NEP-366 meta transactions)
+ * Value: 2^30 + 366 = 1073742190
+ *
+ * This prefix is prepended to DelegateAction when serializing for signing,
+ * ensuring delegate action signatures are always distinguishable from
+ * transaction signatures.
+ */
+export declare const DELEGATE_ACTION_PREFIX = 1073742190;
+/**
+ * PublicKey enum (0 = Ed25519, 1 = Secp256k1)
+ */
+export declare const PublicKeySchema: import("@zorsh/zorsh").Schema<{
+    ed25519Key: {
+        data: number[];
+    };
+} | {
+    secp256k1Key: {
+        data: number[];
+    };
+}, string>;
+/**
+ * Signature enum (0 = Ed25519, 1 = Secp256k1)
+ */
+export declare const SignatureSchema: import("@zorsh/zorsh").Schema<{
+    ed25519Signature: {
+        data: number[];
+    };
+} | {
+    secp256k1Signature: {
+        data: number[];
+    };
+}, string>;
+/**
+ * AccessKeyPermission enum (0 = FunctionCall, 1 = FullAccess)
+ */
+declare const AccessKeyPermissionSchema: import("@zorsh/zorsh").Schema<{
+    functionCall: {
+        allowance: bigint | null;
+        receiverId: string;
+        methodNames: string[];
+    };
+} | {
+    fullAccess: {};
+}, string>;
+/**
+ * AccessKeyPermission type inferred from schema
+ */
+export type AccessKeyPermissionBorsh = b.infer<typeof AccessKeyPermissionSchema>;
+/**
+ * CreateAccount action (empty struct)
+ */
+declare const CreateAccountSchema: import("@zorsh/zorsh").Schema<{}, string>;
+/**
+ * DeployContract action with WASM code
+ */
+declare const DeployContractSchema: import("@zorsh/zorsh").Schema<{
+    code: Uint8Array<ArrayBufferLike>;
+}, string>;
+/**
+ * FunctionCall action
+ * Field order: methodName, args, gas, deposit
+ */
+declare const FunctionCallSchema: import("@zorsh/zorsh").Schema<{
+    methodName: string;
+    args: Uint8Array<ArrayBufferLike>;
+    gas: bigint;
+    deposit: bigint;
+}, string>;
+/**
+ * Transfer action with deposit amount
+ */
+declare const TransferSchema: import("@zorsh/zorsh").Schema<{
+    deposit: bigint;
+}, string>;
+/**
+ * Stake action with amount and validator public key
+ */
+declare const StakeSchema: import("@zorsh/zorsh").Schema<{
+    stake: bigint;
+    publicKey: {
+        ed25519Key: {
+            data: number[];
+        };
+    } | {
+        secp256k1Key: {
+            data: number[];
+        };
+    };
+}, string>;
+/**
+ * AddKey action to add a new access key
+ */
+declare const AddKeySchema: import("@zorsh/zorsh").Schema<{
+    publicKey: {
+        ed25519Key: {
+            data: number[];
+        };
+    } | {
+        secp256k1Key: {
+            data: number[];
+        };
+    };
+    accessKey: {
+        nonce: bigint;
+        permission: {
+            functionCall: {
+                allowance: bigint | null;
+                receiverId: string;
+                methodNames: string[];
+            };
+        } | {
+            fullAccess: {};
+        };
+    };
+}, string>;
+/**
+ * DeleteKey action to remove an access key
+ */
+declare const DeleteKeySchema: import("@zorsh/zorsh").Schema<{
+    publicKey: {
+        ed25519Key: {
+            data: number[];
+        };
+    } | {
+        secp256k1Key: {
+            data: number[];
+        };
+    };
+}, string>;
+/**
+ * DeleteAccount action with beneficiary
+ */
+declare const DeleteAccountSchema: import("@zorsh/zorsh").Schema<{
+    beneficiaryId: string;
+}, string>;
+/**
+ * DeployGlobalContract action
+ */
+declare const DeployGlobalContractSchema: import("@zorsh/zorsh").Schema<{
+    code: Uint8Array<ArrayBufferLike>;
+    deployMode: {
+        CodeHash: {};
+    } | {
+        AccountId: {};
+    };
+}, string>;
+/**
+ * UseGlobalContract action
+ */
+declare const UseGlobalContractSchema: import("@zorsh/zorsh").Schema<{
+    contractIdentifier: {
+        CodeHash: number[];
+    } | {
+        AccountId: string;
+    };
+}, string>;
+/**
+ * ClassicActions enum - same as Action but without SignedDelegate
+ * Used within DelegateAction to prevent infinite recursion
+ * Note: The discriminant values must match the NEAR protocol spec
+ */
+declare const ClassicActionsSchema: import("@zorsh/zorsh").Schema<{
+    stake: {
+        stake: bigint;
+        publicKey: {
+            ed25519Key: {
+                data: number[];
+            };
+        } | {
+            secp256k1Key: {
+                data: number[];
+            };
+        };
+    };
+} | {
+    createAccount: {};
+} | {
+    deployContract: {
+        code: Uint8Array<ArrayBufferLike>;
+    };
+} | {
+    functionCall: {
+        methodName: string;
+        args: Uint8Array<ArrayBufferLike>;
+        gas: bigint;
+        deposit: bigint;
+    };
+} | {
+    transfer: {
+        deposit: bigint;
+    };
+} | {
+    addKey: {
+        publicKey: {
+            ed25519Key: {
+                data: number[];
+            };
+        } | {
+            secp256k1Key: {
+                data: number[];
+            };
+        };
+        accessKey: {
+            nonce: bigint;
+            permission: {
+                functionCall: {
+                    allowance: bigint | null;
+                    receiverId: string;
+                    methodNames: string[];
+                };
+            } | {
+                fullAccess: {};
+            };
+        };
+    };
+} | {
+    deleteKey: {
+        publicKey: {
+            ed25519Key: {
+                data: number[];
+            };
+        } | {
+            secp256k1Key: {
+                data: number[];
+            };
+        };
+    };
+} | {
+    deleteAccount: {
+        beneficiaryId: string;
+    };
+} | {
+    deployGlobalContract: {
+        code: Uint8Array<ArrayBufferLike>;
+        deployMode: {
+            CodeHash: {};
+        } | {
+            AccountId: {};
+        };
+    };
+} | {
+    useGlobalContract: {
+        contractIdentifier: {
+            CodeHash: number[];
+        } | {
+            AccountId: string;
+        };
+    };
+}, string>;
+/**
+ * ClassicAction type - actions that can be used within a DelegateAction
+ * This excludes SignedDelegate to prevent infinite nesting
+ */
+export type ClassicAction = b.infer<typeof ClassicActionsSchema>;
+/**
+ * SignedDelegate - a delegate action with signature
+ */
+declare const SignedDelegateSchema: import("@zorsh/zorsh").Schema<{
+    delegateAction: {
+        senderId: string;
+        receiverId: string;
+        actions: ({
+            stake: {
+                stake: bigint;
+                publicKey: {
+                    ed25519Key: {
+                        data: number[];
+                    };
+                } | {
+                    secp256k1Key: {
+                        data: number[];
+                    };
+                };
+            };
+        } | {
+            createAccount: {};
+        } | {
+            deployContract: {
+                code: Uint8Array<ArrayBufferLike>;
+            };
+        } | {
+            functionCall: {
+                methodName: string;
+                args: Uint8Array<ArrayBufferLike>;
+                gas: bigint;
+                deposit: bigint;
+            };
+        } | {
+            transfer: {
+                deposit: bigint;
+            };
+        } | {
+            addKey: {
+                publicKey: {
+                    ed25519Key: {
+                        data: number[];
+                    };
+                } | {
+                    secp256k1Key: {
+                        data: number[];
+                    };
+                };
+                accessKey: {
+                    nonce: bigint;
+                    permission: {
+                        functionCall: {
+                            allowance: bigint | null;
+                            receiverId: string;
+                            methodNames: string[];
+                        };
+                    } | {
+                        fullAccess: {};
+                    };
+                };
+            };
+        } | {
+            deleteKey: {
+                publicKey: {
+                    ed25519Key: {
+                        data: number[];
+                    };
+                } | {
+                    secp256k1Key: {
+                        data: number[];
+                    };
+                };
+            };
+        } | {
+            deleteAccount: {
+                beneficiaryId: string;
+            };
+        } | {
+            deployGlobalContract: {
+                code: Uint8Array<ArrayBufferLike>;
+                deployMode: {
+                    CodeHash: {};
+                } | {
+                    AccountId: {};
+                };
+            };
+        } | {
+            useGlobalContract: {
+                contractIdentifier: {
+                    CodeHash: number[];
+                } | {
+                    AccountId: string;
+                };
+            };
+        })[];
+        nonce: bigint;
+        maxBlockHeight: bigint;
+        publicKey: {
+            ed25519Key: {
+                data: number[];
+            };
+        } | {
+            secp256k1Key: {
+                data: number[];
+            };
+        };
+    };
+    signature: {
+        ed25519Signature: {
+            data: number[];
+        };
+    } | {
+        secp256k1Signature: {
+            data: number[];
+        };
+    };
+}, string>;
+/**
+ * Action enum matching NEAR protocol action discriminants
+ * Order matters! Each position corresponds to the action type index:
+ * 0 = CreateAccount
+ * 1 = DeployContract
+ * 2 = FunctionCall
+ * 3 = Transfer
+ * 4 = Stake
+ * 5 = AddKey
+ * 6 = DeleteKey
+ * 7 = DeleteAccount
+ * 8 = SignedDelegate
+ * 9 = DeployGlobalContract
+ * 10 = UseGlobalContract
+ */
+export declare const ActionSchema: import("@zorsh/zorsh").Schema<{
+    stake: {
+        stake: bigint;
+        publicKey: {
+            ed25519Key: {
+                data: number[];
+            };
+        } | {
+            secp256k1Key: {
+                data: number[];
+            };
+        };
+    };
+} | {
+    createAccount: {};
+} | {
+    deployContract: {
+        code: Uint8Array<ArrayBufferLike>;
+    };
+} | {
+    functionCall: {
+        methodName: string;
+        args: Uint8Array<ArrayBufferLike>;
+        gas: bigint;
+        deposit: bigint;
+    };
+} | {
+    transfer: {
+        deposit: bigint;
+    };
+} | {
+    addKey: {
+        publicKey: {
+            ed25519Key: {
+                data: number[];
+            };
+        } | {
+            secp256k1Key: {
+                data: number[];
+            };
+        };
+        accessKey: {
+            nonce: bigint;
+            permission: {
+                functionCall: {
+                    allowance: bigint | null;
+                    receiverId: string;
+                    methodNames: string[];
+                };
+            } | {
+                fullAccess: {};
+            };
+        };
+    };
+} | {
+    deleteKey: {
+        publicKey: {
+            ed25519Key: {
+                data: number[];
+            };
+        } | {
+            secp256k1Key: {
+                data: number[];
+            };
+        };
+    };
+} | {
+    deleteAccount: {
+        beneficiaryId: string;
+    };
+} | {
+    deployGlobalContract: {
+        code: Uint8Array<ArrayBufferLike>;
+        deployMode: {
+            CodeHash: {};
+        } | {
+            AccountId: {};
+        };
+    };
+} | {
+    useGlobalContract: {
+        contractIdentifier: {
+            CodeHash: number[];
+        } | {
+            AccountId: string;
+        };
+    };
+} | {
+    signedDelegate: {
+        delegateAction: {
+            senderId: string;
+            receiverId: string;
+            actions: ({
+                stake: {
+                    stake: bigint;
+                    publicKey: {
+                        ed25519Key: {
+                            data: number[];
+                        };
+                    } | {
+                        secp256k1Key: {
+                            data: number[];
+                        };
+                    };
+                };
+            } | {
+                createAccount: {};
+            } | {
+                deployContract: {
+                    code: Uint8Array<ArrayBufferLike>;
+                };
+            } | {
+                functionCall: {
+                    methodName: string;
+                    args: Uint8Array<ArrayBufferLike>;
+                    gas: bigint;
+                    deposit: bigint;
+                };
+            } | {
+                transfer: {
+                    deposit: bigint;
+                };
+            } | {
+                addKey: {
+                    publicKey: {
+                        ed25519Key: {
+                            data: number[];
+                        };
+                    } | {
+                        secp256k1Key: {
+                            data: number[];
+                        };
+                    };
+                    accessKey: {
+                        nonce: bigint;
+                        permission: {
+                            functionCall: {
+                                allowance: bigint | null;
+                                receiverId: string;
+                                methodNames: string[];
+                            };
+                        } | {
+                            fullAccess: {};
+                        };
+                    };
+                };
+            } | {
+                deleteKey: {
+                    publicKey: {
+                        ed25519Key: {
+                            data: number[];
+                        };
+                    } | {
+                        secp256k1Key: {
+                            data: number[];
+                        };
+                    };
+                };
+            } | {
+                deleteAccount: {
+                    beneficiaryId: string;
+                };
+            } | {
+                deployGlobalContract: {
+                    code: Uint8Array<ArrayBufferLike>;
+                    deployMode: {
+                        CodeHash: {};
+                    } | {
+                        AccountId: {};
+                    };
+                };
+            } | {
+                useGlobalContract: {
+                    contractIdentifier: {
+                        CodeHash: number[];
+                    } | {
+                        AccountId: string;
+                    };
+                };
+            })[];
+            nonce: bigint;
+            maxBlockHeight: bigint;
+            publicKey: {
+                ed25519Key: {
+                    data: number[];
+                };
+            } | {
+                secp256k1Key: {
+                    data: number[];
+                };
+            };
+        };
+        signature: {
+            ed25519Signature: {
+                data: number[];
+            };
+        } | {
+            secp256k1Signature: {
+                data: number[];
+            };
+        };
+    };
+}, string>;
+/**
+ * Action type inferred from the Borsh schema
+ * This is the single source of truth for action types
+ */
+export type Action = b.infer<typeof ActionSchema>;
+export type TransferAction = {
+    transfer: b.infer<typeof TransferSchema>;
+};
+export type FunctionCallAction = {
+    functionCall: b.infer<typeof FunctionCallSchema>;
+};
+export type CreateAccountAction = {
+    createAccount: b.infer<typeof CreateAccountSchema>;
+};
+export type DeleteAccountAction = {
+    deleteAccount: b.infer<typeof DeleteAccountSchema>;
+};
+export type DeployContractAction = {
+    deployContract: b.infer<typeof DeployContractSchema>;
+};
+export type StakeAction = {
+    stake: b.infer<typeof StakeSchema>;
+};
+export type AddKeyAction = {
+    addKey: b.infer<typeof AddKeySchema>;
+};
+export type DeleteKeyAction = {
+    deleteKey: b.infer<typeof DeleteKeySchema>;
+};
+export type DeployGlobalContractAction = {
+    deployGlobalContract: b.infer<typeof DeployGlobalContractSchema>;
+};
+export type UseGlobalContractAction = {
+    useGlobalContract: b.infer<typeof UseGlobalContractSchema>;
+};
+export type SignedDelegateAction = {
+    signedDelegate: b.infer<typeof SignedDelegateSchema>;
+};
+/**
+ * Transaction schema
+ * Field order: signerId, publicKey, nonce, receiverId, blockHash, actions
+ */
+export declare const TransactionSchema: import("@zorsh/zorsh").Schema<{
+    signerId: string;
+    publicKey: {
+        ed25519Key: {
+            data: number[];
+        };
+    } | {
+        secp256k1Key: {
+            data: number[];
+        };
+    };
+    nonce: bigint;
+    receiverId: string;
+    blockHash: number[];
+    actions: ({
+        stake: {
+            stake: bigint;
+            publicKey: {
+                ed25519Key: {
+                    data: number[];
+                };
+            } | {
+                secp256k1Key: {
+                    data: number[];
+                };
+            };
+        };
+    } | {
+        createAccount: {};
+    } | {
+        deployContract: {
+            code: Uint8Array<ArrayBufferLike>;
+        };
+    } | {
+        functionCall: {
+            methodName: string;
+            args: Uint8Array<ArrayBufferLike>;
+            gas: bigint;
+            deposit: bigint;
+        };
+    } | {
+        transfer: {
+            deposit: bigint;
+        };
+    } | {
+        addKey: {
+            publicKey: {
+                ed25519Key: {
+                    data: number[];
+                };
+            } | {
+                secp256k1Key: {
+                    data: number[];
+                };
+            };
+            accessKey: {
+                nonce: bigint;
+                permission: {
+                    functionCall: {
+                        allowance: bigint | null;
+                        receiverId: string;
+                        methodNames: string[];
+                    };
+                } | {
+                    fullAccess: {};
+                };
+            };
+        };
+    } | {
+        deleteKey: {
+            publicKey: {
+                ed25519Key: {
+                    data: number[];
+                };
+            } | {
+                secp256k1Key: {
+                    data: number[];
+                };
+            };
+        };
+    } | {
+        deleteAccount: {
+            beneficiaryId: string;
+        };
+    } | {
+        deployGlobalContract: {
+            code: Uint8Array<ArrayBufferLike>;
+            deployMode: {
+                CodeHash: {};
+            } | {
+                AccountId: {};
+            };
+        };
+    } | {
+        useGlobalContract: {
+            contractIdentifier: {
+                CodeHash: number[];
+            } | {
+                AccountId: string;
+            };
+        };
+    } | {
+        signedDelegate: {
+            delegateAction: {
+                senderId: string;
+                receiverId: string;
+                actions: ({
+                    stake: {
+                        stake: bigint;
+                        publicKey: {
+                            ed25519Key: {
+                                data: number[];
+                            };
+                        } | {
+                            secp256k1Key: {
+                                data: number[];
+                            };
+                        };
+                    };
+                } | {
+                    createAccount: {};
+                } | {
+                    deployContract: {
+                        code: Uint8Array<ArrayBufferLike>;
+                    };
+                } | {
+                    functionCall: {
+                        methodName: string;
+                        args: Uint8Array<ArrayBufferLike>;
+                        gas: bigint;
+                        deposit: bigint;
+                    };
+                } | {
+                    transfer: {
+                        deposit: bigint;
+                    };
+                } | {
+                    addKey: {
+                        publicKey: {
+                            ed25519Key: {
+                                data: number[];
+                            };
+                        } | {
+                            secp256k1Key: {
+                                data: number[];
+                            };
+                        };
+                        accessKey: {
+                            nonce: bigint;
+                            permission: {
+                                functionCall: {
+                                    allowance: bigint | null;
+                                    receiverId: string;
+                                    methodNames: string[];
+                                };
+                            } | {
+                                fullAccess: {};
+                            };
+                        };
+                    };
+                } | {
+                    deleteKey: {
+                        publicKey: {
+                            ed25519Key: {
+                                data: number[];
+                            };
+                        } | {
+                            secp256k1Key: {
+                                data: number[];
+                            };
+                        };
+                    };
+                } | {
+                    deleteAccount: {
+                        beneficiaryId: string;
+                    };
+                } | {
+                    deployGlobalContract: {
+                        code: Uint8Array<ArrayBufferLike>;
+                        deployMode: {
+                            CodeHash: {};
+                        } | {
+                            AccountId: {};
+                        };
+                    };
+                } | {
+                    useGlobalContract: {
+                        contractIdentifier: {
+                            CodeHash: number[];
+                        } | {
+                            AccountId: string;
+                        };
+                    };
+                })[];
+                nonce: bigint;
+                maxBlockHeight: bigint;
+                publicKey: {
+                    ed25519Key: {
+                        data: number[];
+                    };
+                } | {
+                    secp256k1Key: {
+                        data: number[];
+                    };
+                };
+            };
+            signature: {
+                ed25519Signature: {
+                    data: number[];
+                };
+            } | {
+                secp256k1Signature: {
+                    data: number[];
+                };
+            };
+        };
+    })[];
+}, string>;
+/**
+ * SignedTransaction schema
+ */
+export declare const SignedTransactionSchema: import("@zorsh/zorsh").Schema<{
+    transaction: {
+        signerId: string;
+        publicKey: {
+            ed25519Key: {
+                data: number[];
+            };
+        } | {
+            secp256k1Key: {
+                data: number[];
+            };
+        };
+        nonce: bigint;
+        receiverId: string;
+        blockHash: number[];
+        actions: ({
+            stake: {
+                stake: bigint;
+                publicKey: {
+                    ed25519Key: {
+                        data: number[];
+                    };
+                } | {
+                    secp256k1Key: {
+                        data: number[];
+                    };
+                };
+            };
+        } | {
+            createAccount: {};
+        } | {
+            deployContract: {
+                code: Uint8Array<ArrayBufferLike>;
+            };
+        } | {
+            functionCall: {
+                methodName: string;
+                args: Uint8Array<ArrayBufferLike>;
+                gas: bigint;
+                deposit: bigint;
+            };
+        } | {
+            transfer: {
+                deposit: bigint;
+            };
+        } | {
+            addKey: {
+                publicKey: {
+                    ed25519Key: {
+                        data: number[];
+                    };
+                } | {
+                    secp256k1Key: {
+                        data: number[];
+                    };
+                };
+                accessKey: {
+                    nonce: bigint;
+                    permission: {
+                        functionCall: {
+                            allowance: bigint | null;
+                            receiverId: string;
+                            methodNames: string[];
+                        };
+                    } | {
+                        fullAccess: {};
+                    };
+                };
+            };
+        } | {
+            deleteKey: {
+                publicKey: {
+                    ed25519Key: {
+                        data: number[];
+                    };
+                } | {
+                    secp256k1Key: {
+                        data: number[];
+                    };
+                };
+            };
+        } | {
+            deleteAccount: {
+                beneficiaryId: string;
+            };
+        } | {
+            deployGlobalContract: {
+                code: Uint8Array<ArrayBufferLike>;
+                deployMode: {
+                    CodeHash: {};
+                } | {
+                    AccountId: {};
+                };
+            };
+        } | {
+            useGlobalContract: {
+                contractIdentifier: {
+                    CodeHash: number[];
+                } | {
+                    AccountId: string;
+                };
+            };
+        } | {
+            signedDelegate: {
+                delegateAction: {
+                    senderId: string;
+                    receiverId: string;
+                    actions: ({
+                        stake: {
+                            stake: bigint;
+                            publicKey: {
+                                ed25519Key: {
+                                    data: number[];
+                                };
+                            } | {
+                                secp256k1Key: {
+                                    data: number[];
+                                };
+                            };
+                        };
+                    } | {
+                        createAccount: {};
+                    } | {
+                        deployContract: {
+                            code: Uint8Array<ArrayBufferLike>;
+                        };
+                    } | {
+                        functionCall: {
+                            methodName: string;
+                            args: Uint8Array<ArrayBufferLike>;
+                            gas: bigint;
+                            deposit: bigint;
+                        };
+                    } | {
+                        transfer: {
+                            deposit: bigint;
+                        };
+                    } | {
+                        addKey: {
+                            publicKey: {
+                                ed25519Key: {
+                                    data: number[];
+                                };
+                            } | {
+                                secp256k1Key: {
+                                    data: number[];
+                                };
+                            };
+                            accessKey: {
+                                nonce: bigint;
+                                permission: {
+                                    functionCall: {
+                                        allowance: bigint | null;
+                                        receiverId: string;
+                                        methodNames: string[];
+                                    };
+                                } | {
+                                    fullAccess: {};
+                                };
+                            };
+                        };
+                    } | {
+                        deleteKey: {
+                            publicKey: {
+                                ed25519Key: {
+                                    data: number[];
+                                };
+                            } | {
+                                secp256k1Key: {
+                                    data: number[];
+                                };
+                            };
+                        };
+                    } | {
+                        deleteAccount: {
+                            beneficiaryId: string;
+                        };
+                    } | {
+                        deployGlobalContract: {
+                            code: Uint8Array<ArrayBufferLike>;
+                            deployMode: {
+                                CodeHash: {};
+                            } | {
+                                AccountId: {};
+                            };
+                        };
+                    } | {
+                        useGlobalContract: {
+                            contractIdentifier: {
+                                CodeHash: number[];
+                            } | {
+                                AccountId: string;
+                            };
+                        };
+                    })[];
+                    nonce: bigint;
+                    maxBlockHeight: bigint;
+                    publicKey: {
+                        ed25519Key: {
+                            data: number[];
+                        };
+                    } | {
+                        secp256k1Key: {
+                            data: number[];
+                        };
+                    };
+                };
+                signature: {
+                    ed25519Signature: {
+                        data: number[];
+                    };
+                } | {
+                    secp256k1Signature: {
+                        data: number[];
+                    };
+                };
+            };
+        })[];
+    };
+    signature: {
+        ed25519Signature: {
+            data: number[];
+        };
+    } | {
+        secp256k1Signature: {
+            data: number[];
+        };
+    };
+}, string>;
+/**
+ * Convert our PublicKey type to zorsh-compatible format.
+ *
+ * @internal Exported for use in action helpers only.
+ */
+export declare function publicKeyToZorsh(pk: Ed25519PublicKey): {
+    ed25519Key: {
+        data: number[];
+    };
+};
+export declare function publicKeyToZorsh(pk: Secp256k1PublicKey): {
+    secp256k1Key: {
+        data: number[];
+    };
+};
+export declare function publicKeyToZorsh(pk: PublicKey): {
+    ed25519Key: {
+        data: number[];
+    };
+} | {
+    secp256k1Key: {
+        data: number[];
+    };
+};
+/**
+ * Convert our Signature type to zorsh-compatible format.
+ *
+ * @internal Exported for use in action helpers only.
+ */
+export declare function signatureToZorsh(sig: Ed25519Signature): {
+    ed25519Signature: {
+        data: number[];
+    };
+};
+export declare function signatureToZorsh(sig: Secp256k1Signature): {
+    secp256k1Signature: {
+        data: number[];
+    };
+};
+export declare function signatureToZorsh(sig: Signature): {
+    ed25519Signature: {
+        data: number[];
+    };
+} | {
+    secp256k1Signature: {
+        data: number[];
+    };
+};
+/**
+ * Serialize a transaction to bytes
+ */
+export declare function serializeTransaction(tx: Transaction): Uint8Array;
+/**
+ * Serialize a signed transaction to bytes
+ */
+export declare function serializeSignedTransaction(signedTx: SignedTransaction): Uint8Array;
+/**
+ * Serialize a delegate action for signing
+ *
+ * Per NEP-461, this prepends a u32 prefix (2^30 + 366) before the delegate action,
+ * ensuring signed delegate actions are never identical to signed transactions.
+ *
+ * Use this when you need to sign a DelegateAction to create a SignedDelegate.
+ *
+ * @param delegateAction - The delegate action to serialize
+ * @returns Uint8Array - The prefixed and serialized delegate action
+ *
+ * @example
+ * ```typescript
+ * const encoded = serializeDelegateAction(delegateAction)
+ * const hash = await crypto.subtle.digest("SHA-256", encoded)
+ * const signature = await signer.sign(new Uint8Array(hash))
+ * ```
+ */
+export declare function serializeDelegateAction(delegateAction: DelegateAction): Uint8Array;
+/**
+ * Serialize a signed delegate action for inclusion in a transaction
+ *
+ * This serializes a SignedDelegate (DelegateAction + signature) for use as
+ * an action within a meta transaction.
+ *
+ * Note: This does NOT include the NEP-461 prefix (only needed when signing).
+ *
+ * @param signedDelegate - The signed delegate action to serialize
+ * @returns Uint8Array - The serialized signed delegate action
+ *
+ * @example
+ * ```typescript
+ * const encoded = serializeSignedDelegate(signedDelegate)
+ * // Use encoded bytes in transaction action
+ * ```
+ */
+export declare function serializeSignedDelegate(signedDelegate: SignedDelegate): Uint8Array;
+export {};
+//# sourceMappingURL=schema.d.ts.map