@layerzerolabs/protocol-stellar-v2 0.2.12 → 0.2.15

package/sdk/test/oft.test.ts

@@ -197,7 +197,6 @@ describe('OFT E2E Testing with SAC', async () => {
                 { contract: CONTRACT_ADDRESSES.executorHelper, fn_name: 'native_drop_and_execute' },
                 { contract: CONTRACT_ADDRESSES.executorHelper, fn_name: 'execute' },
                 { contract: CONTRACT_ADDRESSES.executorHelper, fn_name: 'compose' },
-                { contract: CONTRACT_ADDRESSES.executorHelper, fn_name: 'native_drop' },
             ];
 
             executorClient = await deployContract<ExecutorClient>(
@@ -286,7 +285,7 @@ describe('OFT E2E Testing with SAC', async () => {
                     endpoint: CONTRACT_ADDRESSES.endpointV2,
                     delegate: DEFAULT_DEPLOYER.publicKey(),
                     shared_decimals: SHARED_DECIMALS,
-                    is_lock_unlock: true, // Lock/Unlock mode
+                    mode: { tag: 'LockUnlock' }, // Lock/Unlock mode
                 },
                 DEFAULT_DEPLOYER,
             );
@@ -295,8 +294,8 @@ describe('OFT E2E Testing with SAC', async () => {
             console.log('✅ Lock/Unlock OFT deployed:', CONTRACT_ADDRESSES.lockUnlockOft);
 
             // Verify it's in lock/unlock mode
-            const { result: isLockUnlock } = await lockUnlockOftClient.is_lock_unlock();
-            expect(isLockUnlock).toBe(true);
+            const { result: mode } = await lockUnlockOftClient.mode();
+            expect(mode).toEqual({ tag: 'LockUnlock' });
         });
 
         it('Deploy Mint/Burn OFT', async () => {
@@ -309,7 +308,7 @@ describe('OFT E2E Testing with SAC', async () => {
                     endpoint: CONTRACT_ADDRESSES.endpointV2,
                     delegate: DEFAULT_DEPLOYER.publicKey(),
                     shared_decimals: SHARED_DECIMALS,
-                    is_lock_unlock: false, // Mint/Burn mode
+                    mode: { tag: 'MintBurn' }, // Mint/Burn mode
                 },
                 DEFAULT_DEPLOYER,
             );
@@ -318,8 +317,8 @@ describe('OFT E2E Testing with SAC', async () => {
             console.log('✅ Mint/Burn OFT deployed:', CONTRACT_ADDRESSES.mintBurnOft);
 
             // Verify it's in mint/burn mode
-            const { result: isLockUnlock } = await mintBurnOftClient.is_lock_unlock();
-            expect(isLockUnlock).toBe(false);
+            const { result: mode } = await mintBurnOftClient.mode();
+            expect(mode).toEqual({ tag: 'MintBurn' });
         });
 
         it('Verify all contracts deployed', () => {
@@ -594,15 +593,9 @@ describe('OFT E2E Testing with SAC', async () => {
                 src_eid: EID,
             };
 
-            // Use native_drop_and_execute with empty native_drop_params
-            const assembledTx = await executorHelperClient.native_drop_and_execute({
+            const assembledTx = await executorHelperClient.execute({
                 executor: CONTRACT_ADDRESSES.executor,
-                admin: EXECUTOR_ADMIN.publicKey(),
-                origin,
-                dst_eid: EID,
-                oapp: CONTRACT_ADDRESSES.mintBurnOft,
-                native_drop_params: [],
-                execute_params: {
+                params: {
                     extra_data: Buffer.from([]),
                     gas_limit: 0n,
                     guid,
@@ -611,6 +604,7 @@ describe('OFT E2E Testing with SAC', async () => {
                     receiver: CONTRACT_ADDRESSES.mintBurnOft,
                     value: 0n,
                 },
+                value_payer: EXECUTOR_ADMIN.publicKey(),
             });
 
             // Sign the Executor's auth entries
@@ -770,15 +764,9 @@ describe('OFT E2E Testing with SAC', async () => {
                 src_eid: EID,
             };
 
-            // Use native_drop_and_execute with empty native_drop_params
-            const assembledTx = await executorHelperClient.native_drop_and_execute({
+            const assembledTx = await executorHelperClient.execute({
                 executor: CONTRACT_ADDRESSES.executor,
-                admin: EXECUTOR_ADMIN.publicKey(),
-                origin,
-                dst_eid: EID,
-                oapp: CONTRACT_ADDRESSES.lockUnlockOft,
-                native_drop_params: [],
-                execute_params: {
+                params: {
                     extra_data: Buffer.from([]),
                     gas_limit: 0n,
                     guid,
@@ -787,6 +775,7 @@ describe('OFT E2E Testing with SAC', async () => {
                     receiver: CONTRACT_ADDRESSES.lockUnlockOft,
                     value: 0n,
                 },
+                value_payer: EXECUTOR_ADMIN.publicKey(),
             });
 
             // Sign the Executor's auth entries

package/sdk/test/suites/testUpgradeable.ts

@@ -0,0 +1,169 @@
+import type { Option, u32 } from '@stellar/stellar-sdk/contract';
+import {
+    AssembledTransaction,
+    Client as ContractClient,
+    ClientOptions as ContractClientOptions,
+    MethodOptions,
+    Spec as ContractSpec,
+} from '@stellar/stellar-sdk/contract';
+import { Buffer } from 'buffer';
+export * from '@stellar/stellar-sdk';
+export * as contract from '@stellar/stellar-sdk/contract';
+export * as rpc from '@stellar/stellar-sdk/rpc';
+
+if (typeof window !== 'undefined') {
+    //@ts-ignore Buffer exists
+    window.Buffer = window.Buffer || Buffer;
+}
+
+export const BufferReaderError = {
+    1000: { message: 'InvalidLength' },
+    1001: { message: 'InvalidAddressPayload' },
+};
+
+export const BufferWriterError = {
+    1100: { message: 'InvalidAddressPayload' },
+};
+
+export const TtlError = {
+    1200: { message: 'InvalidTtlConfig' },
+    1201: { message: 'TtlConfigFrozen' },
+    1202: { message: 'TtlConfigAlreadyFrozen' },
+};
+
+export const OwnableError = {
+    1300: { message: 'OwnerAlreadySet' },
+    1301: { message: 'OwnerNotSet' },
+};
+
+export const BytesExtError = {
+    1400: { message: 'LengthMismatch' },
+};
+
+export const UpgradeableError = {
+    1500: { message: 'MigrationNotAllowed' },
+};
+
+export type DefaultOwnableStorage = { tag: 'Owner'; values: void };
+
+/**
+ * A pair of TTL values: threshold (when to trigger extension) and extend_to (target TTL).
+ */
+export interface TtlConfig {
+    /**
+     * Target TTL after extension (in ledgers).
+     */
+    extend_to: u32;
+    /**
+     * TTL threshold that triggers extension (in ledgers).
+     */
+    threshold: u32;
+}
+
+export type TtlConfigStorage =
+    | { tag: 'Frozen'; values: void }
+    | { tag: 'Instance'; values: void }
+    | { tag: 'Persistent'; values: void };
+
+export type UpgradeableStorage = { tag: 'Migrating'; values: void };
+
+export interface Client {
+    /**
+     * Construct and simulate a owner transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    owner: (options?: MethodOptions) => Promise<AssembledTransaction<Option<string>>>;
+
+    /**
+     * Construct and simulate a transfer_ownership transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    transfer_ownership: (
+        { new_owner }: { new_owner: string },
+        options?: MethodOptions,
+    ) => Promise<AssembledTransaction<null>>;
+
+    /**
+     * Construct and simulate a renounce_ownership transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    renounce_ownership: (options?: MethodOptions) => Promise<AssembledTransaction<null>>;
+
+    /**
+     * Construct and simulate a upgrade transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    upgrade: (
+        { new_wasm_hash }: { new_wasm_hash: Buffer },
+        options?: MethodOptions,
+    ) => Promise<AssembledTransaction<null>>;
+
+    /**
+     * Construct and simulate a migrate transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    migrate: (
+        { migration_data }: { migration_data: MigrationData },
+        options?: MethodOptions,
+    ) => Promise<AssembledTransaction<null>>;
+
+    /**
+     * Construct and simulate a counter transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    counter: (options?: MethodOptions) => Promise<AssembledTransaction<u32>>;
+
+    /**
+     * Construct and simulate a counter2 transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    counter2: (options?: MethodOptions) => Promise<AssembledTransaction<u32>>;
+}
+export class Client extends ContractClient {
+    static async deploy<T = Client>(
+        /** Options for initializing a Client as well as for calling a method, with extras specific to deploying. */
+        options: MethodOptions &
+            Omit<ContractClientOptions, 'contractId'> & {
+                /** The hash of the Wasm blob, which must already be installed on-chain. */
+                wasmHash: Buffer | string;
+                /** Salt used to generate the contract's ID. Passed through to {@link Operation.createCustomContract}. Default: random. */
+                salt?: Buffer | Uint8Array;
+                /** The format used to decode `wasmHash`, if it's provided as a string. */
+                format?: 'hex' | 'base64';
+            },
+    ): Promise<AssembledTransaction<T>> {
+        return ContractClient.deploy(null, options);
+    }
+    constructor(public readonly options: ContractClientOptions) {
+        super(
+            new ContractSpec([
+                'AAAAAAAAAAAAAAAFb3duZXIAAAAAAAAAAAAAAQAAA+gAAAAT',
+                'AAAAAAAAAAAAAAASdHJhbnNmZXJfb3duZXJzaGlwAAAAAAABAAAAAAAAAAluZXdfb3duZXIAAAAAAAATAAAAAA==',
+                'AAAAAAAAAAAAAAAScmVub3VuY2Vfb3duZXJzaGlwAAAAAAAAAAAAAA==',
+                'AAAAAAAAAAAAAAAHdXBncmFkZQAAAAABAAAAAAAAAA1uZXdfd2FzbV9oYXNoAAAAAAAD7gAAACAAAAAA',
+                'AAAAAAAAAAAAAAAHbWlncmF0ZQAAAAABAAAAAAAAAA5taWdyYXRpb25fZGF0YQAAAAAH0AAAAA1NaWdyYXRpb25EYXRhAAAAAAAAAA==',
+                'AAAAAAAAAAAAAAAHY291bnRlcgAAAAAAAAAAAQAAAAQ=',
+                'AAAAAAAAAAAAAAAIY291bnRlcjIAAAAAAAAAAQAAAAQ=',
+                'AAAABAAAAAAAAAAAAAAAEUJ1ZmZlclJlYWRlckVycm9yAAAAAAAAAgAAAAAAAAANSW52YWxpZExlbmd0aAAAAAAAA+gAAAAAAAAAFUludmFsaWRBZGRyZXNzUGF5bG9hZAAAAAAAA+k=',
+                'AAAABAAAAAAAAAAAAAAAEUJ1ZmZlcldyaXRlckVycm9yAAAAAAAAAQAAAAAAAAAVSW52YWxpZEFkZHJlc3NQYXlsb2FkAAAAAAAETA==',
+                'AAAABAAAAAAAAAAAAAAACFR0bEVycm9yAAAAAwAAAAAAAAAQSW52YWxpZFR0bENvbmZpZwAABLAAAAAAAAAAD1R0bENvbmZpZ0Zyb3plbgAAAASxAAAAAAAAABZUdGxDb25maWdBbHJlYWR5RnJvemVuAAAAAASy',
+                'AAAABAAAAAAAAAAAAAAADE93bmFibGVFcnJvcgAAAAIAAAAAAAAAD093bmVyQWxyZWFkeVNldAAAAAUUAAAAAAAAAAtPd25lck5vdFNldAAAAAUV',
+                'AAAABAAAAAAAAAAAAAAADUJ5dGVzRXh0RXJyb3IAAAAAAAABAAAAAAAAAA5MZW5ndGhNaXNtYXRjaAAAAAAFeA==',
+                'AAAABAAAAAAAAAAAAAAAEFVwZ3JhZGVhYmxlRXJyb3IAAAABAAAAAAAAABNNaWdyYXRpb25Ob3RBbGxvd2VkAAAABdw=',
+                'AAAABQAAACxFdmVudCBlbWl0dGVkIHdoZW4gb3duZXJzaGlwIGlzIHRyYW5zZmVycmVkLgAAAAAAAAAUT3duZXJzaGlwVHJhbnNmZXJyZWQAAAABAAAAFE93bmVyc2hpcFRyYW5zZmVycmVkAAAAAgAAAAAAAAAJb2xkX293bmVyAAAAAAAAEwAAAAAAAAAAAAAACW5ld19vd25lcgAAAAAAABMAAAAAAAAAAg==',
+                'AAAABQAAACpFdmVudCBlbWl0dGVkIHdoZW4gb3duZXJzaGlwIGlzIHJlbm91bmNlZC4AAAAAAAAAAAAST3duZXJzaGlwUmVub3VuY2VkAAAAAAABAAAAEk93bmVyc2hpcFJlbm91bmNlZAAAAAAAAQAAAAAAAAAJb2xkX293bmVyAAAAAAAAEwAAAAAAAAAC',
+                'AAAAAgAAAAAAAAAAAAAAFURlZmF1bHRPd25hYmxlU3RvcmFnZQAAAAAAAAEAAAAAAAAAAAAAAAVPd25lcgAAAA==',
+                'AAAAAQAAAFdBIHBhaXIgb2YgVFRMIHZhbHVlczogdGhyZXNob2xkICh3aGVuIHRvIHRyaWdnZXIgZXh0ZW5zaW9uKSBhbmQgZXh0ZW5kX3RvICh0YXJnZXQgVFRMKS4AAAAAAAAAAAlUdGxDb25maWcAAAAAAAACAAAAKFRhcmdldCBUVEwgYWZ0ZXIgZXh0ZW5zaW9uIChpbiBsZWRnZXJzKS4AAAAJZXh0ZW5kX3RvAAAAAAAABAAAADNUVEwgdGhyZXNob2xkIHRoYXQgdHJpZ2dlcnMgZXh0ZW5zaW9uIChpbiBsZWRnZXJzKS4AAAAACXRocmVzaG9sZAAAAAAAAAQ=',
+                'AAAAAgAAAAAAAAAAAAAAEFR0bENvbmZpZ1N0b3JhZ2UAAAADAAAAAAAAAAAAAAAGRnJvemVuAAAAAAAAAAAAAAAAAAhJbnN0YW5jZQAAAAAAAAAAAAAAClBlcnNpc3RlbnQAAA==',
+                'AAAABQAAACdFdmVudCBlbWl0dGVkIHdoZW4gVFRMIGNvbmZpZ3MgYXJlIHNldC4AAAAAAAAAAA1UdGxDb25maWdzU2V0AAAAAAAAAQAAAA1UdGxDb25maWdzU2V0AAAAAAAAAgAAAAAAAAAIaW5zdGFuY2UAAAPoAAAH0AAAAAlUdGxDb25maWcAAAAAAAAAAAAAAAAAAApwZXJzaXN0ZW50AAAAAAPoAAAH0AAAAAlUdGxDb25maWcAAAAAAAAAAAAAAg==',
+                'AAAABQAAACpFdmVudCBlbWl0dGVkIHdoZW4gVFRMIGNvbmZpZ3MgYXJlIGZyb3plbi4AAAAAAAAAAAAQVHRsQ29uZmlnc0Zyb3plbgAAAAEAAAAQVHRsQ29uZmlnc0Zyb3plbgAAAAAAAAAC',
+                'AAAAAgAAAAAAAAAAAAAAElVwZ3JhZGVhYmxlU3RvcmFnZQAAAAAAAQAAAAAAAAAAAAAACU1pZ3JhdGluZwAAAA==',
+            ]),
+            options,
+        );
+    }
+    public readonly fromJSON = {
+        owner: this.txFromJSON<Option<string>>,
+        transfer_ownership: this.txFromJSON<null>,
+        renounce_ownership: this.txFromJSON<null>,
+        upgrade: this.txFromJSON<null>,
+        migrate: this.txFromJSON<null>,
+        counter: this.txFromJSON<u32>,
+        counter2: this.txFromJSON<u32>,
+    };
+}
+
+export type MigrationData = void;

package/sdk/test/upgrader.test.ts

@@ -0,0 +1,309 @@
+import { Address, authorizeEntry, Keypair, xdr } from '@stellar/stellar-sdk';
+import { assembleTransaction } from '@stellar/stellar-sdk/rpc';
+import * as rpc from '@stellar/stellar-sdk/rpc';
+import { readFileSync } from 'fs';
+import path from 'path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+
+import { getFullyQualifiedRepoRootPath } from '@layerzerolabs/common-node-utils';
+
+import { Client as UpgraderClient } from '../src/generated/upgrader';
+import { DEFAULT_DEPLOYER, NETWORK_PASSPHRASE, RPC_URL } from './suites/constants';
+import { deployContract, uploadWasm } from './suites/deploy';
+import { startStellarLocalnet, stopStellarLocalnet } from './suites/localnet';
+import { Client as TestUpgradeableContractClient } from './suites/testUpgradeable';
+
+let upgraderClient: UpgraderClient;
+let testContractClient: TestUpgradeableContractClient;
+let testContractAddress: string;
+
+// Test data paths
+let TEST_CONTRACT_V1_WASM_PATH: string;
+let TEST_CONTRACT_V2_WASM_PATH: string;
+
+describe('Upgrader Contract Testing', async () => {
+    const repoRoot = await getFullyQualifiedRepoRootPath();
+    const upgraderWasmDir = path.join(
+        repoRoot,
+        'contracts',
+        'protocol',
+        'stellar',
+        'target',
+        'wasm32v1-none',
+        'release',
+    );
+    const testDataDir = path.join(
+        repoRoot,
+        'contracts',
+        'protocol',
+        'stellar',
+        'contracts',
+        'upgrader',
+        'src',
+        'tests',
+        'test_data',
+    );
+
+    const UPGRADER_WASM_PATH = path.join(upgraderWasmDir, 'upgrader.wasm');
+    TEST_CONTRACT_V1_WASM_PATH = path.join(testDataDir, 'test_upgradeable_contract1.wasm');
+    TEST_CONTRACT_V2_WASM_PATH = path.join(testDataDir, 'test_upgradeable_contract2.wasm');
+
+    beforeAll(async () => {
+        await startStellarLocalnet();
+    }, 120000); // 2 minute timeout for setup
+
+    afterAll(async () => {
+        await stopStellarLocalnet();
+    });
+
+    describe('Contract Deployments', () => {
+        it('Deploy Upgrader Contract', async () => {
+            // Deploy upgrader contract using the helper (no constructor args needed)
+            upgraderClient = await deployContract<UpgraderClient>(
+                UpgraderClient,
+                UPGRADER_WASM_PATH,
+                undefined,
+                DEFAULT_DEPLOYER,
+            );
+
+            console.log('✅ Upgrader deployed at:', upgraderClient.options.contractId);
+            expect(upgraderClient.options.contractId).toBeDefined();
+        });
+
+        it('Deploy Test Upgradeable Contract V1', async () => {
+            console.log('📖 Reading Test Contract V1 WASM file from:', TEST_CONTRACT_V1_WASM_PATH);
+
+            const server = new rpc.Server(RPC_URL, { allowHttp: true });
+
+            // Read and upload WASM
+            const wasmBuffer = readFileSync(TEST_CONTRACT_V1_WASM_PATH);
+            const wasmHash = await uploadWasm(wasmBuffer, DEFAULT_DEPLOYER, server);
+            console.log('✅ Test Contract V1 WASM uploaded, hash:', wasmHash);
+
+            // Deploy test contract V1 with owner as constructor arg
+            console.log('🚀 Deploying Test Contract V1...');
+            const { TransactionBuilder, Operation, StrKey, Address } = await import(
+                '@stellar/stellar-sdk'
+            );
+
+            const account = await server.getAccount(DEFAULT_DEPLOYER.publicKey());
+            const salt = Buffer.from(Keypair.random().rawPublicKey());
+
+            // Create contract from WASM with constructor args
+            const wasmHashBuffer = Buffer.from(wasmHash, 'hex');
+
+            // Encode constructor args: owner (Address)
+            const ownerScVal = Address.fromString(DEFAULT_DEPLOYER.publicKey()).toScVal();
+
+            const createContractTx = new TransactionBuilder(account, {
+                fee: '100000',
+                networkPassphrase: NETWORK_PASSPHRASE,
+            })
+                .addOperation(
+                    Operation.createCustomContract({
+                        address: Address.fromString(DEFAULT_DEPLOYER.publicKey()),
+                        wasmHash: wasmHashBuffer,
+                        salt: salt,
+                        constructorArgs: [ownerScVal],
+                    }),
+                )
+                .setTimeout(30)
+                .build();
+
+            // Simulate to get the contract ID
+            const simulated = await server.simulateTransaction(createContractTx);
+            const preparedTx = rpc.assembleTransaction(createContractTx, simulated).build();
+            preparedTx.sign(DEFAULT_DEPLOYER);
+
+            const sendResult = await server.sendTransaction(preparedTx);
+            if (sendResult.status !== 'PENDING') {
+                throw new Error(`Transaction failed: ${JSON.stringify(sendResult)}`);
+            }
+
+            const txResult = await server.pollTransaction(sendResult.hash);
+            if (txResult.status !== 'SUCCESS') {
+                throw new Error(`Transaction not successful: ${JSON.stringify(txResult)}`);
+            }
+
+            // Extract contract address from the transaction result
+            const returnValue = txResult.returnValue;
+            if (!returnValue) {
+                throw new Error('No return value from contract creation');
+            }
+
+            // The return value is an Address ScVal, decode it
+            const contractIdHash = returnValue.address().contractId();
+            testContractAddress = StrKey.encodeContract(
+                Buffer.from(contractIdHash as unknown as Uint8Array),
+            );
+
+            // Create client for the deployed contract
+            testContractClient = new TestUpgradeableContractClient({
+                contractId: testContractAddress,
+                publicKey: DEFAULT_DEPLOYER.publicKey(),
+                signTransaction: async (tx: string) => {
+                    const transaction = TransactionBuilder.fromXDR(tx, NETWORK_PASSPHRASE);
+                    transaction.sign(DEFAULT_DEPLOYER);
+                    return {
+                        signedTxXdr: transaction.toXDR(),
+                        signerAddress: DEFAULT_DEPLOYER.publicKey(),
+                    };
+                },
+                rpcUrl: RPC_URL,
+                networkPassphrase: NETWORK_PASSPHRASE,
+                allowHttp: true,
+            });
+
+            console.log('✅ Test Contract V1 deployed at:', testContractAddress);
+            expect(testContractAddress).toBeDefined();
+        });
+
+        it('Verify Test Contract V1 Counter', async () => {
+            // Call counter() on V1 contract, should return 1
+            const { result } = await testContractClient.counter();
+            console.log('✅ Test Contract V1 counter value:', result);
+            expect(result).toBe(1);
+        });
+    });
+
+    describe('Upgrade Workflow', () => {
+        let newWasmHash: string;
+
+        it('Upload Test Contract V2 WASM', async () => {
+            console.log('📖 Reading Test Contract V2 WASM file from:', TEST_CONTRACT_V2_WASM_PATH);
+
+            const server = new rpc.Server(RPC_URL, { allowHttp: true });
+
+            // Read and upload WASM for V2
+            const wasmBuffer = readFileSync(TEST_CONTRACT_V2_WASM_PATH);
+            newWasmHash = await uploadWasm(wasmBuffer, DEFAULT_DEPLOYER, server);
+            console.log('✅ Test Contract V2 WASM uploaded, hash:', newWasmHash);
+            expect(newWasmHash).toBeDefined();
+        });
+
+        it('Test Upgrader Contract Can Be Called', async () => {
+            console.log('🔄 Testing upgrader contract call...');
+            console.log('   Contract address:', testContractAddress);
+            console.log('   New WASM hash:', newWasmHash);
+
+            // NOTE: Using Option 2 - Hybrid approach with generated client
+            // Build with generated client, then manually simulate with authMode, then inject back
+
+            const voidScVal = xdr.ScVal.scvVoid();
+            const server = new rpc.Server(RPC_URL, { allowHttp: true });
+
+            // 1. Build transaction using generated client (don't auto-simulate)
+            const assembledTx = await upgraderClient.upgrade_and_migrate(
+                {
+                    contract_address: testContractAddress,
+                    wasm_hash: Buffer.from(newWasmHash, 'hex'),
+                    migration_data: [voidScVal],
+                },
+                {
+                    simulate: false, // Don't simulate yet
+                },
+            );
+
+            console.log('✅ Transaction built with generated client');
+
+            // Build the transaction from the raw builder
+            const rawTx = assembledTx.raw!.build();
+
+            console.log('✅ Raw transaction built');
+
+            // 2. Manually simulate with record_allow_nonroot authMode
+            const sim = await server.simulateTransaction(
+                rawTx,
+                undefined, // addlResources
+                'record_allow_nonroot', // ← This enables non-root auth recording!
+            );
+
+            if (rpc.Api.isSimulationError(sim)) {
+                throw new Error(`Simulation failed: ${JSON.stringify(sim)}`);
+            }
+
+            console.log('✅ Transaction simulated with record_allow_nonroot');
+            console.log('   Auth entries returned:', sim.result?.auth?.length ?? 0);
+
+            // 3. Sign auth entries manually (high-level API doesn't see them after injection)
+            const latestLedger = sim.latestLedger;
+            const validUntilLedger = latestLedger + 100;
+
+            if (sim.result && sim.result.auth) {
+                sim.result.auth = await Promise.all(
+                    sim.result.auth.map(async (entry) => {
+                        // Source account credentials are already signed by tx envelope
+                        if (
+                            entry.credentials().switch() ===
+                            xdr.SorobanCredentialsType.sorobanCredentialsSourceAccount()
+                        ) {
+                            console.log('   Skipping source account auth entry');
+                            return entry;
+                        }
+
+                        // Address credentials need explicit signature
+                        const addr = Address.fromScAddress(
+                            entry.credentials().address().address(),
+                        ).toString();
+
+                        console.log('   Signing auth entry for address:', addr);
+
+                        if (addr === DEFAULT_DEPLOYER.publicKey()) {
+                            // Sign with owner's keypair
+                            return authorizeEntry(
+                                entry,
+                                DEFAULT_DEPLOYER,
+                                validUntilLedger,
+                                NETWORK_PASSPHRASE,
+                            );
+                        }
+
+                        throw new Error(`Unexpected auth signer needed: ${addr}`);
+                    }),
+                );
+                console.log('✅ Auth entries signed');
+            }
+
+            // 4. Assemble final transaction with signed auth entries
+            const finalTxBuilder = assembleTransaction(rawTx, sim);
+            const finalTx = finalTxBuilder.build();
+
+            console.log('✅ Final transaction assembled');
+
+            // 5. Sign the transaction envelope
+            finalTx.sign(DEFAULT_DEPLOYER);
+
+            console.log('✅ Transaction envelope signed');
+
+            // 6. Send and poll
+            const sentResult = await server.sendTransaction(finalTx);
+
+            if (sentResult.status !== 'PENDING') {
+                throw new Error(`Transaction failed to send: ${JSON.stringify(sentResult)}`);
+            }
+
+            console.log('✅ Transaction sent, hash:', sentResult.hash);
+
+            const txResult = await server.pollTransaction(sentResult.hash);
+
+            console.log('✅ Upgrade transaction completed');
+            console.log('   Transaction status:', txResult.status);
+
+            expect(txResult.status).toBe('SUCCESS');
+        });
+
+        it('Verify Test Contract V2 Counter2 After Upgrade', async () => {
+            // After upgrade, the contract should have counter2() function that returns 2
+            const { result } = await testContractClient.counter2();
+            console.log('✅ Test Contract V2 counter2 value:', result);
+            expect(result).toBe(2);
+        });
+
+        it('Verify Test Contract V1 Counter Still Works After Upgrade', async () => {
+            // The original counter() should still be accessible and return 1
+            const { result } = await testContractClient.counter();
+            console.log('✅ Test Contract V2 counter value (from V1):', result);
+            expect(result).toBe(1);
+        });
+    });
+});

package/tools/ts-bindings-gen/src/main.rs

@@ -31,6 +31,8 @@ export * from '@stellar/stellar-sdk'
 export * as contract from '@stellar/stellar-sdk/contract'
 export * as rpc from '@stellar/stellar-sdk/rpc'
 
+export type MigrationData = void;
+
 
 "#
 }
@@ -45,13 +47,21 @@ fn main() -> Result<()> {
     // Configuration for each contract
     // Format: (wasm_filename, ts_filename)
     let contracts = vec![
+        // Protocol contracts
         ("endpoint_v2", "endpoint.ts"),
         ("simple_message_lib", "sml.ts"),
         ("blocked_message_lib", "bml.ts"),
         ("uln302", "uln302.ts"),
-        ("counter", "counter.ts"),
+        ("upgrader", "upgrader.ts"),
+        // Worker contracts
+        ("dvn", "dvn.ts"),
+        ("dvn_fee_lib", "dvn_fee_lib.ts"),
         ("executor", "executor.ts"),
+        ("executor_fee_lib", "executor_fee_lib.ts"),
         ("executor_helper", "executor_helper.ts"),
+        ("price_feed", "price_feed.ts"),
+        // OApp contracts
+        ("counter", "counter.ts"),
         ("oft_std", "oft_std.ts"),
         // Add more contracts here as needed:
     ];