Fix zorsh serialization with BigInt conversion and option handling

- Add ensureBigInt() helper to convert numbers to BigInt for u128/u64 fields
- Convert undefined to null for zorsh option types
- Preserve prototype chain when converting class instances
- Update all encoding functions to use ensureBigInt()
- Fix tests to use encodeTransaction() and handle Uint8Array correctly
- Remove unused Test class from tests

Author: claude

src/transactions/schema.ts

@@ -9,6 +9,39 @@ import type { DelegateAction } from './delegate.js';
 import { DelegateActionPrefix } from './prefix.js';
 import type { Signature } from './signature.js';
 
+/**
+ * Recursively converts numeric values to BigInt for u128/u64 fields in objects
+ * and undefined to null for option types to ensure compatibility with zorsh serialization
+ */
+function ensureBigInt(obj: any): any {
+    if (obj === null || obj === undefined) return obj;
+    if (typeof obj === 'number') return BigInt(obj);
+    if (typeof obj === 'bigint') return obj;
+    if (obj instanceof Uint8Array) return obj;
+    if (Array.isArray(obj)) return obj.map(ensureBigInt);
+    if (typeof obj === 'object') {
+        // Preserve the prototype chain for class instances
+        const result: any = Object.create(Object.getPrototypeOf(obj));
+        for (const [key, value] of Object.entries(obj)) {
+            // Convert numeric fields that should be BigInt
+            if (['deposit', 'stake', 'gas', 'nonce', 'allowance', 'maxBlockHeight'].includes(key)) {
+                if (value === null || value === undefined) {
+                    // zorsh's option type requires null, not undefined
+                    result[key] = value === undefined ? null : value;
+                } else if (typeof value === 'number' || typeof value === 'bigint') {
+                    result[key] = BigInt(value);
+                } else {
+                    result[key] = value;
+                }
+            } else {
+                result[key] = ensureBigInt(value);
+            }
+        }
+        return result;
+    }
+    return obj;
+}
+
 /**
  * Borsh-encode a delegate action for inclusion as an action within a meta transaction
  * NB per NEP-461 this requires a Borsh-serialized prefix specific to delegate actions, ensuring
@@ -18,7 +51,7 @@ import type { Signature } from './signature.js';
 export function encodeDelegateAction(delegateAction: DelegateAction) {
     return new Uint8Array([
         ...SCHEMA.DelegateActionPrefix.serialize(new DelegateActionPrefix()),
-        ...SCHEMA.DelegateAction.serialize(delegateAction as any),
+        ...SCHEMA.DelegateAction.serialize(ensureBigInt(delegateAction)),
     ]);
 }
 
@@ -27,7 +60,7 @@ export function encodeDelegateAction(delegateAction: DelegateAction) {
  * @param signedDelegate Signed delegate to be executed in a meta transaction
  */
 export function encodeSignedDelegate(signedDelegate: SignedDelegate) {
-    return SCHEMA.SignedDelegate.serialize(signedDelegate as any);
+    return SCHEMA.SignedDelegate.serialize(ensureBigInt(signedDelegate));
 }
 
 /**
@@ -37,7 +70,7 @@ export function encodeSignedDelegate(signedDelegate: SignedDelegate) {
  */
 export function encodeTransaction(transaction: Transaction | SignedTransaction) {
     const schema = 'signature' in transaction ? SCHEMA.SignedTransaction : SCHEMA.Transaction;
-    return schema.serialize(transaction as any);
+    return schema.serialize(ensureBigInt(transaction));
 }
 
 /**

test/transactions/serialize.test.ts

@@ -31,14 +31,6 @@ const {
     useGlobalContract
 } = actionCreators;
 
-class Test {
-    constructor(props: any) {
-        for (const [k, v] of Object.entries(props || {})) {
-            this[k] = v;
-        }
-    }
-}
-
 test('serialize object', async () => {
     const value = { x: 255, y: 20, z: '123', q: Uint8Array.from([1, 2, 3]) };
     const schema = b.struct({ x: b.u8(), y: b.u16(), z: b.string(), q: b.bytes() });
@@ -75,7 +67,7 @@ test('serialize multi-action tx', async () => {
     const blockHash = baseDecode('244ZQ9cgj3CQ6bWBdytfrJMuMQ1jdXLFGnr4HhvtCTnM');
     const transaction = createTransaction('test.near', publicKey, '123', 1n, actions, blockHash);
     // expect(baseEncode(hash)).toEqual('Fo3MJ9XzKjnKuDuQKhDAC6fra5H2UWawRejFSEpPNk3Y');
-    const serialized = Buffer.from(SCHEMA.Transaction.serialize(transaction as any));
+    const serialized = Buffer.from(encodeTransaction(transaction));
     expect(serialized.toString('hex')).toEqual('09000000746573742e6e656172000f56a5f028dfc089ec7c39c1183b321b4d8f89ba5bec9e1762803cc2491f6ef80100000000000000030000003132330fa473fd26901df296be6adc4cc4df34d040efa2435224b6986910e630c2fef608000000000103000000010203020300000071717103000000010203e80300000000000040420f00000000000000000000000000037b0000000000000000000000000000000440420f00000000000000000000000000000f56a5f028dfc089ec7c39c1183b321b4d8f89ba5bec9e1762803cc2491f6ef805000f56a5f028dfc089ec7c39c1183b321b4d8f89ba5bec9e1762803cc2491f6ef800000000000000000000030000007a7a7a010000000300000077777706000f56a5f028dfc089ec7c39c1183b321b4d8f89ba5bec9e1762803cc2491f6ef80703000000313233');
 });
 
@@ -231,7 +223,7 @@ describe('Global Contract Actions Serialization', () => {
         const deserializedAction = deserializedTx.actions[0].useGlobalContract;
         expect(deserializedAction).toBeDefined();
         if (deserializedAction) { // Type guard
-            expect(deserializedAction.contractIdentifier).toEqual({ CodeHash: Array.from(sampleCodeHash) });
+            expect(deserializedAction.contractIdentifier.CodeHash).toEqual(sampleCodeHash);
         }
     });