@layerzerolabs/protocol-stellar-v2 0.2.29 → 0.2.30

package/sdk/test/upgrader.test.ts

@@ -1,5 +1,4 @@
-import { Address, authorizeEntry, Keypair, xdr } from '@stellar/stellar-sdk';
-import { assembleTransaction } from '@stellar/stellar-sdk/rpc';
+import { BASE_FEE, Contract, scValToNative, TransactionBuilder, xdr } from '@stellar/stellar-sdk';
 import * as rpc from '@stellar/stellar-sdk/rpc';
 import { readFileSync } from 'fs';
 import path from 'path';
@@ -7,13 +6,20 @@ import { describe, expect, it } from 'vitest';
 
 import { getFullyQualifiedRepoRootPath } from '@layerzerolabs/common-node-utils';
 
+import { Client as DvnClient } from '../src/generated/dvn';
 import { Client as UpgraderClient } from '../src/generated/upgrader';
-import { DEFAULT_DEPLOYER, NETWORK_PASSPHRASE, RPC_URL } from './suites/constants';
+import {
+    DEFAULT_DEPLOYER,
+    DVN_SIGNER,
+    DVN_VID,
+    NETWORK_PASSPHRASE,
+    RPC_URL,
+} from './suites/constants';
 import { deployContract, uploadWasm } from './suites/deploy';
-import { Client as DummyContractClient } from './suites/dummyContractClient';
+import { signDvnAuthEntries } from './utils';
 
 let upgraderClient: UpgraderClient;
-let dummyContractClient: DummyContractClient;
+let dvnClient: DvnClient;
 let testContractAddress: string;
 
 // Test data paths
