Add helper to update expired ledger entries

[chopan123]

Whenever a user deposit liquidity to a Soroswap Pool and doesn't interact in a while with it, the balance of shares of the pool for the user may expire, leading to DoS for the user.

Describe the solution you'd like
Just before removing liquidity, we would like to simulate the transaction and check if the ledger entry for the balance of the user has expired. If it fails due to ledger entry expiration, we should propose a new transaction that restores that ledger entry. If not, we should continue the current flow

Additional context

• Frontend place to include a different flow
• Example of restoration

Acceptance Critera

• Modular code, make a function specifically for this
• Propose a way to test it

[knownothing10]

Can I take this issue?

[OWK50GA]

Hi can I try this?

[Benjtalkshow]

Hi @chopan123
This is a frontend issue with a complex logic, I can handle this task. Kindly assign. Thanks

[wheval]

Can I work on this? Please assign.

[FrankiePower]

@chopan123

Hello, I am Super Franky, a frontend developer and alumni of Web3Bridge Africa, the premier blockchain developer community in Africa. I can confidently handle this task and this is how i will go about it:

My Understanding of the Problem:
The issue is that when a user deposits liquidity into a Soroswap Pool and doesn't interact for a while, their balance may expire due to the ledger entry for their pool shares. This could lead to a Denial of Service (DoS) for the user, as they won't be able to remove liquidity until the entry is restored.

Plan of Action:

1. Study the Code: Review the existing codebase and documentation to understand liquidity mechanics and ensure proper implementation.
2. Implement Transaction Simulation: Create a function to simulate the transaction and check for expired ledger entries. If expired, propose a restoration flow.
3. Update Frontend Flow: Modify the frontend to handle the restoration process and notify users accordingly.
4. Testing: Write tests to cover different scenarios (valid, expired, and restoration failure).

ETA: 1 Day

[Michaelkingsdev]

@chopan123
I have gone through the project and i understood the task properly.

To tackle the task of checking for expired ledger entries before removing liquidity and proposing a restoration transaction if necessary, here is what i will do:

1. I will simulate the transaction first. Before proceeding with the removal of liquidity, I will simulate the transaction to check if the ledger entry for the user's balance has expired. I will use the simulateTransaction function from the Soroban SDK to simulate the transaction and check for any errors related to ledger entry expiration.

2. If the simulation indicates that the ledger entry has expired, I will prepare a new transaction to restore the ledger entry, Construct the storage key for the expired balance using the xdr.ScVal.scvVecand xdr.LedgerKey.contractData methods.

3. I will restore the Ledger Entry by creating a new transaction using the createTransactionBuilder function, add an operation to restore the ledger entry using the Operation.restoreFootprint method from bridge/issue/index.tsx and
   set the Soroban data for the transaction using the SorobanDataBuilder and setReadWrite methods.

4. Then, I will send the restoration transaction using the sendTransaction function from Buttons/SwapButtonNew.
   If the restoration is successful, it will proceed with the original liquidity removal transaction.

5. I will modify the RemoveLiquidityComponent to include the new flow for checking and restoring expired ledger entries, add a new state variable to track whether the restoration transaction is needed and update the removeLiquidity function to include the simulation and restoration steps before proceeding with the original transaction.

6. Finally, I will handle errors and user feedback by providing appropriate feedback to the user if the restoration transaction is needed and executed and handling any errors that occur during the simulation or restoration process and inform the user accordingly.
   Thanks

[Dhanraj30]

I want to work on this

[davedumto]

Hi,
My name is David, and I am a frontend developer skilled in JavaScript, TypeScript, React.js, and Next.js. I will implement a modular function to simulate liquidity removal, detect expired ledger entries, and restore them if needed.
I’ll ensure seamless frontend integration and add tests to validate the flow. ETA: 1 day

[Amarjeet325]

Could I take on this issue?

[qgatssdev]

hey @chopan123 Can I take this? seems a bit straight forward.

[PrincesoDan]

I would like to take this issue.
Proposed Solution (Summary)

1. Transaction Simulation:

   • Validate if the CONTRACT_DATA entry for the user’s balance exists.
   • If expired, generate a transaction to restore it.
   • If it exists, proceed with the normal transaction flow.

2. Modularity:

   • Create a function to:
     • Check for the existence of CONTRACT_DATA.
     • Restore expired entries when necessary.
     • Enable easy testing and future integrations.

3. Testing:

   • Unit Tests: Validate detection of expired entries and their restoration.
   • Integration Tests: Simulate full scenarios with existing and expired entries.
   • Specific Proposal:
     • Hardcode an address instead of the commented one.
     • Execute the transaction with the connected address, without needing the private key of the wallet with the expired CONTRACT_DATA entry.

Steps (Summary)

1. Create a modular function to:
   • Validate CONTRACT_DATA.
   • Restore expired entries.
2. Integrate the function into the liquidity removal flow.
3. Design tests for:
   • Cases with existing entries.
   • Restoration of expired entries.
   • Using hardcoded addresses to validate the solution without a private key.

This approach ensures the system is reliable, modular, and prepared for future improvements.