@layerzerolabs/protocol-stellar-v2 0.2.121 → 0.2.122

package/sdk/test/sac-manager.test.ts

@@ -1,464 +0,0 @@
-import {
-    Address,
-    Asset,
-    AuthClawbackEnabledFlag,
-    type AuthFlag,
-    AuthRevocableFlag,
-    BASE_FEE,
-    Keypair,
-    Operation,
-    rpc,
-    TransactionBuilder,
-} from '@stellar/stellar-sdk';
-import path from 'path';
-import { beforeAll, describe, expect, it } from 'vitest';
-
-import { getFullyQualifiedRepoRootPath } from '@layerzerolabs/common-node-utils';
-
-import { Client as SACManagerClient } from '../src/generated/sac_manager.js';
-import { DEFAULT_DEPLOYER, NETWORK_PASSPHRASE, RPC_URL } from './suites/constants.js';
-import { deployAssetSac, deployContract } from './suites/deploy.js';
-import { fundAccount } from './suites/localnet.js';
-import { getTokenAuthorized, getTokenBalance } from './utils.js';
-
-// ============================================================================
-// Test Accounts
-// ============================================================================
-
-const TOKEN_ISSUER = Keypair.random();
-const USER_A = Keypair.random();
-const USER_B = Keypair.random();
-const USER_C = Keypair.random();
-
-// Token configuration
-const TOKEN_CODE = 'RTKN';
-let TOKEN_ASSET: Asset;
-
-// Contract addresses
-let sacTokenAddress = '';
-let sacManagerAddress = '';
-
-// Clients
-let sacManagerClient: SACManagerClient;
-
-// Initial token amounts
-const INITIAL_TOKEN_AMOUNT = '1000'; // 1000 tokens
-const MINT_AMOUNT = 100_0000000n; // 100 tokens (7 decimals)
-
-// ============================================================================
-// Helper Functions
-// ============================================================================
-
-/**
- * Creates a SACManagerClient with a specific signer
- */
-function createClientWithSigner(contractId: string, signer: Keypair): SACManagerClient {
-    return new SACManagerClient({
-        contractId,
-        publicKey: signer.publicKey(),
-        signTransaction: async (tx: string) => {
-            const transaction = TransactionBuilder.fromXDR(tx, NETWORK_PASSPHRASE);
-            transaction.sign(signer);
-            return {
-                signedTxXdr: transaction.toXDR(),
-                signerAddress: signer.publicKey(),
-            };
-        },
-        rpcUrl: RPC_URL,
-        networkPassphrase: NETWORK_PASSPHRASE,
-        allowHttp: true,
-    });
-}
-
-/**
- * Invokes a SAC contract function using raw transaction building
- */
-async function invokeSacFunction(
-    sacAddress: string,
-    functionName: string,
-    args: any[],
-    signer: Keypair,
-): Promise<void> {
-    const server = new rpc.Server(RPC_URL, { allowHttp: true });
-    const account = await server.getAccount(signer.publicKey());
-
-    const tx = new TransactionBuilder(account, {
-        fee: BASE_FEE,
-        networkPassphrase: NETWORK_PASSPHRASE,
-    })
-        .addOperation(
-            Operation.invokeContractFunction({
-                contract: sacAddress,
-                function: functionName,
-                args,
-            }),
-        )
-        .setTimeout(30)
-        .build();
-
-    const simulated = await server.simulateTransaction(tx);
-    if (rpc.Api.isSimulationError(simulated)) {
-        throw new Error(`Simulation failed: ${JSON.stringify(simulated)}`);
-    }
-
-    const preparedTx = rpc.assembleTransaction(tx, simulated).build();
-    preparedTx.sign(signer);
-
-    const sendResult = await server.sendTransaction(preparedTx);
-    if (sendResult.status !== 'PENDING') {
-        throw new Error(`Transaction failed to send: ${JSON.stringify(sendResult)}`);
-    }
-
-    const txResult = await server.pollTransaction(sendResult.hash);
-    if (txResult.status !== 'SUCCESS') {
-        throw new Error(`Transaction not successful: ${JSON.stringify(txResult)}`);
-    }
-}
-
-// ============================================================================
-// Test Suite
-// ============================================================================
-
-describe('SAC Manager E2E Tests', async () => {
-    const repoRoot = await getFullyQualifiedRepoRootPath();
-    const wasmDir = path.join(
-        repoRoot,
-        'contracts',
-        'protocol',
-        'stellar',
-        'target',
-        'wasm32v1-none',
-        'release',
-    );
-
-    const SAC_MANAGER_WASM_PATH = path.join(wasmDir, 'sac_manager.wasm');
-
-    beforeAll(async () => {
-        console.log('\n====================================');
-        console.log('SAC Manager E2E Tests');
-        console.log('====================================\n');
-
-        console.log('Funding test accounts...');
-        await Promise.all([
-            fundAccount(TOKEN_ISSUER.publicKey()),
-            fundAccount(USER_A.publicKey()),
-            fundAccount(USER_B.publicKey()),
-            fundAccount(USER_C.publicKey()),
-        ]);
-        console.log('Test accounts funded');
-
-        TOKEN_ASSET = new Asset(TOKEN_CODE, TOKEN_ISSUER.publicKey());
-    });
-
-    // ========================================================================
-    // Setup SAC Manager with SAC
-    // ========================================================================
-
-    describe('Setup SAC Manager with SAC', () => {
-        it('Set AUTH_REVOCABLE and AUTH_CLAWBACK_ENABLED flags on issuer account', async () => {
-            const server = new rpc.Server(RPC_URL, { allowHttp: true });
-            const issuerAccount = await server.getAccount(TOKEN_ISSUER.publicKey());
-
-            const authFlags = (AuthRevocableFlag | AuthClawbackEnabledFlag) as AuthFlag;
-            const setOptionsTx = new TransactionBuilder(issuerAccount, {
-                fee: BASE_FEE,
-                networkPassphrase: NETWORK_PASSPHRASE,
-            })
-                .addOperation(
-                    Operation.setOptions({
-                        setFlags: authFlags,
-                    }),
-                )
-                .setTimeout(30)
-                .build();
-
-            setOptionsTx.sign(TOKEN_ISSUER);
-
-            const sendResult = await server.sendTransaction(setOptionsTx);
-            if (sendResult.status !== 'PENDING') {
-                throw new Error(`Failed to set auth flags: ${JSON.stringify(sendResult)}`);
-            }
-
-            const txResult = await server.pollTransaction(sendResult.hash);
-            if (txResult.status !== 'SUCCESS') {
-                throw new Error(`Failed to set auth flags: ${JSON.stringify(txResult)}`);
-            }
-
-            console.log('AUTH_REVOCABLE and AUTH_CLAWBACK_ENABLED flags set on issuer');
-        });
-
-        it('Deploy SAC with trustlines and issue tokens', async () => {
-            const server = new rpc.Server(RPC_URL, { allowHttp: true });
-
-            const issuerAccount = await server.getAccount(TOKEN_ISSUER.publicKey());
-            const issueTx = new TransactionBuilder(issuerAccount, {
-                fee: BASE_FEE,
-                networkPassphrase: NETWORK_PASSPHRASE,
-            })
-                .addOperation(
-                    Operation.changeTrust({
-                        asset: TOKEN_ASSET,
-                        source: DEFAULT_DEPLOYER.publicKey(),
-                    }),
-                )
-                .addOperation(
-                    Operation.changeTrust({
-                        asset: TOKEN_ASSET,
-                        source: USER_A.publicKey(),
-                    }),
-                )
-                .addOperation(
-                    Operation.changeTrust({
-                        asset: TOKEN_ASSET,
-                        source: USER_B.publicKey(),
-                    }),
-                )
-                .addOperation(
-                    Operation.changeTrust({
-                        asset: TOKEN_ASSET,
-                        source: USER_C.publicKey(),
-                    }),
-                )
-                .addOperation(
-                    Operation.payment({
-                        asset: TOKEN_ASSET,
-                        amount: INITIAL_TOKEN_AMOUNT,
-                        destination: USER_A.publicKey(),
-                    }),
-                )
-                .addOperation(
-                    Operation.payment({
-                        asset: TOKEN_ASSET,
-                        amount: INITIAL_TOKEN_AMOUNT,
-                        destination: USER_B.publicKey(),
-                    }),
-                )
-                .setTimeout(30)
-                .build();
-
-            issueTx.sign(TOKEN_ISSUER, DEFAULT_DEPLOYER, USER_A, USER_B, USER_C);
-
-            const sendResult = await server.sendTransaction(issueTx);
-            if (sendResult.status !== 'PENDING') {
-                throw new Error(`Failed to setup trustlines: ${JSON.stringify(sendResult)}`);
-            }
-
-            const txResult = await server.pollTransaction(sendResult.hash);
-            if (txResult.status !== 'SUCCESS') {
-                throw new Error(`Failed to setup trustlines: ${JSON.stringify(txResult)}`);
-            }
-
-            console.log('Trustlines created and tokens issued');
-
-            sacTokenAddress = await deployAssetSac(TOKEN_ASSET);
-            console.log('SAC deployed at:', sacTokenAddress);
-        });
-
-        it('Deploy SAC Manager contract', async () => {
-            sacManagerClient = await deployContract<SACManagerClient>(
-                SACManagerClient,
-                SAC_MANAGER_WASM_PATH,
-                {
-                    sac_token: sacTokenAddress,
-                    owner: DEFAULT_DEPLOYER.publicKey(),
-                },
-                DEFAULT_DEPLOYER,
-            );
-
-            sacManagerAddress = sacManagerClient.options.contractId;
-            console.log('SAC Manager deployed at:', sacManagerAddress);
-        });
-
-        it('Grant all roles to owner', async () => {
-            for (const role of [
-                'ADMIN_MANAGER_ROLE',
-                'MINTER_ROLE',
-                'BLACKLISTER_ROLE',
-                'CLAWBACK_ROLE',
-            ]) {
-                const assembledTx = await sacManagerClient.grant_role({
-                    account: DEFAULT_DEPLOYER.publicKey(),
-                    role,
-                    caller: DEFAULT_DEPLOYER.publicKey(),
-                });
-                await assembledTx.signAndSend();
-            }
-            console.log('All roles granted to owner');
-        });
-
-        it('Set SAC admin to SAC Manager', async () => {
-            await invokeSacFunction(
-                sacTokenAddress,
-                'set_admin',
-                [Address.fromString(sacManagerAddress).toScVal()],
-                TOKEN_ISSUER,
-            );
-            console.log('SAC admin set to SAC Manager');
-        });
-
-        it('Verify owner (DEFAULT_DEPLOYER) starts with zero balance', async () => {
-            const ownerBalance = await getTokenBalance(
-                DEFAULT_DEPLOYER.publicKey(),
-                sacTokenAddress,
-            );
-            console.log('Owner (DEFAULT_DEPLOYER) balance:', ownerBalance.toString());
-            expect(ownerBalance).toBe(0n);
-        });
-    });
-
-    // ========================================================================
-    // Blacklist Management
-    // ========================================================================
-
-    describe('Blacklist Management', () => {
-        it('Verify all accounts start authorized', async () => {
-            const [userAAuthorized, userBAuthorized, userCAuthorized] = await Promise.all([
-                getTokenAuthorized(USER_A.publicKey(), sacTokenAddress),
-                getTokenAuthorized(USER_B.publicKey(), sacTokenAddress),
-                getTokenAuthorized(USER_C.publicKey(), sacTokenAddress),
-            ]);
-
-            expect(userAAuthorized).toBe(true);
-            expect(userBAuthorized).toBe(true);
-            expect(userCAuthorized).toBe(true);
-            console.log('All users start authorized');
-        });
-
-        it('Blacklist USER_B via set_authorized', async () => {
-            // operator: caller must have BLACKLISTER_ROLE (generated client will include operator after regeneration)
-            const assembledTx = await (
-                sacManagerClient.set_authorized as (args: {
-                    id: string;
-                    authorize: boolean;
-                    operator: string;
-                }) => ReturnType<typeof sacManagerClient.set_authorized>
-            )({
-                id: USER_B.publicKey(),
-                authorize: false,
-                operator: DEFAULT_DEPLOYER.publicKey(),
-            });
-            await assembledTx.signAndSend();
-            console.log('USER_B blacklisted (authorized=false)');
-        });
-
-        it('Verify USER_B is blacklisted', async () => {
-            const authorized = await getTokenAuthorized(USER_B.publicKey(), sacTokenAddress);
-            expect(authorized).toBe(false);
-            console.log('USER_B authorized:', authorized);
-        });
-
-        it('Non-admin cannot call set_authorized', async () => {
-            const userClient = createClientWithSigner(sacManagerAddress, USER_A);
-            // operator: USER_A does not have BLACKLISTER_ROLE (generated client will include operator after regeneration)
-            const assembledTx = await (
-                userClient.set_authorized as (args: {
-                    id: string;
-                    authorize: boolean;
-                    operator: string;
-                }) => ReturnType<typeof userClient.set_authorized>
-            )({
-                id: USER_C.publicKey(),
-                authorize: false,
-                operator: USER_A.publicKey(),
-            });
-            await expect(assembledTx.signAndSend()).rejects.toThrow();
-            console.log('Non-admin correctly rejected from calling set_authorized');
-        });
-
-        it('Un-blacklist USER_B via set_authorized', async () => {
-            // operator: caller must have BLACKLISTER_ROLE (generated client will include operator after regeneration)
-            const assembledTx = await (
-                sacManagerClient.set_authorized as (args: {
-                    id: string;
-                    authorize: boolean;
-                    operator: string;
-                }) => ReturnType<typeof sacManagerClient.set_authorized>
-            )({
-                id: USER_B.publicKey(),
-                authorize: true,
-                operator: DEFAULT_DEPLOYER.publicKey(),
-            });
-            await assembledTx.signAndSend();
-            const authorized = await getTokenAuthorized(USER_B.publicKey(), sacTokenAddress);
-            expect(authorized).toBe(true);
-            console.log('USER_B un-blacklisted');
-        });
-    });
-
-    // ========================================================================
-    // Mint (operator must have MINTER_ROLE)
-    // ========================================================================
-
-    describe('Mint', () => {
-        it('Verify initial balances', async () => {
-            const [userABalance, userBBalance, userCBalance, ownerBalance] = await Promise.all([
-                getTokenBalance(USER_A.publicKey(), sacTokenAddress),
-                getTokenBalance(USER_B.publicKey(), sacTokenAddress),
-                getTokenBalance(USER_C.publicKey(), sacTokenAddress),
-                getTokenBalance(DEFAULT_DEPLOYER.publicKey(), sacTokenAddress),
-            ]);
-
-            console.log('\nInitial Balances:');
-            console.log(`  USER_A: ${userABalance}`);
-            console.log(`  USER_B: ${userBBalance}`);
-            console.log(`  USER_C: ${userCBalance}`);
-            console.log(`  Owner: ${ownerBalance}`);
-
-            expect(userABalance).toBe(10000000000n);
-            expect(userBBalance).toBe(10000000000n);
-            expect(userCBalance).toBe(0n);
-            expect(ownerBalance).toBe(0n);
-        });
-
-        it('Minter can mint to non-blacklisted address', async () => {
-            const userCBalanceBefore = await getTokenBalance(USER_C.publicKey(), sacTokenAddress);
-
-            const assembledTx = await sacManagerClient.mint({
-                to: USER_C.publicKey(),
-                amount: MINT_AMOUNT,
-                operator: DEFAULT_DEPLOYER.publicKey(),
-            });
-            await assembledTx.signAndSend();
-
-            const userCBalance = await getTokenBalance(USER_C.publicKey(), sacTokenAddress);
-            console.log('\nAfter mint to USER_C:', userCBalance);
-            expect(userCBalance).toBe(userCBalanceBefore + MINT_AMOUNT);
-        });
-
-        it('Non-minter cannot mint', async () => {
-            const userClient = createClientWithSigner(sacManagerAddress, USER_A);
-            const assembledTx = await userClient.mint({
-                to: USER_C.publicKey(),
-                amount: MINT_AMOUNT,
-                operator: USER_A.publicKey(),
-            });
-            await expect(assembledTx.signAndSend()).rejects.toThrow();
-            console.log('Non-minter correctly rejected');
-        });
-    });
-
-    // ========================================================================
-    // Final Summary
-    // ========================================================================
-
-    describe('Final Summary', () => {
-        it('Print final balances', async () => {
-            const [userABalance, userBBalance, userCBalance, ownerBalance] = await Promise.all([
-                getTokenBalance(USER_A.publicKey(), sacTokenAddress),
-                getTokenBalance(USER_B.publicKey(), sacTokenAddress),
-                getTokenBalance(USER_C.publicKey(), sacTokenAddress),
-                getTokenBalance(DEFAULT_DEPLOYER.publicKey(), sacTokenAddress),
-            ]);
-
-            console.log('\n========================================');
-            console.log('Final Balance Summary');
-            console.log('========================================');
-            console.log(`  USER_A: ${userABalance}`);
-            console.log(`  USER_B: ${userBBalance}`);
-            console.log(`  USER_C: ${userCBalance}`);
-            console.log(`  Owner: ${ownerBalance}`);
-            console.log('========================================\n');
-            console.log('SAC Manager E2E tests completed successfully!');
-        });
-    });
-});

