Fix dlmm parser

consts.go

@@ -185,6 +185,7 @@ var mevAgentFeeAddresses = map[solana.PublicKey]string{
 	solana.MustPublicKeyFromBase58("soyascXFW5wEEYiwfEmHy2pNwomqzvggJosGVD6TJdY"):  MevAgentSoyas,
 	solana.MustPublicKeyFromBase58("soyasDBdKjADwPz3xk82U3TNPRDKEWJj7wWLajNHZ1L"):  MevAgentSoyas,
 	solana.MustPublicKeyFromBase58("soyasE2abjBAynmHbGWgEwk4ctBy7JMTUCNrMbjcnyH"):  MevAgentSoyas,
+	solana.MustPublicKeyFromBase58("soyasF3QPWPAKKmgA3GjfWax1kmTT1aoqSGxPzVLNUQ"):  MevAgentSoyas,
 	solana.MustPublicKeyFromBase58("ste11JV3MLMM7x7EJUM2sXcJC1H7F4jBLnP9a9PG8PH"):  MevAgentStellium,
 	solana.MustPublicKeyFromBase58("ste11MWPjXCRfQryCshzi86SGhuXjF4Lv6xMXD2AoSt"):  MevAgentStellium,
 	solana.MustPublicKeyFromBase58("ste11p5x8tJ53H1NbNQsRBg1YNRd4GcVpxtDw8PBpmb"):  MevAgentStellium,
@@ -209,6 +210,14 @@ var mevAgentFeeAddresses = map[solana.PublicKey]string{
 	solana.MustPublicKeyFromBase58("B1ooMauwuJPhHsXqt3uj7B92CAFG8kaD1Q2iGEmGYnx"):  MevAgentAstralane,
 	solana.MustPublicKeyFromBase58("B1ooMdjcY7zemxDWiH8jVZPxEMdHnE5AraWPHdHQoPj"):  MevAgentAstralane,
 	solana.MustPublicKeyFromBase58("B1ooMKzu6siJzQutP6a6oLiY3fpzgQnBZsAjxuAm9qo"):  MevAgentAstralane,
+	solana.MustPublicKeyFromBase58("AstrA1ejL4UeXC2SBP4cpeEmtcFPZVLxx3XGKXyCW6to"): MevAgentAstralane,
+	solana.MustPublicKeyFromBase58("AsTra79FET4aCKWspPqeSFvjJNyp96SvAnrmyAxqg5b7"): MevAgentAstralane,
+	solana.MustPublicKeyFromBase58("AsTRADtvb6tTmrsqULQ9Wji9PigDMjhfEMza6zkynEvV"): MevAgentAstralane,
+	solana.MustPublicKeyFromBase58("AsTRAEoyMofR3vUPpf9k68Gsfb6ymTZttEtsAbv8Bk4d"): MevAgentAstralane,
+	solana.MustPublicKeyFromBase58("AStrAJv2RN2hKCHxwUMtqmSxgdcNZbihCwc1mCSnG83W"): MevAgentAstralane,
+	solana.MustPublicKeyFromBase58("Astran35aiQUF57XZsmkWMtNCtXGLzs8upfiqXxth2bz"): MevAgentAstralane,
+	solana.MustPublicKeyFromBase58("AStRAnpi6kFrKypragExgeRoJ1QnKH7pbSjLAKQVWUum"): MevAgentAstralane,
+	solana.MustPublicKeyFromBase58("ASTRaoF93eYt73TYvwtsv6fMWHWbGmMUZfVZPo3CRU9C"): MevAgentAstralane,
 	solana.MustPublicKeyFromBase58("Gu2UGEfze3Gg5cHuEC4jGbyCufgpev75RkVvBdKKtf12"): MevAgentNozomi,
 	solana.MustPublicKeyFromBase58("E8wD3SMD1trozPrvSN9F6SyuUXD7rrFDuR3WexGziKG5"): MevAgent0slot,
 	solana.MustPublicKeyFromBase58("18hCV7f9CPmZRAH3QCNZaGHhHeNSfisQKeKuFkQsPLY"):  MevAgent0slot,
@@ -327,6 +336,51 @@ var mevAgentFeeAddresses = map[solana.PublicKey]string{
 	solana.MustPublicKeyFromBase58("bgH7YhymSykyvMa3nAZpzvrn73owJHU5iB75S1aiLT9"):  MevAgentNozomi,
 	solana.MustPublicKeyFromBase58("pfngGVVQLiVRFbLWw3Ektiv17ef9NiRZbcgdAhh4ZEW"):  MevAgentNozomi,
 	solana.MustPublicKeyFromBase58("nEFs3jph8HJt7honu3k7XtGUufMnwAvSXmXcKSPxryP"):  MevAgentNozomi,
+	solana.MustPublicKeyFromBase58("Fa1con11xLjPddfzRwRUB16sbFZggp2JeJkCeWREyR8X"): MevagentFa1con,
+	solana.MustPublicKeyFromBase58("Fa1con11TM1RuAQzbQzYjTy4Ekfap9Lnc9fnEbQYEd6Q"): MevagentFa1con,
+	solana.MustPublicKeyFromBase58("Fa1con113Bvi76nS5AzUiRDC2fqjfzkNMUNRLgQybMYt"): MevagentFa1con,
+	solana.MustPublicKeyFromBase58("Fa1con1QGHJK232s8yZpzZZwqPexnAKcoyKj626LNsMv"): MevagentFa1con,
+	solana.MustPublicKeyFromBase58("Fa1con1zUzb6qJVFz5tNkPq1Ahm8H1qKW7Q48252QbkQ"): MevagentFa1con,
+	solana.MustPublicKeyFromBase58("Fa1con16d3MSwd3SAiwvr2LwgkpE7ot8zntbpuec8HAx"): MevagentFa1con,
+	solana.MustPublicKeyFromBase58("Fa1con1i7mpa7Qc6epYJ6r4P9AbU77DFFz173r59Df1x"): MevagentFa1con,
+	solana.MustPublicKeyFromBase58("Fa1con18nWn8TdAGL7JX8PertfMUGVSc899NawokJ4Bq"): MevagentFa1con,
+	solana.MustPublicKeyFromBase58("Fa1con1GKusK2EqsfzrDzGPaYZSxQtFGzJiRMMU9Zm2g"): MevagentFa1con,
+	solana.MustPublicKeyFromBase58("Fa1con1RDwVwM9VrJ53CwVefD3VU9c58EMpDawV7fLMi"): MevagentFa1con,
+	solana.MustPublicKeyFromBase58("Sp1x2AqpQckPLaWnWCJUNg8k6qQexfaEWcSRKf5JcDV"):  MevagentBlocksprint,
+	solana.MustPublicKeyFromBase58("Sp4JHSh9cksfzXbgK7Pq2ovtn8LirLQydaJKTsiNT77"):  MevagentBlocksprint,
+	solana.MustPublicKeyFromBase58("Sp1xMS2cbw83SZDNr4AGqkBYYLjb3LvVnmDSrTMaHkr"):  MevagentBlocksprint,
+	solana.MustPublicKeyFromBase58("SpagSJmnh8E9cGT5Y431xPPaS2c1xLREGGCWN9yDeUf"):  MevagentBlocksprint,
+	solana.MustPublicKeyFromBase58("SpWrza9E63MQuHeGnnfzmtLVCs3pBdjyKPXUABPo9nq"):  MevagentBlocksprint,
+	solana.MustPublicKeyFromBase58("moon17L6BgxXRX5uHKudAmqVF96xia9h8ygcmG2sL3F"):  MevAgentMoon,
+	solana.MustPublicKeyFromBase58("moon26Sek222Md7ZydcAGxoKG832DK36CkLrS3PQY4c"):  MevAgentMoon,
+	solana.MustPublicKeyFromBase58("moon7fwyajcVstMoBnVy7UBcTx87SBtNoGGAaH2Cb8V"):  MevAgentMoon,
+	solana.MustPublicKeyFromBase58("moonBtH9HvLHjLqi9ivyrMVKgFUsSfrz9BwQ9khhn1u"):  MevAgentMoon,
+	solana.MustPublicKeyFromBase58("moonCJg8476LNFLptX1qrK8PdRsA1HD1R6XWyu9MB93"):  MevAgentMoon,
+	solana.MustPublicKeyFromBase58("moonF2sz7qwAtdETnrgxNbjonnhGGjd6r4W4UC9284s"):  MevAgentMoon,
+	solana.MustPublicKeyFromBase58("moonKfftMiGSak3cezvhEqvkPSzwrmQxQHXuspC96yj"):  MevAgentMoon,
+	solana.MustPublicKeyFromBase58("moonQBUKBpkifLcTd78bfxxt4PYLwmJ5admLW6cBBs8"):  MevAgentMoon,
+	solana.MustPublicKeyFromBase58("moonXwpKwoVkMegt5Bc776cSW793X1irL5hHV1vJ3JA"):  MevAgentMoon,
+	solana.MustPublicKeyFromBase58("moonZ6u9E2fgk6eWd82621eLPHt9zuJuYECXAYjMY1C"):  MevAgentMoon,
+	solana.MustPublicKeyFromBase58("SpEEdz8S1KorkMZqjMUxfxrmWwofmp6ReNP2Nx6CUmq"):  MevAgentSpeedlanding,
+	solana.MustPublicKeyFromBase58("SpeeDy3GJM4wcrQmk1itRFWgidvxX4rwjTLMv78wwjE"):  MevAgentSpeedlanding,
+	solana.MustPublicKeyFromBase58("SPeEdva37vW8vRtqgYjprQs1g3965icfVN5Rt7SMAyh"):  MevAgentSpeedlanding,
+	solana.MustPublicKeyFromBase58("speEdrSEpox5GUfHWcBc7tQjRuSfUin2yvB7qoYvvJh"):  MevAgentSpeedlanding,
+	solana.MustPublicKeyFromBase58("SPeEDmkHkN3A2roSZf6aZyEMsmrGqTHKqwP51y2Y4rV"):  MevAgentSpeedlanding,
+	solana.MustPublicKeyFromBase58("SpeedLdTJXh2RKpXEaP8JCxkWoUVXhtdPQ1EnxBJMxc"):  MevAgentSpeedlanding,
+	solana.MustPublicKeyFromBase58("SpEediGKLbbXndSYTzwmz6Z3NDgHQLDcTDEvGFkSMH9"):  MevAgentSpeedlanding,
+	solana.MustPublicKeyFromBase58("speede8xCcUq2Tiv1efXeTuE3k9TDNq8TnGKaKSc6J4"):  MevAgentSpeedlanding,
+	solana.MustPublicKeyFromBase58("harkEpXoJv5qVzHaN7HSuUAd6PHjyMcFMcDYBMDJCEQ"):  MevAgentAllenhark,
+	solana.MustPublicKeyFromBase58("harkm2BTWxZuszoNpZnfe84jRbQTg6KGHaQBmWzDGQQ"):  MevAgentAllenhark,
+	solana.MustPublicKeyFromBase58("harkR2YJ4Dpt4UDJTcBirjnSPBhNpQFcoFkNpCkVqNk"):  MevAgentAllenhark,
+	solana.MustPublicKeyFromBase58("t3QLYyXH4vZYbEifLqjD581t5dPVhq9LABxWceySzL2"):  MevAgentRaiden,
+	solana.MustPublicKeyFromBase58("t46SqGmwStEffUMp1fr2xmv5uyR85TB9annJuLKLf83"):  MevAgentRaiden,
+	solana.MustPublicKeyFromBase58("t1TcSg9biJsz4NjKjhopK8QZzPS4KzBgFSszu5QTGgF"):  MevAgentRaiden,
+	solana.MustPublicKeyFromBase58("t2XFAFBaUkCzxJwEbLWFX9PKFjfBCp2tSyFtx5z4RZM"):  MevAgentRaiden,
+	solana.MustPublicKeyFromBase58("t55hdzzftxWkYy3J8t32C9RRcZDuMZ4LDuBmbTzJFkU"):  MevAgentRaiden,
+	solana.MustPublicKeyFromBase58("t6UtTQLUGHJJrzxAb8PBBZdZKra8SWUqvTv9zPnxKNz"):  MevAgentRaiden,
+	solana.MustPublicKeyFromBase58("t7qUQU35sLpPydh42BcPmtEfTWW8gBe4Ry3gjwVnokJ"):  MevAgentRaiden,
+	solana.MustPublicKeyFromBase58("t8pPgarSK3TnuLbbHmoE1RCQdLxfxuPqNTyFjBKahok"):  MevAgentRaiden,
+	solana.MustPublicKeyFromBase58("t96GGdw3MiaGR993XN8PSsRpKGXx56t5Wf6zcF1hBpY"):  MevAgentRaiden,
 }
 
 var entryContractAddresses = map[solana.PublicKey]string{

enum.go

@@ -15,6 +15,12 @@ const (
 	MevAgentSoyas        = "soyas"
 	MevAgentStellium     = "stellium"
 	MevAgentAstralane    = "astralane"
+	MevagentFa1con       = "fa1con"
+	MevagentBlocksprint  = "blocksprint"
+	MevAgentMoon         = "moon"
+	MevAgentSpeedlanding = "speedlanding"
+	MevAgentAllenhark    = "allenhark"
+	MevAgentRaiden       = "raiden"
 )
 
 const (

meta.go

@@ -76,11 +76,19 @@ var (
 	meteoraDlmmSwapExactOut2Discriminator                = calculateDiscriminator("global:swap_exact_out2")
 	meteoraDlmmSwapWithPriceImpactDiscriminator          = calculateDiscriminator("global:swap_with_price_impact")
 	meteoraDlmmSwapWithPriceImpact2Discriminator         = calculateDiscriminator("global:swap_with_price_impact2")
+	meteoraDlmmInitializePositionDiscriminator           = calculateDiscriminator("global:initialize_position")
+	meteoraDlmmInitializePosition2Discriminator          = calculateDiscriminator("global:initialize_position2")
+	meteoraDlmmInitializePositionByOperatorDiscriminator = calculateDiscriminator("global:initialize_position_by_operator")
+	meteoraDlmmInitializePositionPdaDiscriminator        = calculateDiscriminator("global:initialize_position_pda")
+	meteoraDlmmClosePositionDiscriminator                = calculateDiscriminator("global:close_position")
+	meteoraDlmmClosePosition2Discriminator               = calculateDiscriminator("global:close_position2")
+	meteoraDlmmClosePositionIfEmptyDiscriminator         = calculateDiscriminator("global:close_position_if_empty")
 	meteoraDlmmSwapEventDiscriminator                    = calculateDiscriminator("event:Swap")
 	meteoraDlmmAddLiquidityDiscriminator                 = calculateDiscriminator("global:add_liquidity")
 	meteoraDlmmAddLiquidity2Discriminator                = calculateDiscriminator("global:add_liquidity2")
 	meteoraDlmmAddLiquidityByStrategyDiscriminator       = calculateDiscriminator("global:add_liquidity_by_strategy")
 	meteoraDlmmAddLiquidityByStrategy2Discriminator      = calculateDiscriminator("global:add_liquidity_by_strategy2")
+	meteoraDlmmAddLiquidityByWeightDiscriminator         = calculateDiscriminator("global:add_liquidity_by_weight")
 	meteoraDlmmClaimFeeDiscriminator                     = calculateDiscriminator("global:claim_fee")
 	meteoraDlmmClaimFee2Discriminator                    = calculateDiscriminator("global:claim_fee2")
 	meteoraDlmmRebalanceLiquidityDiscriminator           = calculateDiscriminator("global:rebalance_liquidity")
@@ -91,6 +99,8 @@ var (
 	meteoraDlmmAddLiquidityEventDiscriminator            = calculateDiscriminator("event:AddLiquidity")
 	meteoraDlmmClaimFeeEventDiscriminator                = calculateDiscriminator("event:ClaimFee")
 	meteoraDlmmClaimFee2EventDiscriminator               = calculateDiscriminator("event:ClaimFee2")
+	meteoraDlmmPositionCloseEventDiscriminator           = calculateDiscriminator("event:PositionClose")
+	meteoraDlmmPositionCreateEventDiscriminator          = calculateDiscriminator("event:PositionCreate")
 	meteoraDlmmRebalancingEventDiscriminator             = calculateDiscriminator("event:Rebalancing")
 	meteoraDlmmRemoveLiquidityEventDiscriminator         = calculateDiscriminator("event:RemoveLiquidity")
 )

metaoradlmm.go

@@ -55,6 +55,17 @@ type dlmmRemoveLiquidityEvent struct {
 	ActiveBinId int32
 }
 
+type dlmmPositionCreateEvent struct {
+	LbPair   solana.PublicKey
+	Position solana.PublicKey
+	Owner    solana.PublicKey
+}
+
+type dlmmPositionCloseEvent struct {
+	Position solana.PublicKey
+	Owner    solana.PublicKey
+}
+
 type dlmmClaimFeeInnerEvent struct {
 	LbPair       solana.PublicKey
 	Position     solana.PublicKey
@@ -106,6 +117,11 @@ type dlmmBinLiquidityDistribution struct {
 	DistributionY uint16
 }
 
+type dlmmBinLiquidityDistributionByWeight struct {
+	BinId  int32
+	Weight uint16
+}
+
 type dlmmBinLiquidityReduction struct {
 	BinId       int32
 	BpsToRemove uint16
@@ -132,6 +148,14 @@ type dlmmLiquidityParameterByStrategy struct {
 	StrategyParameters   dlmmStrategyParameters
 }
 
+type dlmmLiquidityParameterByWeight struct {
+	AmountX              uint64
+	AmountY              uint64
+	ActiveID             int32
+	MaxActiveBinSlippage int32
+	BinLiquidityDist     []dlmmBinLiquidityDistributionByWeight
+}
+
 type dlmmAddLiquidityArgs struct {
 	LiquidityParameter dlmmLiquidityParameter
 }
@@ -150,6 +174,10 @@ type dlmmAddLiquidityByStrategy2Args struct {
 	RemainingAccountsInfo dlmmRemainingAccountsInfo
 }
 
+type dlmmAddLiquidityByWeightArgs struct {
+	LiquidityParameter dlmmLiquidityParameterByWeight
+}
+
 type dlmmRemoveLiquidityArgs struct {
 	BinLiquidityRemoval []dlmmBinLiquidityReduction
 }
@@ -172,6 +200,18 @@ type dlmmRemoveLiquidityByRange2Args struct {
 	RemainingAccountsInfo dlmmRemainingAccountsInfo
 }
 
+type dlmmInitializePositionArgs struct {
+	LowerBinId int32
+	Width      int32
+}
+
+type dlmmInitializePositionByOperatorArgs struct {
+	LowerBinId       int32
+	Width            int32
+	FeeOwner         solana.PublicKey
+	LockReleasePoint uint64
+}
+
 type dlmmRemainingAccountsInfo struct{}
 
 func (dlmmRemainingAccountsInfo) UnmarshalWithDecoder(decoder *agbinary.Decoder) error {
@@ -245,12 +285,16 @@ func metaoradlmmParser(tx *Tx, instruction Instruction, innerInstructions InnerI
 	switch discriminator {
 	case meteoraInitializeLbPairDiscriminator:
 		return metaoradlmmInitializeParser(tx, instruction, innerInstructions, offset)
+	case meteoraDlmmInitializePositionDiscriminator, meteoraDlmmInitializePosition2Discriminator,
+		meteoraDlmmInitializePositionByOperatorDiscriminator, meteoraDlmmInitializePositionPdaDiscriminator:
+		return metaoradlmmPositionCreateParser(tx, instruction, innerInstructions, offset)
 	case meteoraDlmmSwapDiscriminator, meteoraDlmmSwapExactOutDiscriminator, meteoraDlmmSwapWithPriceImpactDiscriminator:
 		return metaoradlmmSwapParser(tx, instruction, innerInstructions, offset)
 	case meteoraDlmmSwap2Discriminator, meteoraDlmmSwapExactOut2Discriminator, meteoraDlmmSwapWithPriceImpact2Discriminator:
 		return metaoradlmmSwap2Parser(tx, instruction, innerInstructions, offset)
 	case meteoraDlmmAddLiquidityDiscriminator, meteoraDlmmAddLiquidity2Discriminator,
-		meteoraDlmmAddLiquidityByStrategyDiscriminator, meteoraDlmmAddLiquidityByStrategy2Discriminator:
+		meteoraDlmmAddLiquidityByStrategyDiscriminator, meteoraDlmmAddLiquidityByStrategy2Discriminator,
+		meteoraDlmmAddLiquidityByWeightDiscriminator:
 		return metaoradlmmAddLiquidityParser(tx, instruction, innerInstructions, offset)
 	case meteoraDlmmClaimFeeDiscriminator, meteoraDlmmClaimFee2Discriminator:
 		return metaoradlmmClaimFeeParser(tx, instruction, innerInstructions, offset)
@@ -259,6 +303,8 @@ func metaoradlmmParser(tx *Tx, instruction Instruction, innerInstructions InnerI
 	case meteoraDlmmRemoveLiquidityDiscriminator, meteoraDlmmRemoveLiquidity2Discriminator,
 		meteoraDlmmRemoveLiquidityByRangeDiscriminator, meteoraDlmmRemoveLiquidityByRange2Discriminator:
 		return metaoradlmmRemoveLiquidityParser(tx, instruction, innerInstructions, offset)
+	case meteoraDlmmClosePositionDiscriminator, meteoraDlmmClosePosition2Discriminator, meteoraDlmmClosePositionIfEmptyDiscriminator:
+		return metaoradlmmPositionCloseParser(tx, instruction, innerInstructions, offset)
 	default:
 		return nil, increaseOffset(offset), InstructionIgnoredError
 	}
@@ -315,6 +361,144 @@ func metaoradlmmInitializeParser(tx *Tx, instruction Instruction, innerInstructi
 	return []Swap{swap}, offset, nil
 }
 
+func metaoradlmmPositionCreateParser(tx *Tx, instruction Instruction, innerInstructions InnerInstructions, offset [2]uint) ([]Swap, [2]uint, error) {
+	result := tx.rawTx
+
+	entryContract := result.accountList[result.Transaction.Message.Instructions[offset[0]].ProgramIDIndex]
+	if instruction.StackHeight != nil && *instruction.StackHeight > 2 {
+		for _, innerInstr := range innerInstructions.Instructions {
+			if innerInstr.StackHeight != nil && *innerInstr.StackHeight == *instruction.StackHeight-1 {
+				entryContract = result.accountList[innerInstr.ProgramIDIndex]
+				break
+			}
+		}
+	}
+
+	decode := instruction.Data
+	if len(decode) < 8 {
+		offset[1] += 1
+		return nil, increaseOffset(offset), fmt.Errorf("meteora dlmm create position instruction data too short, offset, %d, %d", offset[0], offset[1])
+	}
+
+	discriminator := *(*[8]byte)(decode[:8])
+	var (
+		lowerBinId int32
+		width      int32
+	)
+
+	switch discriminator {
+	case meteoraDlmmInitializePositionDiscriminator, meteoraDlmmInitializePosition2Discriminator, meteoraDlmmInitializePositionPdaDiscriminator:
+		var args dlmmInitializePositionArgs
+		if err := agbinary.NewBorshDecoder(decode[8:]).Decode(&args); err != nil {
+			return nil, increaseOffset(offset), fmt.Errorf("meteora dlmm create position decode error: %v, offset, %d, %d", err, offset[0], offset[1])
+		}
+		lowerBinId = args.LowerBinId
+		width = args.Width
+	case meteoraDlmmInitializePositionByOperatorDiscriminator:
+		var args dlmmInitializePositionByOperatorArgs
+		if err := agbinary.NewBorshDecoder(decode[8:]).Decode(&args); err != nil {
+			return nil, increaseOffset(offset), fmt.Errorf("meteora dlmm create position by operator decode error: %v, offset, %d, %d", err, offset[0], offset[1])
+		}
+		lowerBinId = args.LowerBinId
+		width = args.Width
+	default:
+		return nil, increaseOffset(offset), InstructionIgnoredError
+	}
+
+	pool, positionAccount, eventUser, err := dlmmPositionCreateInstructionAccounts(result, discriminator, instruction.Accounts)
+	if err != nil {
+		return nil, increaseOffset(offset), fmt.Errorf("meteora dlmm create position accounts parse error: %v, offset, %d, %d", err, offset[0], offset[1])
+	}
+
+	createEvent, nextOffset, found, err := dlmmPositionCreateEventFromInnerInstructions(innerInstructions, instruction, offset)
+	if err != nil {
+		return nil, nextOffset, err
+	}
+	if !found {
+		return nil, nextOffset, InstructionIgnoredError
+	}
+	offset = nextOffset
+
+	if !createEvent.LbPair.IsZero() {
+		pool = createEvent.LbPair
+	}
+	if !createEvent.Position.IsZero() {
+		positionAccount = createEvent.Position
+	}
+	if !createEvent.Owner.IsZero() {
+		eventUser = createEvent.Owner
+	}
+
+	swap := Swap{
+		Program:         SolProgramMeteoraDLMM,
+		Event:           "open",
+		Pool:            pool,
+		User:            eventUser,
+		EntryContract:   entryContract,
+		StartBinId:      lowerBinId,
+		EndBinId:        dlmmPositionUpperBinId(lowerBinId, width),
+		PositionAccount: positionAccount,
+	}
+
+	return []Swap{swap}, offset, nil
+}
+
+func metaoradlmmPositionCloseParser(tx *Tx, instruction Instruction, innerInstructions InnerInstructions, offset [2]uint) ([]Swap, [2]uint, error) {
+	result := tx.rawTx
+
+	entryContract := result.accountList[result.Transaction.Message.Instructions[offset[0]].ProgramIDIndex]
+	if instruction.StackHeight != nil && *instruction.StackHeight > 2 {
+		for _, innerInstr := range innerInstructions.Instructions {
+			if innerInstr.StackHeight != nil && *innerInstr.StackHeight == *instruction.StackHeight-1 {
+				entryContract = result.accountList[innerInstr.ProgramIDIndex]
+				break
+			}
+		}
+	}
+
+	decode := instruction.Data
+	if len(decode) < 8 {
+		offset[1] += 1
+		return nil, increaseOffset(offset), fmt.Errorf("meteora dlmm close position instruction data too short, offset, %d, %d", offset[0], offset[1])
+	}
+
+	discriminator := *(*[8]byte)(decode[:8])
+	pool, positionAccount, eventUser, err := dlmmPositionCloseInstructionAccounts(result, discriminator, instruction.Accounts)
+	if err != nil {
+		return nil, increaseOffset(offset), fmt.Errorf("meteora dlmm close position accounts parse error: %v, offset, %d, %d", err, offset[0], offset[1])
+	}
+
+	closeEvent, nextOffset, found, err := dlmmPositionCloseEventFromInnerInstructions(innerInstructions, instruction, offset)
+	if err != nil {
+		return nil, nextOffset, err
+	}
+	if !found {
+		if discriminator == meteoraDlmmClosePositionIfEmptyDiscriminator {
+			return nil, nextOffset, InstructionIgnoredError
+		}
+		return nil, nextOffset, fmt.Errorf("meteora dlmm close position event not found, offset, %d, %d", nextOffset[0], nextOffset[1])
+	}
+	offset = nextOffset
+
+	if !closeEvent.Position.IsZero() {
+		positionAccount = closeEvent.Position
+	}
+	if !closeEvent.Owner.IsZero() {
+		eventUser = closeEvent.Owner
+	}
+
+	swap := Swap{
+		Program:         SolProgramMeteoraDLMM,
+		Event:           "close",
+		Pool:            pool,
+		User:            eventUser,
+		EntryContract:   entryContract,
+		PositionAccount: positionAccount,
+	}
+
+	return []Swap{swap}, offset, nil
+}
+
 func metaoradlmmSwapParser(tx *Tx, instruction Instruction, innerInstructions InnerInstructions, offset [2]uint) ([]Swap, [2]uint, error) {
 	result := tx.rawTx
 
@@ -542,6 +726,7 @@ func metaoradlmmAddLiquidityParser(tx *Tx, instruction Instruction, innerInstruc
 		amountX    uint64
 		amountY    uint64
 		binDist    []dlmmBinLiquidityDistribution
+		weightDist []dlmmBinLiquidityDistributionByWeight
 		startBinId int32
 		endBinId   int32
 		hasRange   bool
@@ -588,6 +773,16 @@ func metaoradlmmAddLiquidityParser(tx *Tx, instruction Instruction, innerInstruc
 		startBinId = args.LiquidityParameter.StrategyParameters.MinBinId
 		endBinId = args.LiquidityParameter.StrategyParameters.MaxBinId
 		hasRange = true
+	case meteoraDlmmAddLiquidityByWeightDiscriminator:
+		var args dlmmAddLiquidityByWeightArgs
+		if err := agbinary.NewBorshDecoder(decode[8:]).Decode(&args); err != nil {
+			return nil, increaseOffset(offset), fmt.Errorf("meteora dlmm add liquidity by weight decode error: %v, offset, %d, %d", err, offset[0], offset[1])
+		}
+		amountX = args.LiquidityParameter.AmountX
+		amountY = args.LiquidityParameter.AmountY
+		weightDist = args.LiquidityParameter.BinLiquidityDist
+		startBinId, endBinId = dlmmMinMaxBinIdFromWeightDistribution(weightDist)
+		hasRange = len(weightDist) > 0
 	default:
 		return nil, increaseOffset(offset), InstructionIgnoredError
 	}
@@ -608,6 +803,9 @@ func metaoradlmmAddLiquidityParser(tx *Tx, instruction Instruction, innerInstruc
 	binChanges := []DlmmBinLiquidityChange(nil)
 	if len(binDist) > 0 {
 		binChanges = dlmmBinChangesFromDistribution(amountX, amountY, binDist)
+	} else if len(weightDist) > 0 {
+		// Weight-only params do not preserve per-side amounts for each bin, so keep the affected range only.
+		binChanges = dlmmBinChangesFromRange(startBinId, endBinId, 0)
 	} else if hasRange {
 		binChanges = dlmmBinChangesFromRange(startBinId, endBinId, 0)
 	}
@@ -704,6 +902,7 @@ func metaoradlmmAddLiquidityParser(tx *Tx, instruction Instruction, innerInstruc
 		StartBinId:        startBinId,
 		EndBinId:          endBinId,
 		BinChanges:        binChanges,
+		PositionAccount:   result.accountList[accounts.positionIdx],
 	}
 
 	return []Swap{swap}, offset, nil
@@ -879,6 +1078,7 @@ func metaoradlmmRemoveLiquidityParser(tx *Tx, instruction Instruction, innerInst
 		EndBinId:          endBinId,
 		RemoveBp:          removeBp,
 		BinChanges:        binChanges,
+		PositionAccount:   result.accountList[accounts.positionIdx],
 	}
 
 	return []Swap{swap}, offset, nil
@@ -994,6 +1194,7 @@ func metaoradlmmClaimFeeParser(tx *Tx, instruction Instruction, innerInstruction
 		UserBaseBalance:   userBase,
 		UserQuoteBalance:  userQuote,
 		EntryContract:     entryContract,
+		PositionAccount:   result.accountList[accounts.positionIdx],
 	}
 	if claimEvent.HasActiveBin {
 		swap.ActiveBinId = claimEvent.ActiveBinId
@@ -1121,6 +1322,7 @@ func metaoradlmmRebalanceLiquidityParser(tx *Tx, instruction Instruction, innerI
 			StartBinId:        event.OldMinBinId,
 			EndBinId:          event.OldMaxBinId,
 			BinChanges:        dlmmBinChangesFromRange(event.OldMinBinId, event.OldMaxBinId, 0),
+			PositionAccount:   result.accountList[accounts.positionIdx],
 		})
 	}
 	if addBase > 0 || addQuote > 0 {
@@ -1146,6 +1348,7 @@ func metaoradlmmRebalanceLiquidityParser(tx *Tx, instruction Instruction, innerI
 			StartBinId:        event.NewMinBinId,
 			EndBinId:          event.NewMaxBinId,
 			BinChanges:        dlmmBinChangesFromRange(event.NewMinBinId, event.NewMaxBinId, 0),
+			PositionAccount:   result.accountList[accounts.positionIdx],
 		})
 	}
 	if len(swaps) == 0 {
@@ -1278,6 +1481,54 @@ func dlmmRebalancingEventFromInnerInstructions(innerInstructions InnerInstructio
 	return dlmmRebalancingEvent{}, increaseOffset(offset), fmt.Errorf("meteora dlmm rebalance liquidity event not found, offset, %d, %d", offset[0], prefixLen)
 }
 
+func dlmmPositionCreateEventFromInnerInstructions(innerInstructions InnerInstructions, instruction Instruction, offset [2]uint) (dlmmPositionCreateEvent, [2]uint, bool, error) {
+	var prefixLen = offset[1]
+	inners, err := getInnerInstructions(innerInstructions, prefixLen)
+	if err != nil {
+		return dlmmPositionCreateEvent{}, increaseOffset(offset), false, fmt.Errorf("meteora dlmm create position get inner instructions error: %v, offset, %d, %d", err, offset[0], prefixLen)
+	}
+	for innerIndex, innerInstr := range inners {
+		if innerInstr.ProgramIDIndex != instruction.ProgramIDIndex {
+			continue
+		}
+		event, ok := dlmmDecodePositionCreateEvent(innerInstr.Data)
+		if !ok {
+			continue
+		}
+		if offset[1] == 0 {
+			offset[0] += 1
+		} else {
+			offset[1] = uint(innerIndex) + 1 + prefixLen
+		}
+		return event, offset, true, nil
+	}
+	return dlmmPositionCreateEvent{}, increaseOffset(offset), false, nil
+}
+
+func dlmmPositionCloseEventFromInnerInstructions(innerInstructions InnerInstructions, instruction Instruction, offset [2]uint) (dlmmPositionCloseEvent, [2]uint, bool, error) {
+	var prefixLen = offset[1]
+	inners, err := getInnerInstructions(innerInstructions, prefixLen)
+	if err != nil {
+		return dlmmPositionCloseEvent{}, increaseOffset(offset), false, fmt.Errorf("meteora dlmm close position get inner instructions error: %v, offset, %d, %d", err, offset[0], prefixLen)
+	}
+	for innerIndex, innerInstr := range inners {
+		if innerInstr.ProgramIDIndex != instruction.ProgramIDIndex {
+			continue
+		}
+		event, ok := dlmmDecodePositionCloseEvent(innerInstr.Data)
+		if !ok {
+			continue
+		}
+		if offset[1] == 0 {
+			offset[0] += 1
+		} else {
+			offset[1] = uint(innerIndex) + 1 + prefixLen
+		}
+		return event, offset, true, nil
+	}
+	return dlmmPositionCloseEvent{}, increaseOffset(offset), false, nil
+}
+
 func dlmmDecodeAddLiquidityEvent(data []byte) (dlmmAddLiquidityEvent, bool) {
 	switch {
 	case len(data) >= 8 && bytes.Equal(data[:8], meteoraDlmmAddLiquidityEventDiscriminator[:]):
@@ -1320,6 +1571,48 @@ func dlmmDecodeRemoveLiquidityEvent(data []byte) (dlmmRemoveLiquidityEvent, bool
 	}
 }
 
+func dlmmDecodePositionCreateEvent(data []byte) (dlmmPositionCreateEvent, bool) {
+	switch {
+	case len(data) >= 8 && bytes.Equal(data[:8], meteoraDlmmPositionCreateEventDiscriminator[:]):
+		var event dlmmPositionCreateEvent
+		if err := agbinary.NewBorshDecoder(data[8:]).Decode(&event); err != nil {
+			return dlmmPositionCreateEvent{}, false
+		}
+		return event, true
+	case len(data) >= 16 &&
+		bytes.Equal(data[:8], eventDiscriminator[:]) &&
+		bytes.Equal(data[8:16], meteoraDlmmPositionCreateEventDiscriminator[:]):
+		var event dlmmPositionCreateEvent
+		if err := agbinary.NewBorshDecoder(data[16:]).Decode(&event); err != nil {
+			return dlmmPositionCreateEvent{}, false
+		}
+		return event, true
+	default:
+		return dlmmPositionCreateEvent{}, false
+	}
+}
+
+func dlmmDecodePositionCloseEvent(data []byte) (dlmmPositionCloseEvent, bool) {
+	switch {
+	case len(data) >= 8 && bytes.Equal(data[:8], meteoraDlmmPositionCloseEventDiscriminator[:]):
+		var event dlmmPositionCloseEvent
+		if err := agbinary.NewBorshDecoder(data[8:]).Decode(&event); err != nil {
+			return dlmmPositionCloseEvent{}, false
+		}
+		return event, true
+	case len(data) >= 16 &&
+		bytes.Equal(data[:8], eventDiscriminator[:]) &&
+		bytes.Equal(data[8:16], meteoraDlmmPositionCloseEventDiscriminator[:]):
+		var event dlmmPositionCloseEvent
+		if err := agbinary.NewBorshDecoder(data[16:]).Decode(&event); err != nil {
+			return dlmmPositionCloseEvent{}, false
+		}
+		return event, true
+	default:
+		return dlmmPositionCloseEvent{}, false
+	}
+}
+
 func dlmmDecodeClaimFeeEvent(data []byte) (dlmmClaimFeeInnerEvent, bool) {
 	switch {
 	case len(data) >= 16 &&
@@ -1378,6 +1671,40 @@ func dlmmDecodeRebalancingEvent(data []byte) (dlmmRebalancingEvent, bool) {
 	}
 }
 
+func dlmmPositionCreateInstructionAccounts(result *RawTx, discriminator [8]byte, accounts []int) (pool, position, owner solana.PublicKey, err error) {
+	switch discriminator {
+	case meteoraDlmmInitializePositionDiscriminator, meteoraDlmmInitializePosition2Discriminator:
+		if len(accounts) < 4 {
+			return solana.PublicKey{}, solana.PublicKey{}, solana.PublicKey{}, fmt.Errorf("accounts too short, expected at least 4")
+		}
+		return result.accountList[accounts[2]], result.accountList[accounts[1]], result.accountList[accounts[3]], nil
+	case meteoraDlmmInitializePositionByOperatorDiscriminator, meteoraDlmmInitializePositionPdaDiscriminator:
+		if len(accounts) < 5 {
+			return solana.PublicKey{}, solana.PublicKey{}, solana.PublicKey{}, fmt.Errorf("accounts too short, expected at least 5")
+		}
+		return result.accountList[accounts[3]], result.accountList[accounts[2]], result.accountList[accounts[4]], nil
+	default:
+		return solana.PublicKey{}, solana.PublicKey{}, solana.PublicKey{}, fmt.Errorf("unsupported create position discriminator")
+	}
+}
+
+func dlmmPositionCloseInstructionAccounts(result *RawTx, discriminator [8]byte, accounts []int) (pool, position, owner solana.PublicKey, err error) {
+	switch discriminator {
+	case meteoraDlmmClosePositionDiscriminator:
+		if len(accounts) < 5 {
+			return solana.PublicKey{}, solana.PublicKey{}, solana.PublicKey{}, fmt.Errorf("accounts too short, expected at least 5")
+		}
+		return result.accountList[accounts[1]], result.accountList[accounts[0]], result.accountList[accounts[4]], nil
+	case meteoraDlmmClosePosition2Discriminator, meteoraDlmmClosePositionIfEmptyDiscriminator:
+		if len(accounts) < 2 {
+			return solana.PublicKey{}, solana.PublicKey{}, solana.PublicKey{}, fmt.Errorf("accounts too short, expected at least 2")
+		}
+		return solana.PublicKey{}, result.accountList[accounts[0]], result.accountList[accounts[1]], nil
+	default:
+		return solana.PublicKey{}, solana.PublicKey{}, solana.PublicKey{}, fmt.Errorf("unsupported close position discriminator")
+	}
+}
+
 func resolveDlmmSwapAccounts(result *RawTx, accounts []int) (dlmmSwapAccounts, error) {
 	if len(accounts) < 13 {
 		return dlmmSwapAccounts{}, fmt.Errorf("accounts too short, expected at least 13")
@@ -1731,6 +2058,13 @@ func dlmmCommonRemoveBp(reduction []dlmmBinLiquidityReduction) int32 {
 	return int32(bpsToRemove)
 }
 
+func dlmmPositionUpperBinId(lowerBinId, width int32) int32 {
+	if width <= 0 {
+		return lowerBinId
+	}
+	return lowerBinId + width - 1
+}
+
 func dlmmMinMaxBinIdFromDistribution(dist []dlmmBinLiquidityDistribution) (int32, int32) {
 	if len(dist) == 0 {
 		return 0, 0
@@ -1748,6 +2082,23 @@ func dlmmMinMaxBinIdFromDistribution(dist []dlmmBinLiquidityDistribution) (int32
 	return min, max
 }
 
+func dlmmMinMaxBinIdFromWeightDistribution(dist []dlmmBinLiquidityDistributionByWeight) (int32, int32) {
+	if len(dist) == 0 {
+		return 0, 0
+	}
+	min := dist[0].BinId
+	max := dist[0].BinId
+	for _, item := range dist[1:] {
+		if item.BinId < min {
+			min = item.BinId
+		}
+		if item.BinId > max {
+			max = item.BinId
+		}
+	}
+	return min, max
+}
+
 func dlmmMinMaxBinIdFromReduction(reduction []dlmmBinLiquidityReduction) (int32, int32) {
 	if len(reduction) == 0 {
 		return 0, 0

tx.go

@@ -53,6 +53,7 @@ type Swap struct {
 	EndBinId    int32
 	RemoveBp    int32
 	BinChanges  []DlmmBinLiquidityChange
+	PositionAccount solana.PublicKey
 
 	ConsumeUnit uint64
 }