Collecting and burning

​

In the app

​

Collect from a position

1. Open Pools, then select the pool. Under Your Positions, the Position Funds column shows what each position holds for you. Hover the info icon next to the column name for what the total includes.
2. Select Collect in the position’s row, or Collect All below the table to collect from every position in the pool.
3. In Review collection, check the Receive amount for each asset and the position ID. Select Confirm.
4. In the Transaction request in Shield Wallet, check that the request is from swap.shield.fi and that the amounts match, then select Confirm.

​

Collect from Pending Claims

1. Open Portfolio, then select Pending Claims. Total recoverable shows the combined value.
2. Under Position Funds, find the position’s row. Select the info icon to open Position claim details, which shows the range and the position’s full ID.
3. Select Collect in the row, then follow the review and wallet steps above.

​

Close a position

​

Troubleshooting

​

Next steps

• Decreasing liquidity to remove funds or close a position.
• Rebalancing positions to move a position to a new range without collecting first.

​

Collect and burn

const positions = await client.getOwnedPositions()
const position = positions.find((p) => p.positionTokenId === POSITION_TOKEN_ID)
if (!position?.state) throw new Error("position not ready or not owned by this account")

const [token0, token1] = await Promise.all([
  client.tokenData(position.token0Id),
  client.tokenData(position.token1Id),
])

const amount0 = position.state.uncollectedFees0
const amount1 = position.state.uncollectedFees1
if (amount0 === 0n && amount1 === 0n) throw new Error("nothing to collect")

const imports = await client.resolveDexImports({
  tokenPrograms: [token0.ammTokenProgram!, token1.ammTokenProgram!],
})

const collected = await client.collect({
  poolKey: position.poolKey,
  positionTokenId: position.positionTokenId,
  amount0Requested: amount0,
  amount1Requested: amount1,
  imports,
})

console.log(`submitted ${collected.transactionId}`)
const refreshed = await waitForPosition(
  collected.transactionId, position.positionTokenId, position.record.tag,
)

if (refreshed.state.liquidity !== 0n ||
    refreshed.state.tokensOwed0 !== 0n || refreshed.state.tokensOwed1 !== 0n) {
  throw new Error("decrease all liquidity and collect the remaining balances before burning")
}
const burned = await client.burn({
  poolKey: refreshed.poolKey,
  positionTokenId: refreshed.positionTokenId,
  positionRecord: refreshed.record.recordPlaintext,
})
console.log(`submitted ${burned.transactionId}`)
await waitForTransaction(burned.transactionId)
console.log("burn accepted")

position = dex.get_owned_position(POSITION_TOKEN_ID)
if position is None:
    raise ValueError("position not ready or not owned by this account")

if position.state is None:
    state = read_position_state(position.position_token_id)
    if state["liquidity"] != 0:
        raise RuntimeError("live fee state unavailable; refresh before collecting")
    amount0, amount1 = state["tokens_owed0"], state["tokens_owed1"]
else:
    amount0, amount1 = position.state.collectible0, position.state.collectible1
if amount0 == 0 and amount1 == 0:
    raise ValueError("nothing to collect")

result = dex.collect(
    pool_key=position.pool_key,
    position_record=position.record,
    amount0_requested=amount0,
    amount1_requested=amount1,
).delegate(wait=True)

print(result.transaction_id)
refreshed = wait_for_position(position.position_token_id, position.record)

empty = refreshed
state = read_position_state(empty.position_token_id)
if state["liquidity"] or state["tokens_owed0"] or state["tokens_owed1"]:
    raise ValueError("decrease all liquidity and collect the remaining balances before burning")
result = dex.burn(pool_key=empty.pool_key, position_record=empty.record).delegate(wait=True)
print(result.transaction_id)

shield-swap collect --position POSITION_TOKEN_ID --network mainnet --execute

shield-swap collect --position POSITION_TOKEN_ID --close --network mainnet --execute

​

How it works on chain

​

What each operation changes

​

How a collect settles

1. The contract settles pending fees using the position’s current liquidity and fee growth inside its range.
2. It checks each requested base-unit amount against that token’s total owed balance, including the newly settled fees. A request above either total rejects the transaction.
3. It subtracts the payouts and advances the fee checkpoints. Any uncollected whole base units remain owed.

​

Close the position in order

1. Decrease all liquidity and wait for acceptance and the replacement PositionNFT.
2. Collect both owed balances and wait for acceptance and another replacement record.
3. Confirm that liquidity, tokens_owed0, and tokens_owed1 are all zero.
4. Burn using the latest record. The position is closed once the burn is accepted.

​

Next steps

• Decreasing liquidity to remove liquidity before a final collect and burn.
• Rebalancing positions to move a position to a new range in one transaction.