package/sdk/test/secp256k1.ts

@@ -1,59 +0,0 @@
-import { keccak_256 } from '@noble/hashes/sha3';
-import * as secp from '@noble/secp256k1';
-
-/**
- * A secp256k1 key pair with private key and derived Ethereum-style address.
- * Used for DVN multisig signing.
- */
-export class Secp256k1KeyPair {
-    private privateKey: Uint8Array;
-    public readonly ethAddress: Buffer;
-
-    constructor(privateKey: Uint8Array | Buffer | string) {
-        if (typeof privateKey === 'string') {
-            // Remove 0x prefix if present
-            const hex = privateKey.startsWith('0x') ? privateKey.slice(2) : privateKey;
-            this.privateKey = Buffer.from(hex, 'hex');
-        } else {
-            this.privateKey = new Uint8Array(privateKey);
-        }
-        this.ethAddress = this.deriveEthAddress();
-    }
-
-    /**
-     * Generate a random key pair.
-     */
-    static generate(): Secp256k1KeyPair {
-        const privateKey = secp.utils.randomPrivateKey();
-        return new Secp256k1KeyPair(privateKey);
-    }
-
-    /**
-     * Derive Ethereum-style address from the public key.
-     * Address = last 20 bytes of keccak256(uncompressed_pubkey[1:65])
-     */
-    private deriveEthAddress(): Buffer {
-        const publicKey = secp.getPublicKey(this.privateKey, false); // uncompressed
-        const pubkeyWithoutPrefix = publicKey.slice(1); // remove 0x04 prefix
-        const hash = keccak_256(pubkeyWithoutPrefix);
-        return Buffer.from(hash.slice(12)); // last 20 bytes
-    }
-
-    /**
-     * Sign a 32-byte digest and return a 65-byte signature (r || s || v).
-     */
-    async sign(digest: Uint8Array): Promise<Buffer> {
-        const [signature, recoveryId] = await secp.sign(digest, this.privateKey, {
-            canonical: true,
-            recovered: true,
-            der: false,
-        });
-
-        const v = 27 + recoveryId;
-        const result = Buffer.alloc(65);
-        result.set(signature, 0); // r (32 bytes) + s (32 bytes)
-        result[64] = v;
-
-        return result;
-    }
-}