@@ -36,16 +42,14 @@ describe('Upgrader Contract Testing', async () => {
         'contracts',
         'protocol',
         'stellar',
-        'contracts',
-        'upgrader',
-        'src',
-        'tests',
+        'sdk',
+        'test',
         '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');
+    TEST_CONTRACT_V1_WASM_PATH = path.join(upgraderWasmDir, 'dvn.wasm');
+    TEST_CONTRACT_V2_WASM_PATH = path.join(testDataDir, 'test_upgradeable_dvn.wasm');
 
     describe('Contract Deployments', () => {
         it('Deploy Upgrader Contract', async () => {
@@ -61,99 +65,34 @@ describe('Upgrader Contract Testing', async () => {
             expect(upgraderClient.options.contractId).toBeDefined();
         });
 
-        it('Deploy Test Upgradeable Contract V1', async () => {
+        it('Deploy DVN 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
-            dummyContractClient = new DummyContractClient({
-                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(),
-                    };
+            dvnClient = await deployContract<DvnClient>(
+                DvnClient,
+                TEST_CONTRACT_V1_WASM_PATH,
+                {
+                    vid: DVN_VID,
+                    signers: [DVN_SIGNER.ethAddress],
+                    threshold: 1,
+                    admins: [DEFAULT_DEPLOYER.publicKey()],
+                    supported_msglibs: [],
+                    price_feed: DEFAULT_DEPLOYER.publicKey(),
+                    default_multiplier_bps: 10000,
+                    worker_fee_lib: DEFAULT_DEPLOYER.publicKey(),
+                    deposit_address: DEFAULT_DEPLOYER.publicKey(),
                 },
-                rpcUrl: RPC_URL,
-                networkPassphrase: NETWORK_PASSPHRASE,
-                allowHttp: true,
-            });
+                DEFAULT_DEPLOYER,
+            );
+            testContractAddress = dvnClient.options.contractId;
 
             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 dummyContractClient.counter();
-            console.log('✅ Test Contract V1 counter value:', result);
-            expect(result).toBe(1);
+        it('Verify Test Contract V1 VID', async () => {
+            const { result } = await dvnClient.vid();
+            console.log('✅ Test Contract V1 vid value:', result);
+            expect(result).toBe(DVN_VID);
         });
     });
 
@@ -172,128 +111,62 @@ describe('Upgrader Contract Testing', async () => {
             expect(newWasmHash).toBeDefined();
         });
 
-        it('Test Upgrader Contract Can Be Called', async () => {
+        it('Test Upgrader Contract Can Upgrade DVN with Multisig Auth', 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 counterValue = 2;
-            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: xdr.ScVal.scvU32(counterValue).toXDR(),
-                },
-                {
-                    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');
+            const upgradeTx = await upgraderClient.upgrade_and_migrate({
+                contract_address: testContractAddress,
+                wasm_hash: Buffer.from(newWasmHash, 'hex'),
+                migration_data: xdr.ScVal.scvVoid().toXDR(),
+            });
 
-            // 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!
+            await signDvnAuthEntries(
+                testContractAddress,
+                DVN_VID,
+                DEFAULT_DEPLOYER,
+                [DVN_SIGNER],
+                upgradeTx,
+                NETWORK_PASSPHRASE,
             );
 
-            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);
+            await upgradeTx.signAndSend();
+            console.log('✅ Upgrade transaction completed');
+        });
 
-                        if (addr === DEFAULT_DEPLOYER.publicKey()) {
-                            // Sign with owner's keypair
-                            return authorizeEntry(
-                                entry,
-                                DEFAULT_DEPLOYER,
-                                validUntilLedger,
-                                NETWORK_PASSPHRASE,
-                            );
-                        }
+        it('Verify Test Contract V2 test_upgrade_version After Upgrade', async () => {
+            const server = new rpc.Server(RPC_URL, { allowHttp: true });
+            const account = await server.getAccount(DEFAULT_DEPLOYER.publicKey());
+            const contract = new Contract(testContractAddress);
+            const tx = new TransactionBuilder(account, {
+                fee: BASE_FEE,
+                networkPassphrase: NETWORK_PASSPHRASE,
+            })
+                .addOperation(contract.call('test_upgrade_version'))
+                .setTimeout(30)
+                .build();
 
-                        throw new Error(`Unexpected auth signer needed: ${addr}`);
-                    }),
+            const simulated = await server.simulateTransaction(tx);
+            if (rpc.Api.isSimulationError(simulated)) {
+                throw new Error(
+                    `test_upgrade_version simulation failed: ${JSON.stringify(simulated)}`,
                 );
-                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)}`);
+            if (!simulated.result?.retval) {
+                throw new Error('No return value from test_upgrade_version');
             }
 
-            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 dummyContractClient.counter2();
-            console.log('✅ Test Contract V2 counter2 value:', result);
+            const result = scValToNative(simulated.result.retval) as number;
+            console.log('✅ Test Contract V2 test_upgrade_version 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 dummyContractClient.counter();
-            console.log('✅ Test Contract V2 counter value (from V1):', result);
-            expect(result).toBe(1);
+        it('Verify Test Contract V1 Methods Still Work After Upgrade', async () => {
+            const { result } = await dvnClient.vid();
+            console.log('✅ Test Contract V2 vid value (from V1):', result);
+            expect(result).toBe(DVN_VID);
         });
     });
 });

package/sdk/test/utils.ts

@@ -113,6 +113,46 @@ export async function getNativeBalance(accountAddress: string): Promise<bigint>
     return getTokenBalance(accountAddress, NATIVE_TOKEN_ADDRESS);
 }
 
+/**
+ * Helper to check if an account is authorized on a SAC (Stellar Asset Contract).
+ * Calls the SAC's `authorized()` method directly.
+ *
+ * @param accountAddress - The account to check authorization for
+ * @param tokenAddress - The SAC contract address
+ */
+export async function getTokenAuthorized(
+    accountAddress: string,
+    tokenAddress: string,
+): Promise<boolean> {
+    const server = new rpc.Server(RPC_URL, { allowHttp: true });
+    const tokenContract = new Contract(tokenAddress);
+
+    const authorizedOp = tokenContract.call(
+        'authorized',
+        nativeToScVal(Address.fromString(accountAddress), { type: 'address' }),
+    );
+
+    const account = await server.getAccount(DEFAULT_DEPLOYER.publicKey());
+    const tx = new TransactionBuilder(account, {
+        fee: BASE_FEE,
+        networkPassphrase: NETWORK_PASSPHRASE,
+    })
+        .addOperation(authorizedOp)
+        .setTimeout(30)
+        .build();
+
+    const simulated = await server.simulateTransaction(tx);
+    if (rpc.Api.isSimulationError(simulated)) {
+        throw new Error(`Authorized query failed: ${JSON.stringify(simulated)}`);
+    }
+
+    const result = (simulated as rpc.Api.SimulateTransactionSuccessResponse).result;
+    if (result?.retval) {
+        return scValToNative(result.retval) as boolean;
+    }
+    return false;
+}
+
 // ============================================================================
 // Secp256k1 Key Pair for DVN Multisig
 // ============================================================================

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

@@ -103,6 +103,7 @@ fn main() -> Result<()> {
         // OApp contracts
         ("counter", "counter.ts"),
         ("oft", "oft.ts"),
+        ("sac_manager", "sac_manager.ts"),
         // View contracts
         ("layerzero_views", "layerzero_view.ts"),
         // Add more contracts here as needed: