@layerzerolabs/lz-v2-stellar-sdk 0.2.32 → 0.2.34

package/test/oft-sml.test.ts

@@ -17,6 +17,7 @@ import { PacketSerializer, PacketV1Codec } from '@layerzerolabs/lz-v2-utilities'
 import { Client as EndpointClient } from '../src/generated/endpoint';
 import { Client as ExecutorHelperClient } from '../src/generated/executor_helper';
 import { Client as OFTClient, SendParam } from '../src/generated/oft';
+import { Client as SacManagerClient } from '../src/generated/sac_manager';
 import { Client as SMLClient } from '../src/generated/sml';
 import {
     DEFAULT_DEPLOYER,
@@ -43,6 +44,7 @@ let chainB: ChainAddresses;
 
 // OFT-specific addresses
 let oftTokenAddress = '';
+let sacManagerAddress = ''; // Mintable for Mint/Burn OFT (Chain B)
 let lockUnlockOftAddress = ''; // Chain A
 let mintBurnOftAddress = ''; // Chain B
 
@@ -87,6 +89,7 @@ describe('OFT Cross-Chain E2E Testing with SAC (SML)', async () => {
     );
 
     const OFT_WASM_PATH = path.join(wasmDir, 'oft.wasm');
+    const SAC_MANAGER_WASM_PATH = path.join(wasmDir, 'sac_manager.wasm');
 
     beforeAll(async () => {
         // Inject chain addresses from globalSetup
@@ -180,6 +183,53 @@ describe('OFT Cross-Chain E2E Testing with SAC (SML)', async () => {
             console.log('✅ OFT Token SAC deployed:', oftTokenAddress);
         });
 
+        it('Deploy SAC Manager and set SAC admin (mintable for Mint/Burn OFT)', async () => {
+            const sacManagerClient = await deployContract<SacManagerClient>(
+                SacManagerClient,
+                SAC_MANAGER_WASM_PATH,
+                {
+                    sac_token: oftTokenAddress,
+                    owner: DEFAULT_DEPLOYER.publicKey(),
+                },
+                DEFAULT_DEPLOYER,
+            );
+            sacManagerAddress = sacManagerClient.options.contractId;
+            console.log('✅ SAC Manager deployed:', sacManagerAddress);
+
+            const server = new rpc.Server(RPC_URL, { allowHttp: true });
+            const account = await server.getAccount(TOKEN_ISSUER.publicKey());
+            const setAdminTx = new TransactionBuilder(account, {
+                fee: BASE_FEE,
+                networkPassphrase: NETWORK_PASSPHRASE,
+            })
+                .addOperation(
+                    Operation.invokeContractFunction({
+                        contract: oftTokenAddress,
+                        function: 'set_admin',
+                        args: [Address.fromString(sacManagerAddress).toScVal()],
+                    }),
+                )
+                .setTimeout(30)
+                .build();
+
+            const simulated = await server.simulateTransaction(setAdminTx);
+            if (rpc.Api.isSimulationError(simulated)) {
+                throw new Error(`Simulation failed: ${JSON.stringify(simulated)}`);
+            }
+            const preparedTx = rpc.assembleTransaction(setAdminTx, simulated).build();
+            preparedTx.sign(TOKEN_ISSUER);
+
+            const sendResult = await server.sendTransaction(preparedTx);
+            if (sendResult.status !== 'PENDING') {
+                throw new Error(`Failed to set admin: ${JSON.stringify(sendResult)}`);
+            }
+            const txResult = await server.pollTransaction(sendResult.hash);
+            if (txResult.status !== 'SUCCESS') {
+                throw new Error(`Failed to set admin: ${JSON.stringify(txResult)}`);
+            }
+            console.log('✅ SAC admin set to SAC Manager');
+        });
+
         it('Deploy Lock/Unlock OFT on Chain A', async () => {
             lockUnlockOftClient = await deployContract<OFTClient>(
                 OFTClient,
@@ -212,7 +262,7 @@ describe('OFT Cross-Chain E2E Testing with SAC (SML)', async () => {
                     endpoint: chainB.endpointV2, // Chain B endpoint
                     delegate: DEFAULT_DEPLOYER.publicKey(),
                     shared_decimals: SHARED_DECIMALS,
-                    oft_type: { tag: 'MintBurn', values: [oftTokenAddress] },
+                    oft_type: { tag: 'MintBurn', values: [sacManagerAddress] },
                 },
                 DEFAULT_DEPLOYER,
             );
@@ -328,42 +378,28 @@ describe('OFT Cross-Chain E2E Testing with SAC (SML)', async () => {
             console.log('✅ Mint/Burn OFT (Chain B) peer set to Lock/Unlock OFT for EID_A');
         });
 
-        it('Set SAC Admin to Mint/Burn OFT (for minting)', async () => {
-            const server = new rpc.Server(RPC_URL, { allowHttp: true });
-
-            const account = await server.getAccount(TOKEN_ISSUER.publicKey());
-
-            const setAdminTx = new TransactionBuilder(account, {
-                fee: BASE_FEE,
+        it('Add Mint/Burn OFT as minter on SAC Manager (for receive/mint)', async () => {
+            const sacManagerClient = new SacManagerClient({
+                contractId: sacManagerAddress,
+                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,
-            })
-                .addOperation(
-                    Operation.invokeContractFunction({
-                        contract: oftTokenAddress,
-                        function: 'set_admin',
-                        args: [Address.fromString(mintBurnOftAddress).toScVal()],
-                    }),
-                )
-                .setTimeout(30)
-                .build();
-
-            const simulated = await server.simulateTransaction(setAdminTx);
-            if (rpc.Api.isSimulationError(simulated)) {
-                throw new Error(`Simulation failed: ${JSON.stringify(simulated)}`);
-            }
-            const preparedTx = rpc.assembleTransaction(setAdminTx, simulated).build();
-            preparedTx.sign(TOKEN_ISSUER);
-
-            const sendResult = await server.sendTransaction(preparedTx);
-            if (sendResult.status !== 'PENDING') {
-                throw new Error(`Failed to set admin: ${JSON.stringify(sendResult)}`);
-            }
-            const txResult = await server.pollTransaction(sendResult.hash);
-            if (txResult.status !== 'SUCCESS') {
-                throw new Error(`Failed to set admin: ${JSON.stringify(txResult)}`);
-            }
-
-            console.log('✅ SAC admin set to Mint/Burn OFT');
+                allowHttp: true,
+            });
+            const assembledTx = await sacManagerClient.set_minter({
+                minter: mintBurnOftAddress,
+                active: true,
+            });
+            await assembledTx.signAndSend();
+            console.log('✅ Mint/Burn OFT added as minter on SAC Manager');
         });
     });
 

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

@@ -26,7 +26,6 @@ import { getTokenAuthorized, getTokenBalance } from './utils';
 // ============================================================================
 
 const TOKEN_ISSUER = Keypair.random();
-const REDISTRIBUTION_ADMIN = Keypair.random();
 const USER_A = Keypair.random();
 const USER_B = Keypair.random();
 const USER_C = Keypair.random();
@@ -44,8 +43,7 @@ let sacManagerClient: SacManagerClient;
 
 // Initial token amounts
 const INITIAL_TOKEN_AMOUNT = '1000'; // 1000 tokens
-const TRANSFER_AMOUNT = 100_0000000n; // 100 tokens (7 decimals)
-const REDISTRIBUTE_AMOUNT = 50_0000000n; // 50 tokens (7 decimals)
+const MINT_AMOUNT = 100_0000000n; // 100 tokens (7 decimals)
 
 // ============================================================================
 // Helper Functions
@@ -72,9 +70,6 @@ function createClientWithSigner(contractId: string, signer: Keypair): SacManager
     });
 }
 
-// Note: The old executeRedistributeFundsWithAuth function has been removed
-// because we now use the SacManagerClient directly which handles authorization properly
-
 /**
  * Invokes a SAC contract function using raw transaction building
  */
@@ -124,7 +119,7 @@ async function invokeSacFunction(
 // Test Suite
 // ============================================================================
 
-describe('SAC Manager Redistribution E2E Tests', async () => {
+describe('SAC Manager E2E Tests', async () => {
     const repoRoot = await getFullyQualifiedRepoRootPath();
     const wasmDir = path.join(
         repoRoot,
@@ -140,25 +135,22 @@ describe('SAC Manager Redistribution E2E Tests', async () => {
 
     beforeAll(async () => {
         console.log('\n====================================');
-        console.log('SAC Manager Redistribution E2E Tests');
+        console.log('SAC Manager E2E Tests');
         console.log('====================================\n');
 
-        // Fund test accounts (including DEFAULT_DEPLOYER which is normally funded by globalSetup)
         console.log('Funding test accounts...');
         await fundAccount(DEFAULT_DEPLOYER.publicKey());
         await fundAccount(TOKEN_ISSUER.publicKey());
-        await fundAccount(REDISTRIBUTION_ADMIN.publicKey());
         await fundAccount(USER_A.publicKey());
         await fundAccount(USER_B.publicKey());
         await fundAccount(USER_C.publicKey());
         console.log('Test accounts funded');
 
-        // Create the token asset
         TOKEN_ASSET = new Asset(TOKEN_CODE, TOKEN_ISSUER.publicKey());
     });
 
     // ========================================================================
-    // Setup SAC Manager with SAC (redistribution enabled at construction)
+    // Setup SAC Manager with SAC
     // ========================================================================
 
     describe('Setup SAC Manager with SAC', () => {
@@ -166,9 +158,6 @@ describe('SAC Manager Redistribution E2E Tests', async () => {
             const server = new rpc.Server(RPC_URL, { allowHttp: true });
             const issuerAccount = await server.getAccount(TOKEN_ISSUER.publicKey());
 
-            // Set AUTH_REVOCABLE and AUTH_CLAWBACK_ENABLED flags on issuer
-            // AUTH_REVOCABLE allows revoking authorization (blacklisting)
-            // AUTH_CLAWBACK_ENABLED allows clawback operations (required for redistribute_funds)
             const authFlags = (AuthRevocableFlag | AuthClawbackEnabledFlag) as AuthFlag;
             const setOptionsTx = new TransactionBuilder(issuerAccount, {
                 fee: BASE_FEE,
@@ -200,48 +189,35 @@ describe('SAC Manager Redistribution E2E Tests', async () => {
         it('Deploy SAC with trustlines and issue tokens', async () => {
             const server = new rpc.Server(RPC_URL, { allowHttp: true });
 
-            // Create trustlines for all test accounts and issue tokens
             const issuerAccount = await server.getAccount(TOKEN_ISSUER.publicKey());
             const issueTx = new TransactionBuilder(issuerAccount, {
                 fee: BASE_FEE,
                 networkPassphrase: NETWORK_PASSPHRASE,
             })
-                // Trustline for DEFAULT_DEPLOYER (will be the SAC manager admin)
                 .addOperation(
                     Operation.changeTrust({
                         asset: TOKEN_ASSET,
                         source: DEFAULT_DEPLOYER.publicKey(),
                     }),
                 )
-                // Trustline for REDISTRIBUTION_ADMIN
-                .addOperation(
-                    Operation.changeTrust({
-                        asset: TOKEN_ASSET,
-                        source: REDISTRIBUTION_ADMIN.publicKey(),
-                    }),
-                )
-                // Trustline for USER_A
                 .addOperation(
                     Operation.changeTrust({
                         asset: TOKEN_ASSET,
                         source: USER_A.publicKey(),
                     }),
                 )
-                // Trustline for USER_B
                 .addOperation(
                     Operation.changeTrust({
                         asset: TOKEN_ASSET,
                         source: USER_B.publicKey(),
                     }),
                 )
-                // Trustline for USER_C
                 .addOperation(
                     Operation.changeTrust({
                         asset: TOKEN_ASSET,
                         source: USER_C.publicKey(),
                     }),
                 )
-                // Issue tokens to USER_A (sender)
                 .addOperation(
                     Operation.payment({
                         asset: TOKEN_ASSET,
@@ -249,7 +225,6 @@ describe('SAC Manager Redistribution E2E Tests', async () => {
                         destination: USER_A.publicKey(),
                     }),
                 )
-                // Issue tokens to USER_B (will be blacklisted)
                 .addOperation(
                     Operation.payment({
                         asset: TOKEN_ASSET,
@@ -260,14 +235,7 @@ describe('SAC Manager Redistribution E2E Tests', async () => {
                 .setTimeout(30)
                 .build();
 
-            issueTx.sign(
-                TOKEN_ISSUER,
-                DEFAULT_DEPLOYER,
-                REDISTRIBUTION_ADMIN,
-                USER_A,
-                USER_B,
-                USER_C,
-            );
+            issueTx.sign(TOKEN_ISSUER, DEFAULT_DEPLOYER, USER_A, USER_B, USER_C);
 
             const sendResult = await server.sendTransaction(issueTx);
             if (sendResult.status !== 'PENDING') {
@@ -281,20 +249,17 @@ describe('SAC Manager Redistribution E2E Tests', async () => {
 
             console.log('Trustlines created and tokens issued');
 
-            // Deploy the SAC for the token
             sacTokenAddress = await deployAssetSac(TOKEN_ASSET);
             console.log('SAC deployed at:', sacTokenAddress);
         });
 
-        it('Deploy SAC Manager contract with redistribution enabled', async () => {
+        it('Deploy SAC Manager contract', async () => {
             sacManagerClient = await deployContract<SacManagerClient>(
                 SacManagerClient,
                 SAC_MANAGER_WASM_PATH,
                 {
                     sac_token: sacTokenAddress,
                     owner: DEFAULT_DEPLOYER.publicKey(),
-                    redistribution_enabled: true,
-                    supply_control_enabled: false,
                 },
                 DEFAULT_DEPLOYER,
             );
@@ -304,22 +269,25 @@ describe('SAC Manager Redistribution E2E Tests', async () => {
         });
 
         it('Set SAC admin to SAC Manager', async () => {
-            // Set the SAC admin to the SAC manager contract
-            // This allows the SAC manager to call clawback, set_authorized, mint, etc.
             await invokeSacFunction(
                 sacTokenAddress,
                 'set_admin',
                 [Address.fromString(sacManagerAddress).toScVal()],
                 TOKEN_ISSUER,
             );
-
             console.log('SAC admin set to SAC Manager');
         });
 
-        it('Verify redistribution is enabled at construction', async () => {
-            const { result: enabled } = await sacManagerClient.redistribution_enabled();
-            expect(enabled).toBe(true);
-            console.log('Redistribution enabled:', enabled);
+        it('Add DEFAULT_DEPLOYER as minter', async () => {
+            const assembledTx = await sacManagerClient.set_minter({
+                minter: DEFAULT_DEPLOYER.publicKey(),
+                active: true,
+            });
+            await assembledTx.signAndSend();
+            const { result: minters } = await sacManagerClient.minters();
+            expect(minters).toBeDefined();
+            expect(minters?.length).toBeGreaterThanOrEqual(1);
+            console.log('DEFAULT_DEPLOYER added as minter');
         });
 
         it('Verify owner (DEFAULT_DEPLOYER) starts with zero balance', async () => {
@@ -337,8 +305,7 @@ describe('SAC Manager Redistribution E2E Tests', async () => {
     // ========================================================================
 
     describe('Blacklist Management', () => {
-        it('Verify all accounts start authorized (AUTH_REQUIRED=false)', async () => {
-            // Check authorization status directly on the SAC
+        it('Verify all accounts start authorized', async () => {
             const userAAuthorized = await getTokenAuthorized(USER_A.publicKey(), sacTokenAddress);
             const userBAuthorized = await getTokenAuthorized(USER_B.publicKey(), sacTokenAddress);
             const userCAuthorized = await getTokenAuthorized(USER_C.publicKey(), sacTokenAddress);
@@ -346,22 +313,19 @@ describe('SAC Manager Redistribution E2E Tests', async () => {
             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 () => {
-            // Use DEFAULT_DEPLOYER (owner) to blacklist USER_B
             const assembledTx = await sacManagerClient.set_authorized({
                 id: USER_B.publicKey(),
                 authorize: false,
             });
-
             await assembledTx.signAndSend();
             console.log('USER_B blacklisted (authorized=false)');
         });
 
-        it('Verify USER_B is blacklisted (not authorized on SAC)', async () => {
+        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);
@@ -369,54 +333,31 @@ describe('SAC Manager Redistribution E2E Tests', async () => {
 
         it('Non-admin cannot call set_authorized', async () => {
             const userClient = createClientWithSigner(sacManagerAddress, USER_A);
-
             const assembledTx = await userClient.set_authorized({
                 id: USER_C.publicKey(),
                 authorize: false,
             });
-
             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 () => {
-            // Re-authorize USER_B
             const assembledTx = await sacManagerClient.set_authorized({
                 id: USER_B.publicKey(),
                 authorize: true,
             });
-
             await assembledTx.signAndSend();
-
-            // Verify
             const authorized = await getTokenAuthorized(USER_B.publicKey(), sacTokenAddress);
             expect(authorized).toBe(true);
-
-            const isAuthorized = await getTokenAuthorized(USER_B.publicKey(), sacTokenAddress);
-            expect(isAuthorized).toBe(true);
-
             console.log('USER_B un-blacklisted');
         });
-
-        it('Re-blacklist USER_B for mint redirection tests', async () => {
-            const assembledTx = await sacManagerClient.set_authorized({
-                id: USER_B.publicKey(),
-                authorize: false,
-            });
-
-            await assembledTx.signAndSend();
-
-            const isAuthorized = await getTokenAuthorized(USER_B.publicKey(), sacTokenAddress);
-            expect(isAuthorized).toBe(false);
-            console.log('USER_B re-blacklisted for transfer tests');
-        });
     });
 
     // ========================================================================
-    // Mint Redirection (redistribution enabled)
+    // Mint (Mintable interface – minter must be in minters list)
     // ========================================================================
 
-    describe('Mint Redirection', () => {
+    describe('Mint', () => {
         it('Verify initial balances', async () => {
             const userABalance = await getTokenBalance(USER_A.publicKey(), sacTokenAddress);
             const userBBalance = await getTokenBalance(USER_B.publicKey(), sacTokenAddress);
@@ -430,122 +371,38 @@ describe('SAC Manager Redistribution E2E Tests', async () => {
             console.log(`  USER_A: ${userABalance}`);
             console.log(`  USER_B: ${userBBalance}`);
             console.log(`  USER_C: ${userCBalance}`);
-            console.log(`  Owner (DEFAULT_DEPLOYER): ${ownerBalance}`);
+            console.log(`  Owner: ${ownerBalance}`);
 
-            expect(userABalance).toBe(10000000000n); // 1000 tokens
-            expect(userBBalance).toBe(10000000000n); // 1000 tokens
+            expect(userABalance).toBe(10000000000n);
+            expect(userBBalance).toBe(10000000000n);
             expect(userCBalance).toBe(0n);
             expect(ownerBalance).toBe(0n);
         });
 
-        it('Admin mint to non-blacklisted address succeeds normally', async () => {
+        it('Minter can mint to non-blacklisted address', async () => {
             const userCBalanceBefore = await getTokenBalance(USER_C.publicKey(), sacTokenAddress);
 
-            const assembledTx = await sacManagerClient.authorized_mint({
-                sender: DEFAULT_DEPLOYER.publicKey(),
+            const assembledTx = await sacManagerClient.mint({
                 to: USER_C.publicKey(),
-                amount: TRANSFER_AMOUNT,
+                amount: MINT_AMOUNT,
+                operation: DEFAULT_DEPLOYER.publicKey(),
             });
             await assembledTx.signAndSend();
 
-            // Verify balance increased
             const userCBalance = await getTokenBalance(USER_C.publicKey(), sacTokenAddress);
-
-            console.log('\nAfter authorized_mint to non-blacklisted (USER_C):');
-            console.log(`  USER_C: ${userCBalance}`);
-
-            expect(userCBalance).toBe(userCBalanceBefore + TRANSFER_AMOUNT);
-        });
-
-        it('Admin mint to blacklisted address redirects to redistribution target (owner)', async () => {
-            const ownerBalanceBefore = await getTokenBalance(
-                DEFAULT_DEPLOYER.publicKey(),
-                sacTokenAddress,
-            );
-            const userBBalanceBefore = await getTokenBalance(USER_B.publicKey(), sacTokenAddress);
-
-            const assembledTx = await sacManagerClient.authorized_mint({
-                sender: DEFAULT_DEPLOYER.publicKey(),
-                to: USER_B.publicKey(), // Blacklisted!
-                amount: TRANSFER_AMOUNT,
-            });
-            await assembledTx.signAndSend();
-
-            // Verify balances - USER_B should not receive, owner should
-            const userBBalance = await getTokenBalance(USER_B.publicKey(), sacTokenAddress);
-            const ownerBalance = await getTokenBalance(
-                DEFAULT_DEPLOYER.publicKey(),
-                sacTokenAddress,
-            );
-
-            console.log('\nAfter authorized_mint to blacklisted (USER_B):');
-            console.log(`  USER_B: ${userBBalance} (unchanged)`);
-            console.log(`  Owner (received redirected): ${ownerBalance}`);
-
-            // USER_B balance should be unchanged
-            expect(userBBalance).toBe(userBBalanceBefore);
-            // Owner should receive the redirected tokens
-            expect(ownerBalance).toBe(ownerBalanceBefore + TRANSFER_AMOUNT);
-        });
-    });
-
-    // ========================================================================
-    // Redistribute Funds
-    // ========================================================================
-
-    describe('Redistribute Funds', () => {
-        it('Redistribute funds from blacklisted account', async () => {
-            const ownerBalanceBefore = await getTokenBalance(
-                DEFAULT_DEPLOYER.publicKey(),
-                sacTokenAddress,
-            );
-            const userBBalanceBefore = await getTokenBalance(USER_B.publicKey(), sacTokenAddress);
-
-            console.log('\nBefore redistribute_blacklisted_funds:');
-            console.log(`  USER_B: ${userBBalanceBefore}`);
-            console.log(`  Owner: ${ownerBalanceBefore}`);
-
-            // Only owner can redistribute - use DEFAULT_DEPLOYER
-            const assembledTx = await sacManagerClient.redistribute_blacklisted_funds({
-                from: USER_B.publicKey(),
-                amount: REDISTRIBUTE_AMOUNT,
-            });
-            await assembledTx.signAndSend();
-
-            // Verify balances
-            const userBBalance = await getTokenBalance(USER_B.publicKey(), sacTokenAddress);
-            const ownerBalance = await getTokenBalance(
-                DEFAULT_DEPLOYER.publicKey(),
-                sacTokenAddress,
-            );
-
-            console.log('\nAfter redistribute_blacklisted_funds:');
-            console.log(`  USER_B: ${userBBalance}`);
-            console.log(`  Owner: ${ownerBalance}`);
-
-            expect(userBBalance).toBe(userBBalanceBefore - REDISTRIBUTE_AMOUNT);
-            expect(ownerBalance).toBe(ownerBalanceBefore + REDISTRIBUTE_AMOUNT);
-        });
-
-        it('Cannot redistribute from non-blacklisted account', async () => {
-            // USER_A is not blacklisted - this should fail even for owner
-            const assembledTx = await sacManagerClient.redistribute_blacklisted_funds({
-                from: USER_A.publicKey(),
-                amount: REDISTRIBUTE_AMOUNT,
-            });
-            await expect(assembledTx.signAndSend()).rejects.toThrow();
-            console.log('Correctly rejected redistribution from non-blacklisted account');
+            console.log('\nAfter mint to USER_C:', userCBalance);
+            expect(userCBalance).toBe(userCBalanceBefore + MINT_AMOUNT);
         });
 
-        it('Non-owner cannot redistribute', async () => {
-            // USER_A is not the owner - this should fail
+        it('Non-minter cannot mint', async () => {
             const userClient = createClientWithSigner(sacManagerAddress, USER_A);
-            const assembledTx = await userClient.redistribute_blacklisted_funds({
-                from: USER_B.publicKey(),
-                amount: REDISTRIBUTE_AMOUNT,
+            const assembledTx = await userClient.mint({
+                to: USER_C.publicKey(),
+                amount: MINT_AMOUNT,
+                operation: USER_A.publicKey(),
             });
             await expect(assembledTx.signAndSend()).rejects.toThrow();
-            console.log('Non-owner correctly rejected from redistributing');
+            console.log('Non-minter correctly rejected');
         });
     });
 
@@ -567,12 +424,11 @@ describe('SAC Manager Redistribution E2E Tests', async () => {
             console.log('Final Balance Summary');
             console.log('========================================');
             console.log(`  USER_A: ${userABalance}`);
-            console.log(`  USER_B (blacklisted): ${userBBalance}`);
+            console.log(`  USER_B: ${userBBalance}`);
             console.log(`  USER_C: ${userCBalance}`);
-            console.log(`  Owner (redistribution target): ${ownerBalance}`);
+            console.log(`  Owner: ${ownerBalance}`);
             console.log('========================================\n');
-
-            console.log('SAC Manager Redistribution E2E tests completed successfully!');
+            console.log('SAC Manager E2E tests completed successfully!');
         });
     });
 });