package/sdk/test/suites/constants.ts

@@ -1,51 +0,0 @@
-import { Asset, Keypair, Networks } from '@stellar/stellar-sdk';
-
-import { Secp256k1KeyPair } from '../secp256k1.js';
-
-const CORE_URL = 'http://localhost:8086';
-export const RPC_URL = `${CORE_URL}/soroban/rpc`;
-export const NETWORK_PASSPHRASE = Networks.STANDALONE;
-
-// Pre-funded in the ECR localnet image (BIP39: "test test...junk", path m/44'/148'/0')
-export const JUNK_WALLET = Keypair.fromSecret(
-    'SCZ5VBFVGE4SLZV5WJO33LEEU36EEOEHWO27KYJIIUWGOKZB2OSNAQBI',
-);
-export const DEFAULT_DEPLOYER = Keypair.fromSecret(
-    'SDLCA3JUES3G6R4FTI6XXDIWW7QCNMZNWPYQQIKQ26TEIZUFOLIVIUDK',
-);
-export const ZRO_DISTRIBUTOR = Keypair.fromSecret(
-    'SB6QAFXFRR2MXYHW4RRZ23JDGKHDCYCT5YTQEGG3WNT5VKZADJQFVNWG',
-);
-// Use deterministic keypair for EXECUTOR_ADMIN to ensure consistency between globalSetup and test files
-// (globalSetup runs in a separate process, so Keypair.random() would generate different keys)
-export const EXECUTOR_ADMIN = Keypair.fromSecret(
-    'SACWJCNRT2AYRPBWW7IBRNI765EMZSWPXXAAHYN57UFQNOXMGET7HM5K',
-);
-// Separate deployer for Chain B to enable parallel contract deployment in globalSetup
-export const CHAIN_B_DEPLOYER = Keypair.fromSecret(
-    'SDLIZSTG7W4C3FZYY52WIKF7FTWAXCWC5Z4OVVF3TDA3MBOR37LMIANJ',
-);
-
-// DVN secp256k1 signer for multisig (deterministic key for testing)
-// Private key is keccak256("dvn_test_signer") truncated to 32 bytes
-export const DVN_SIGNER = new Secp256k1KeyPair(
-    '0x8d3f8d5d8f1c7e2a5b4c3d6e9f0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a',
-);
-
-// DVN configuration
-export const DVN_VID = 1;
-
-// Two-chain EIDs for cross-chain testing
-export const EID_A = 30401;
-export const EID_B = 30402;
-
-// Legacy single EID (kept for backwards compatibility)
-export const EID = EID_A;
-
-export const NATIVE_TOKEN_ADDRESS = Asset.native().contractId(NETWORK_PASSPHRASE);
-export const ZRO_ASSET = new Asset('ZRO', DEFAULT_DEPLOYER.publicKey());
-export const ZRO_TOKEN_ADDRESS = ZRO_ASSET.contractId(NETWORK_PASSPHRASE);
-export const MSG_TYPE_VANILLA = 1;
-export const MSG_TYPE_COMPOSED = 2;
-export const MSG_TYPE_ABA = 3;
-export const MSG_TYPE_COMPOSED_ABA = 4;