bath

var BidaskJettonSwapStraw = Straw[BubbleJettonSwap]{
	CheckFuncs: []bubbleCheck{IsJettonTransfer, func(bubble *Bubble) bool {
		jettonTx := bubble.Info.(BubbleJettonTransfer)
		swap, ok := jettonTx.payload.Value.(abi.BidaskSwapJettonPayload)
		if !ok {
			return false
		}
		if swap.ToAddress != jettonTx.sender.Address.ToMsgAddress() {
			return false
		}
		return true
	}},
	Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
		jettonTx := bubble.Info.(BubbleJettonTransfer)
		newAction.Dex = references.Bidask
		newAction.UserWallet = jettonTx.sender.Address
		newAction.Router = jettonTx.recipient.Address
		newAction.In.JettonMaster = jettonTx.master
		newAction.In.JettonWallet = jettonTx.senderWallet
		newAction.In.Amount = big.Int(jettonTx.amount)
		return nil
	},
	SingleChild: &Straw[BubbleJettonSwap]{
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.BidaskInternalSwapMsgOp), HasInterface(abi.BidaskRange)},
		SingleChild: &Straw[BubbleJettonSwap]{
			CheckFuncs: []bubbleCheck{
				IsTx,
				Or(HasOperation(abi.BidaskSwapSuccessMsgOp), HasOperation(abi.BidaskSwapSuccessV2MsgOp)),
				HasInterface(abi.BidaskPool),
			},
			SingleChild: &Straw[BubbleJettonSwap]{
				CheckFuncs: []bubbleCheck{IsJettonTransfer},
				Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
					jettonTx := bubble.Info.(BubbleJettonTransfer)
					newAction.Out.JettonMaster = jettonTx.master
					newAction.Out.JettonWallet = jettonTx.recipientWallet
					newAction.Out.Amount = big.Int(jettonTx.amount)
					newAction.Success = jettonTx.success
					return nil
				},
			},
		},
	},
}

var BidaskLiquidityDepositBothJettonStraw = Straw[BubbleLiquidityDeposit]{
	CheckFuncs: []bubbleCheck{},
	Children: []Straw[BubbleLiquidityDeposit]{
		{
			CheckFuncs: []bubbleCheck{IsJettonTransfer},
			Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
				jettonTx := bubble.Info.(BubbleJettonTransfer)
				newAction.Protocol = core.Protocol{
					Name:  string(references.Bidask),
					Image: &references.BidaskImage,
				}
				newAction.From = jettonTx.sender.Address
				depositJetton := core.VaultDepositInfo{
					Price: core.Price{
						Currency: core.Currency{
							Type:   core.CurrencyJetton,
							Jetton: &jettonTx.master,
						},
						Amount: big.Int(jettonTx.amount),
					},
					Vault: jettonTx.recipientWallet,
				}
				newAction.Tokens = append(newAction.Tokens, depositJetton)
				return nil
			},
			SingleChild: &Straw[BubbleLiquidityDeposit]{
				CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.BidaskInternalLiquidityVault)},
				SingleChild: &Straw[BubbleLiquidityDeposit]{
					CheckFuncs: []bubbleCheck{Is(BubbleContractDeploy{})},
					Optional:   true,
				},
			},
		},
		{
			CheckFuncs: []bubbleCheck{IsJettonTransfer},
			Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
				jettonTx := bubble.Info.(BubbleJettonTransfer)
				newAction.Protocol = core.Protocol{
					Name:  string(references.Bidask),
					Image: &references.BidaskImage,
				}
				newAction.From = jettonTx.sender.Address
				depositJetton := core.VaultDepositInfo{
					Price: core.Price{
						Currency: core.Currency{
							Type:   core.CurrencyJetton,
							Jetton: &jettonTx.master,
						},
						Amount: big.Int(jettonTx.amount),
					},
					Vault: jettonTx.recipientWallet,
				}
				newAction.Tokens = append(newAction.Tokens, depositJetton)
				return nil
			},
			SingleChild: &Straw[BubbleLiquidityDeposit]{
				CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.BidaskInternalLiquidityVault)},
				Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
					tx := bubble.Info.(BubbleTx)
					newAction.Success = tx.success
					return nil
				},
				SingleChild: &Straw[BubbleLiquidityDeposit]{
					CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.BidaskPool)},
					SingleChild: &Straw[BubbleLiquidityDeposit]{
						CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.BidaskRange)},
						SingleChild: &Straw[BubbleLiquidityDeposit]{
							CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.BidaskLpMultitoken)},
							Children: []Straw[BubbleLiquidityDeposit]{
								{
									CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.Wallet)},
									Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
										tx := bubble.Info.(BubbleTx)
										newAction.Success = tx.success
										return nil
									},
								},
								{
									CheckFuncs: []bubbleCheck{Is(BubbleContractDeploy{})},
								},
							},
						},
					},
				},
			},
		},
	},
}

var BidaskLiquidityDepositBothNativeStraw = Straw[BubbleLiquidityDeposit]{
	CheckFuncs: []bubbleCheck{IsJettonTransfer, JettonTransferOperation(abi.BidaskProvideBothJettonOp)},
	Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
		jettonTx := bubble.Info.(BubbleJettonTransfer)
		newAction.Protocol = core.Protocol{
			Name:  string(references.Bidask),
			Image: &references.BidaskImage,
		}
		newAction.From = jettonTx.sender.Address
		payload := jettonTx.payload.Value.(abi.BidaskProvideBothJettonPayload)
		tonAmount := new(big.Int)
		tonAmount.SetUint64(uint64(payload.TonAmount))
		depositTon := core.VaultDepositInfo{
			Price: core.Price{
				Currency: core.Currency{
					Type: core.CurrencyTON,
				},
				Amount: *tonAmount,
			},
			Vault: jettonTx.recipient.Address,
		}
		newAction.Tokens = append(newAction.Tokens, depositTon)
		depositJetton := core.VaultDepositInfo{
			Price: core.Price{
				Currency: core.Currency{
					Type:   core.CurrencyJetton,
					Jetton: &jettonTx.master,
				},
				Amount: big.Int(jettonTx.amount),
			},
			Vault: jettonTx.recipientWallet,
		}
		newAction.Tokens = append(newAction.Tokens, depositJetton)
		return nil
	},
	SingleChild: &Straw[BubbleLiquidityDeposit]{
		CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.BidaskRange)},
		Children: []Straw[BubbleLiquidityDeposit]{
			{
				CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.BidaskPool)},
				SingleChild: &Straw[BubbleLiquidityDeposit]{
					CheckFuncs: []bubbleCheck{IsJettonTransfer},
				},
				Optional: true,
			},
			{
				CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.BidaskLpMultitoken)},
				Children: []Straw[BubbleLiquidityDeposit]{
					{
						CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.Wallet)},
						Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
							tx := bubble.Info.(BubbleTx)
							newAction.Success = tx.success
							return nil
						},
					},
					{
						CheckFuncs: []bubbleCheck{Is(BubbleContractDeploy{})},
					},
				},
			},
		},
	},
}

var BidaskLiquidityDepositJettonStraw = Straw[BubbleLiquidityDeposit]{
	CheckFuncs: []bubbleCheck{IsJettonTransfer},
	Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
		jettonTx := bubble.Info.(BubbleJettonTransfer)
		newAction.Protocol = core.Protocol{
			Name:  string(references.Bidask),
			Image: &references.BidaskImage,
		}
		newAction.From = jettonTx.sender.Address
		depositJetton := core.VaultDepositInfo{
			Price: core.Price{
				Currency: core.Currency{
					Type:   core.CurrencyJetton,
					Jetton: &jettonTx.master,
				},
				Amount: big.Int(jettonTx.amount),
			},
			Vault: jettonTx.recipientWallet,
		}
		newAction.Tokens = append(newAction.Tokens, depositJetton)
		return nil
	},
	SingleChild: &Straw[BubbleLiquidityDeposit]{
		CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.BidaskRange)},
		Children: []Straw[BubbleLiquidityDeposit]{
			{
				CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.BidaskPool)},
				SingleChild: &Straw[BubbleLiquidityDeposit]{
					CheckFuncs: []bubbleCheck{IsJettonTransfer},
				},
				Optional: true,
			},
			{
				CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.BidaskLpMultitoken)},
				Children: []Straw[BubbleLiquidityDeposit]{
					{
						CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.Wallet)},
						Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
							tx := bubble.Info.(BubbleTx)
							newAction.Success = tx.success
							return nil
						},
					},
					{
						CheckFuncs: []bubbleCheck{Is(BubbleContractDeploy{})},
					},
				},
			},
		},
	},
}

var BidaskSwapStraw = Straw[BubbleJettonSwap]{
	CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.BidaskSwapMsgOp), HasInterface(abi.BidaskPool), func(bubble *Bubble) bool {
		tx := bubble.Info.(BubbleTx)
		return tx.decodedBody.Value.(abi.BidaskSwapMsgBody).ToAddress == tx.inputFrom.Address.ToMsgAddress()
	}},
	Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		newAction.Dex = references.Bidask
		newAction.UserWallet = tx.inputFrom.Address
		newAction.Router = tx.account.Address
		body := tx.decodedBody.Value.(abi.BidaskSwapMsgBody)
		newAction.In.Amount = *big.NewInt(int64(body.NativeAmount))
		newAction.In.IsTon = true
		return nil
	},
	SingleChild: &Straw[BubbleJettonSwap]{
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.BidaskInternalSwapMsgOp), HasInterface(abi.BidaskRange)},
		SingleChild: &Straw[BubbleJettonSwap]{
			CheckFuncs: []bubbleCheck{
				IsTx,
				Or(HasOperation(abi.BidaskSwapSuccessMsgOp), HasOperation(abi.BidaskSwapSuccessV2MsgOp)),
				HasInterface(abi.BidaskPool),
			},
			SingleChild: &Straw[BubbleJettonSwap]{
				CheckFuncs: []bubbleCheck{IsJettonTransfer},
				Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
					jettonTx := bubble.Info.(BubbleJettonTransfer)
					newAction.Out.JettonMaster = jettonTx.master
					newAction.Out.JettonWallet = jettonTx.recipientWallet
					newAction.Out.Amount = big.Int(jettonTx.amount)
					newAction.Success = jettonTx.success
					return nil
				},
			},
		},
	},
}

var BidaskSwapStrawReverse = Straw[BubbleJettonSwap]{
	CheckFuncs: []bubbleCheck{IsJettonTransfer, func(bubble *Bubble) bool {
		jettonTx := bubble.Info.(BubbleJettonTransfer)
		swap, ok := jettonTx.payload.Value.(abi.BidaskSwapJettonPayload)
		if !ok {
			return false
		}
		if swap.ToAddress != jettonTx.sender.Address.ToMsgAddress() {
			return false
		}
		return true
	}},
	Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
		jettonTx := bubble.Info.(BubbleJettonTransfer)
		newAction.Dex = references.Bidask
		newAction.UserWallet = jettonTx.sender.Address
		newAction.Router = jettonTx.recipient.Address
		newAction.In.JettonMaster = jettonTx.master
		newAction.In.JettonWallet = jettonTx.senderWallet
		newAction.In.Amount = big.Int(jettonTx.amount)
		return nil
	},
	SingleChild: &Straw[BubbleJettonSwap]{
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.BidaskInternalSwapMsgOp), HasInterface(abi.BidaskRange)},
		SingleChild: &Straw[BubbleJettonSwap]{
			CheckFuncs: []bubbleCheck{
				IsTx,
				Or(HasOperation(abi.BidaskSwapSuccessMsgOp), HasOperation(abi.BidaskSwapSuccessV2MsgOp)),
				HasInterface(abi.BidaskPool),
			},
			SingleChild: &Straw[BubbleJettonSwap]{
				CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.BidaskNativeTransferNotificationMsgOp)},
				Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
					tx := bubble.Info.(BubbleTx)
					newAction.Out.IsTon = true
					body, ok := tx.decodedBody.Value.(abi.BidaskNativeTransferNotificationMsgBody)
					if !ok {
						return fmt.Errorf("body is not a bidask native transfer notification")
					}
					newAction.Out.Amount = *big.NewInt(int64(body.NativeAmount))
					newAction.Success = tx.success
					return nil
				},
			},
		},
	},
}

var DNSRenewStraw = Straw[BubbleDnsItemRenew]{
	CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.DeleteDnsRecordMsgOp), HasInterface(abi.NftItem), func(bubble *Bubble) bool {
		return bubble.Info.(BubbleTx).decodedBody.Value.(abi.DeleteDnsRecordMsgBody).Key.Equal(tlb.Bits256{})
	}},
	Builder: func(newAction *BubbleDnsItemRenew, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		newAction.Renewer = tx.inputFrom.Address
		newAction.Item = tx.account.Address
		newAction.Success = tx.success
		return nil
	},
	SingleChild: &Straw[BubbleDnsItemRenew]{
		Optional:   true,
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.BounceMsgOp)},
	},
}

var DefaultStraws = []Merger{
	StrawFindAuctionBidFragmentSimple,
	GasRelayerStraw,
	NftTransferStraw,
	NftTransferNotifyStraw,
	StonfiV1PTONStraw,
	StonfiV2PTONStrawReverse,
	StonfiV2PTONStraw,
	JettonTransferClassicStraw,
	JettonTransferMinimalStraw,
	JettonBurnStraw,
	WtonMintStraw,
	NftPurchaseStraw,
	StonfiSwapStraw,
	StonfiSwapV2Straw,
	UniversalDedustStraw{},
	TgAuctionV1InitialBidStraw,
	StrawAuctionBigGetgems,
	StrawAuctionBuyGetgems,
	StrawAuctionBuyFragments,
	JettonMintFromMasterStraw,
	JettonMintStrawGovernance,
	InvoicePaymentStrawNative,
	InvoicePaymentStrawJetton,
	MegatonFiJettonSwap,
	UnSubscriptionBySubscriberStraw,
	UnSubscriptionByBeneficiaryOrExpiredStraw,
	SubscriptionDeployStraw,
	SubscriptionPaymentStraw,
	SubscriptionPaymentWithRequestFundsStraw,
	DepositLiquidStakeStraw,
	OldPendingWithdrawRequestLiquidStraw,
	PendingWithdrawRequestLiquidStraw,
	ElectionsDepositStakeStraw,
	ElectionsRecoverStakeStraw,
	DepositTFStakeStraw,
	WithdrawTFStakeRequestStraw,
	WithdrawStakeImmediatelyStraw,
	WithdrawLiquidStake,
	DNSRenewStraw,
	BidaskLiquidityDepositBothNativeStraw,
	BidaskLiquidityDepositBothJettonStraw,
	BidaskLiquidityDepositJettonStraw,
	StonfiLiquidityDepositSingle,
	StonfiLiquidityDepositBoth,
	DepositEthenaStakeStraw,
	WithdrawEthenaStakeRequestStraw,
	BidaskSwapStraw,
	BidaskSwapStrawReverse,
	BidaskJettonSwapStraw,
	MooncxSwapStraw,
	MooncxSwapStrawReverse,
	ToncoSwapStraw,
	ToncoDepositLiquiditySingleStraw,
	ToncoDepositLiquidityBothStraw,
	ToncoDepositLiquidityWithRefundStraw,
}

var DepositEthenaStakeStraw = Straw[BubbleDepositTokenStake]{
	CheckFuncs: []bubbleCheck{IsJettonTransfer, JettonRecipientAccount(references.EthenaPool)},
	Builder: func(newAction *BubbleDepositTokenStake, bubble *Bubble) error {
		tx := bubble.Info.(BubbleJettonTransfer)
		newAction.Staker = tx.sender.Address
		amount := big.Int(tx.amount)
		newAction.Protocol = core.Protocol{
			Name:  references.Ethena,
			Image: &references.EthenaImage,
		}
		newAction.StakeMeta = &core.Price{
			Currency: core.Currency{
				Type:   core.CurrencyJetton,
				Jetton: &tx.master,
			},
			Amount: amount,
		}
		return nil
	},
	SingleChild: &Straw[BubbleDepositTokenStake]{
		CheckFuncs: []bubbleCheck{Is(BubbleJettonMint{})},
		Builder: func(newAction *BubbleDepositTokenStake, bubble *Bubble) error {
			tx := bubble.Info.(BubbleJettonMint)
			newAction.Success = tx.success
			return nil
		},
	},
}

var DepositLiquidStakeStraw = Straw[BubbleDepositStake]{
	CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.TonstakePoolDepositMsgOp)},
	Builder: func(newAction *BubbleDepositStake, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		newAction.Pool = tx.account.Address
		newAction.Staker = tx.inputFrom.Address
		newAction.Amount = tx.inputAmount - int64(ton.OneTON)
		if newAction.Amount < 0 {
			newAction.Amount = 0
		}
		newAction.Success = tx.success
		newAction.Implementation = core.StakingImplementationLiquidTF
		return nil
	},
	SingleChild: &Straw[BubbleDepositStake]{
		CheckFuncs: []bubbleCheck{IsBounced},
		Optional:   true,
	},
}

var DepositTFStakeStraw = Straw[BubbleDepositStake]{
	CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.TvPool), HasTextComment("d")},
	Builder: func(newAction *BubbleDepositStake, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		newAction.Pool = tx.account.Address
		newAction.Staker = tx.inputFrom.Address
		newAction.Amount = tx.inputAmount
		newAction.Success = tx.success
		newAction.Implementation = core.StakingImplementationTF
		return nil
	},
	SingleChild: &Straw[BubbleDepositStake]{
		CheckFuncs: []bubbleCheck{IsBounced},
		Optional:   true,
	},
}

var ElectionsDepositStakeStraw = Straw[BubbleElectionsDepositStake]{
	CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.ElectorNewStakeMsgOp), IsAccount(config.ElectorAddress())},
	Builder: func(newAction *BubbleElectionsDepositStake, bubble *Bubble) error {
		bubbleTx := bubble.Info.(BubbleTx)
		newAction.Amount = bubbleTx.inputAmount
		newAction.Staker = bubbleTx.inputFrom.Address
		return nil
	},
	Children: []Straw[BubbleElectionsDepositStake]{
		{
			CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.ElectorNewStakeConfirmationMsgOp)},
			Builder: func(newAction *BubbleElectionsDepositStake, bubble *Bubble) error {
				newAction.Success = true
				return nil
			},
		},
	},
}

var ElectionsRecoverStakeStraw = Straw[BubbleElectionsRecoverStake]{
	CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.ElectorRecoverStakeRequestMsgOp), IsAccount(config.ElectorAddress())},
	Builder: func(newAction *BubbleElectionsRecoverStake, bubble *Bubble) error {
		bubbleTx := bubble.Info.(BubbleTx)
		newAction.Staker = bubbleTx.inputFrom.Address
		return nil
	},
	Children: []Straw[BubbleElectionsRecoverStake]{
		{
			CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.ElectorRecoverStakeResponseMsgOp)},
			Builder: func(newAction *BubbleElectionsRecoverStake, bubble *Bubble) error {
				newAction.Amount = bubble.Info.(BubbleTx).inputAmount
				newAction.Success = true
				return nil
			},
		},
	},
}

var GasRelayerStraw = Straw[GasRelayBubble]{
	CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.WalletSignedInternalV5R1MsgOp), HasInterface(abi.WalletV5R1), func(bubble *Bubble) bool {
		tx := bubble.Info.(BubbleTx)
		return tx.inputFrom != nil && slices.Contains(knownRelayers, tx.inputFrom.Address)
	}},
	Builder: func(newAction *GasRelayBubble, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		newAction.Relayer = tx.inputFrom.Address
		newAction.Target = tx.account.Address
		newAction.Amount = tx.inputAmount
		return nil
	},
}

var InvoicePaymentStrawJetton = Straw[BubbleInvoicePayment]{
	CheckFuncs: []bubbleCheck{func(bubble *Bubble) bool {
		jettonTx, ok := bubble.Info.(BubbleJettonTransfer)
		if !ok {
			return false
		}
		if jettonTx.sender == nil || jettonTx.recipient == nil {
			return false
		}
		if jettonTx.payload.SumType != abi.InvoicePayloadJettonOp {
			return false
		}
		return true
	}},
	Builder: func(newAction *BubbleInvoicePayment, bubble *Bubble) error {
		jettonTx := bubble.Info.(BubbleJettonTransfer)

		invoicePayload := jettonTx.payload.Value.(abi.InvoicePayloadJettonPayload)
		id, err := uuid.FromBytes(invoicePayload.Id[:])
		if err != nil {
			return err
		}
		newAction.InvoiceID = id
		newAction.Price = core.Price{
			Currency: core.Currency{
				Type:   core.CurrencyJetton,
				Jetton: &jettonTx.master,
			},
			Amount: big.Int(jettonTx.amount),
		}

		newAction.Sender = jettonTx.sender.Address
		newAction.Recipient = jettonTx.recipient.Address
		newAction.Success = jettonTx.success
		return nil
	},
}

var InvoicePaymentStrawNative = Straw[BubbleInvoicePayment]{
	CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.InvoicePayloadMsgOp), AmountInterval(1, 1<<62)},
	Builder: func(newAction *BubbleInvoicePayment, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		invoicePayload := tx.decodedBody.Value.(abi.InvoicePayloadMsgBody)
		id, err := uuid.FromBytes(invoicePayload.Id[:])
		if err != nil {
			return err
		}
		newAction.InvoiceID = id
		price := core.Price{
			Currency: core.Currency{Type: core.CurrencyTON},
			Amount:   *big.NewInt(tx.inputAmount),
		}
		for c, am := range tx.inputExtraAmount {
			price.Currency = core.Currency{
				Type:       core.CurrencyExtra,
				CurrencyID: &c,
			}
			price.Amount = big.Int(am)
			break
		}
		if tx.inputFrom == nil {
			return errors.New("empty input")
		}
		newAction.Sender = tx.inputFrom.Address
		newAction.Recipient = tx.account.Address
		newAction.Price = price
		newAction.Success = tx.success
		return nil
	},
}

var JettonBurnStraw = Straw[BubbleJettonBurn]{
	CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.JettonBurnMsgOp)},
	Builder: func(newAction *BubbleJettonBurn, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		msg := tx.decodedBody.Value.(abi.JettonBurnMsgBody)
		newAction.amount = msg.Amount
		if tx.inputFrom != nil {
			newAction.sender = *tx.inputFrom
		}
		if tx.additionalInfo != nil {
			if master, ok := tx.additionalInfo.JettonMaster(tx.account.Address); ok {

				newAction.master = master
			}
		}
		newAction.senderWallet = tx.account.Address
		newAction.success = tx.success
		return nil
	},
	SingleChild: &Straw[BubbleJettonBurn]{
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.JettonBurnNotificationMsgOp)},
		Builder: func(newAction *BubbleJettonBurn, bubble *Bubble) error {
			newAction.master = bubble.Info.(BubbleTx).account.Address
			return nil
		},
		ValueFlowUpdater: func(newAction *BubbleJettonBurn, flow *ValueFlow) {
			if newAction.success {
				flow.SubJettons(newAction.sender.Address, newAction.master, big.Int(newAction.amount))
			}
		},
		Optional: true,
	},
}

var JettonMintFromMasterStraw = Straw[BubbleJettonMint]{
	CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.JettonInternalTransferMsgOp), HasInterface(abi.JettonWallet), func(bubble *Bubble) bool {
		tx := bubble.Info.(BubbleTx)
		return tx.inputFrom != nil && tx.inputFrom.Is(abi.JettonMaster)
	}},

	Builder: func(newAction *BubbleJettonMint, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		msg := tx.decodedBody.Value.(abi.JettonInternalTransferMsgBody)
		newAction.amount = msg.Amount
		newAction.master = tx.inputFrom.Address
		newAction.recipientWallet = tx.account.Address
		newAction.success = tx.success
		return nil
	},
	Children: []Straw[BubbleJettonMint]{
		{
			CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.JettonNotifyMsgOp)},
			Builder: func(newAction *BubbleJettonMint, bubble *Bubble) error {
				tx := bubble.Info.(BubbleTx)
				newAction.recipient = tx.account
				return nil
			},
			ValueFlowUpdater: func(newAction *BubbleJettonMint, flow *ValueFlow) {
				if newAction.success {
					flow.AddJettons(newAction.recipient.Address, newAction.master, big.Int(newAction.amount))
				}
			},
		},
		{CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.ExcessMsgOp)}, Optional: true},
	},
}

var JettonMintStrawGovernance = Straw[BubbleJettonMint]{
	CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.JettonMintMsgOp), HasInterface(abi.JettonMaster)},
	Builder: func(newAction *BubbleJettonMint, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		msg := tx.decodedBody.Value.(abi.JettonMintMsgBody)
		dest, err := tongo.AccountIDFromTlb(msg.ToAddress)
		if err == nil && dest != nil {
			newAction.recipient = Account{Address: *dest}
		}
		return nil
	},
	SingleChild: &Straw[BubbleJettonMint]{
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.JettonInternalTransferMsgOp), HasInterface(abi.JettonWallet)},
		Builder: func(newAction *BubbleJettonMint, bubble *Bubble) error {
			tx := bubble.Info.(BubbleTx)
			msg := tx.decodedBody.Value.(abi.JettonInternalTransferMsgBody)
			newAction.amount = msg.Amount
			newAction.recipientWallet = tx.account.Address
			newAction.master = tx.inputFrom.Address
			newAction.success = tx.success
			return nil
		},
		SingleChild: &Straw[BubbleJettonMint]{
			Optional:   true,
			CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.ExcessMsgOp)},
		},
	},
}

var JettonTransferClassicStraw = Straw[BubbleJettonTransfer]{
	CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.JettonWallet), HasOperation(abi.JettonTransferMsgOp)},
	Builder: func(newAction *BubbleJettonTransfer, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		newAction.master, _ = tx.additionalInfo.JettonMaster(tx.account.Address)
		newAction.senderWallet = tx.account.Address
		newAction.sender = tx.inputFrom
		body := tx.decodedBody.Value.(abi.JettonTransferMsgBody)
		newAction.amount = body.Amount
		newAction.payload = body.ForwardPayload.Value
		recipient, err := ton.AccountIDFromTlb(body.Destination)
		if err == nil && recipient != nil {
			newAction.recipient = &Account{Address: *recipient}
			bubble.Accounts = append(bubble.Accounts, *recipient)
		}
		return nil
	},
	SingleChild: &Straw[BubbleJettonTransfer]{
		CheckFuncs: []bubbleCheck{IsTx, Or(HasInterface(abi.JettonWallet), HasOperation(abi.JettonInternalTransferMsgOp))},
		Optional:   true,
		Builder: func(newAction *BubbleJettonTransfer, bubble *Bubble) error {
			tx := bubble.Info.(BubbleTx)
			newAction.recipientWallet = tx.account.Address
			if newAction.master.IsZero() {
				newAction.master, _ = tx.additionalInfo.JettonMaster(tx.account.Address)
			}
			newAction.success = tx.success
			return nil
		},
		ValueFlowUpdater: func(newAction *BubbleJettonTransfer, flow *ValueFlow) {
			if newAction.success {
				if newAction.recipient != nil {
					flow.AddJettons(newAction.recipient.Address, newAction.master, big.Int(newAction.amount))
				}
				if newAction.sender != nil {
					flow.SubJettons(newAction.sender.Address, newAction.master, big.Int(newAction.amount))
				}
			}
		},
		Children: []Straw[BubbleJettonTransfer]{
			{
				CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.JettonNotifyMsgOp)},
				Builder: func(newAction *BubbleJettonTransfer, bubble *Bubble) error {
					tx := bubble.Info.(BubbleTx)
					newAction.success = true
					body := tx.decodedBody.Value.(abi.JettonNotifyMsgBody)
					newAction.amount = body.Amount
					newAction.payload = body.ForwardPayload.Value
					newAction.recipient = &tx.account
					if newAction.sender == nil {
						sender, err := ton.AccountIDFromTlb(body.Sender)
						if err == nil {
							newAction.sender = &Account{Address: *sender}
						}
					}
					return nil
				},
				ValueFlowUpdater: func(newAction *BubbleJettonTransfer, flow *ValueFlow) {
					if newAction.recipient != nil {
						flow.AddJettons(newAction.recipient.Address, newAction.master, big.Int(newAction.amount))
					}
					if newAction.sender != nil {
						flow.SubJettons(newAction.sender.Address, newAction.master, big.Int(newAction.amount))
					}
				},
				Optional: true,
			},
			{
				CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.ExcessMsgOp)},
				Optional:   true,
			},
		},
	},
}

var JettonTransferMinimalStraw = Straw[BubbleJettonTransfer]{
	CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.JettonWallet), HasOpcode(abi.JettonTransferMsgOpCode)},
	Builder: func(newAction *BubbleJettonTransfer, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		newAction.master, _ = tx.additionalInfo.JettonMaster(tx.account.Address)
		newAction.senderWallet = tx.account.Address
		newAction.sender = tx.inputFrom
		return nil
	},
	SingleChild: &Straw[BubbleJettonTransfer]{
		CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.JettonWallet), HasOperation(abi.JettonInternalTransferMsgOp)},
		Optional:   true,
		Builder: func(newAction *BubbleJettonTransfer, bubble *Bubble) error {
			tx := bubble.Info.(BubbleTx)
			newAction.recipientWallet = tx.account.Address
			if newAction.master.IsZero() {
				newAction.master, _ = tx.additionalInfo.JettonMaster(tx.account.Address)
			}
			newAction.success = tx.success
			body, _ := tx.decodedBody.Value.(abi.JettonInternalTransferMsgBody)
			newAction.amount = body.Amount
			return nil
		},
		ValueFlowUpdater: func(newAction *BubbleJettonTransfer, flow *ValueFlow) {
			if newAction.success {
				if newAction.recipient != nil {
					flow.AddJettons(newAction.recipient.Address, newAction.master, big.Int(newAction.amount))
				}
				if newAction.sender != nil {
					flow.SubJettons(newAction.sender.Address, newAction.master, big.Int(newAction.amount))
				}
			}
		},
		Children: []Straw[BubbleJettonTransfer]{
			{
				CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.JettonNotifyMsgOp)},
				Builder: func(newAction *BubbleJettonTransfer, bubble *Bubble) error {
					tx := bubble.Info.(BubbleTx)
					newAction.success = true
					body := tx.decodedBody.Value.(abi.JettonNotifyMsgBody)
					newAction.amount = body.Amount
					newAction.payload = body.ForwardPayload.Value
					newAction.recipient = &tx.account
					if newAction.sender == nil {
						sender, err := ton.AccountIDFromTlb(body.Sender)
						if err == nil {
							newAction.sender = &Account{Address: *sender}
						}
					}
					return nil
				},
				ValueFlowUpdater: func(newAction *BubbleJettonTransfer, flow *ValueFlow) {
					if newAction.recipient != nil {
						flow.AddJettons(newAction.recipient.Address, newAction.master, big.Int(newAction.amount))
					}
					if newAction.sender != nil {
						flow.SubJettons(newAction.sender.Address, newAction.master, big.Int(newAction.amount))
					}
				},
				Optional: true,
			},
			{
				CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.ExcessMsgOp)},
				Optional:   true,
			},
		},
	},
}

var JettonTransfersBurnsMints = []Merger{
	StonfiV1PTONStraw,
	StonfiV2PTONStrawReverse,
	StonfiV2PTONStraw,
	JettonTransferClassicStraw,
	JettonTransferMinimalStraw,
	JettonBurnStraw,
	JettonMintFromMasterStraw,
	JettonMintStrawGovernance,
	WtonMintStraw,
}

var MegatonFiJettonSwap = Straw[BubbleJettonSwap]{
	CheckFuncs: []bubbleCheck{IsJettonTransfer, IsJettonReceiver(abi.MegatonfiRouter)},
	Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
		tx := bubble.Info.(BubbleJettonTransfer)
		newAction.UserWallet = tx.sender.Address
		newAction.In.Amount = big.Int(tx.amount)
		newAction.In.IsTon = tx.isWrappedTon
		newAction.Router = tx.recipient.Address
		newAction.In.JettonWallet = tx.senderWallet
		newAction.In.JettonMaster = tx.master
		newAction.Dex = references.Megatonfi
		return nil
	},
	Children: []Straw[BubbleJettonSwap]{
		{
			CheckFuncs: []bubbleCheck{IsJettonTransfer, IsJettonReceiver(abi.MegatonfiExchange)},
			Children: []Straw[BubbleJettonSwap]{
				{
					CheckFuncs: []bubbleCheck{IsJettonTransfer, IsJettonReceiver(abi.MegatonfiRouter)},
					Children: []Straw[BubbleJettonSwap]{
						{
							CheckFuncs: []bubbleCheck{IsJettonTransfer},
							Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
								tx := bubble.Info.(BubbleJettonTransfer)
								newAction.Success = tx.success
								newAction.Out.Amount = big.Int(tx.amount)
								newAction.Out.IsTon = tx.isWrappedTon
								newAction.Out.JettonWallet = tx.recipientWallet
								newAction.Out.JettonMaster = tx.master
								return nil
							},
						},
					},
				},
			},
		},
	},
}

var MooncxSwapStraw = Straw[BubbleJettonSwap]{
	CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.MoonSwapMsgOp), HasInterface(abi.MoonPool), func(bubble *Bubble) bool {
		tx, ok := bubble.Info.(BubbleTx)
		if !ok {
			return false
		}
		swap, ok := tx.decodedBody.Value.(abi.MoonSwapMsgBody)
		if !ok {
			return false
		}
		if swap.SwapParams.NextFulfill != nil && swap.SwapParams.NextFulfill.Recipient != tx.inputFrom.Address.ToMsgAddress() {
			return false
		}
		return true
	}},
	Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		newAction.Dex = references.Mooncx
		newAction.UserWallet = tx.inputFrom.Address
		newAction.Router = tx.account.Address
		body := tx.decodedBody.Value.(abi.MoonSwapMsgBody)
		amount := big.Int(body.Amount)
		newAction.In.Amount = amount
		newAction.In.IsTon = true
		return nil
	},
	SingleChild: &Straw[BubbleJettonSwap]{
		CheckFuncs: []bubbleCheck{IsJettonTransfer},
		Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
			tx := bubble.Info.(BubbleJettonTransfer)
			newAction.Out.JettonMaster = tx.master
			newAction.Out.JettonWallet = tx.recipientWallet
			amount := big.Int(tx.amount)
			newAction.Out.Amount = amount
			newAction.Success = tx.success
			return nil
		},
	},
}

var MooncxSwapStrawReverse = Straw[BubbleJettonSwap]{
	CheckFuncs: []bubbleCheck{func(bubble *Bubble) bool {
		tx, ok := bubble.Info.(BubbleJettonTransfer)
		if !ok {
			return false
		}
		swap, ok := tx.payload.Value.(abi.MoonSwapJettonPayload)
		if !ok {
			return false
		}
		if swap.SwapParams.NextFulfill != nil && swap.SwapParams.NextFulfill.Recipient != tx.sender.Address.ToMsgAddress() {
			return false
		}
		return true
	}},
	Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
		tx := bubble.Info.(BubbleJettonTransfer)
		newAction.Dex = references.Mooncx
		newAction.UserWallet = tx.sender.Address
		newAction.Router = tx.recipient.Address
		newAction.In.JettonMaster = tx.master
		newAction.In.JettonWallet = tx.senderWallet
		amount := big.Int(tx.amount)
		newAction.In.Amount = amount
		body := tx.payload.Value.(abi.MoonSwapJettonPayload)
		newAction.Out.Amount = big.Int(body.SwapParams.MinOut)
		newAction.Out.IsTon = true
		return nil
	},
	SingleChild: &Straw[BubbleJettonSwap]{
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.MoonSwapSucceedMsgOp)},
		Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
			tx := bubble.Info.(BubbleTx)
			newAction.Success = tx.success
			return nil
		},
	},
}

var NFTStraws = []Merger{
	NftTransferStraw,
	NftTransferNotifyStraw,
}

var NftPurchaseStraw = Straw[BubbleNftPurchase]{
	CheckFuncs: []bubbleCheck{
		IsTx,
		Or(HasInterface(abi.NftSaleV2), HasInterface(abi.NftSaleV1)),
		HasEmptyBody,
		AmountInterval(1, 1<<62),
		func(bubble *Bubble) bool {
			tx := bubble.Info.(BubbleTx)
			return tx.additionalInfo != nil && tx.additionalInfo.NftSaleContract != nil && tx.additionalInfo.NftSaleContract.Owner != nil
		}},
	Builder: func(newAction *BubbleNftPurchase, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		sale := tx.additionalInfo.NftSaleContract
		newAction.Seller = *sale.Owner
		newAction.AuctionType = GetGemsAuction
		newAction.Buyer = tx.inputFrom.Address
		newAction.Price = sale.NftPrice
		if tx.additionalInfo.NftSaleContract != nil {
			newAction.Nft = tx.additionalInfo.NftSaleContract.Item
		}
		return nil
	},
	SingleChild: &Straw[BubbleNftPurchase]{
		CheckFuncs: []bubbleCheck{IsNftTransfer},
		Builder: func(newAction *BubbleNftPurchase, bubble *Bubble) error {
			newAction.Success = bubble.Info.(BubbleNftTransfer).success
			newAction.Nft = bubble.Info.(BubbleNftTransfer).account.Address
			return nil
		},
		Optional: true,
	},
}

var NftTransferNotifyStraw = Straw[BubbleNftTransfer]{
	CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.NftItem)},
	Builder: func(newAction *BubbleNftTransfer, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		if tx.inputFrom != nil {
			newAction.sender = tx.inputFrom
		}
		return nil
	},
	Children: []Straw[BubbleNftTransfer]{
		{
			CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.NftOwnershipAssignedMsgOp)},
			Builder: func(newAction *BubbleNftTransfer, bubble *Bubble) error {
				receiverTx := bubble.Info.(BubbleTx)
				transfer := receiverTx.decodedBody.Value.(abi.NftOwnershipAssignedMsgBody)
				newAction.success = true
				if receiverTx.inputFrom == nil {
					return fmt.Errorf("nft transfer notify without sender")
				}
				newAction.account = *receiverTx.inputFrom
				newAction.recipient = &receiverTx.account
				newAction.payload = transfer.ForwardPayload.Value
				return nil
			},
		},
		{
			CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.ExcessMsgOp)},
			Optional:   true,
		},
	},
}

var NftTransferStraw = Straw[BubbleNftTransfer]{
	CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.NftTransferMsgOp), HasInterface(abi.NftItem)},
	Builder: func(newAction *BubbleNftTransfer, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		transfer := tx.decodedBody.Value.(abi.NftTransferMsgBody)
		newAction.account = tx.account
		newAction.success = tx.success
		newAction.sender = tx.inputFrom
		newAction.payload = transfer.ForwardPayload.Value
		if newAction.recipient == nil {
			newAction.recipient = parseAccount(transfer.NewOwner)
			if newAction.recipient != nil {
				bubble.Accounts = append(bubble.Accounts, newAction.recipient.Address)
			}
		}
		return nil
	},
	Children: []Straw[BubbleNftTransfer]{
		{
			CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.NftOwnershipAssignedMsgOp)},
			Optional:   true,
			Builder: func(newAction *BubbleNftTransfer, bubble *Bubble) error {
				receiverTx := bubble.Info.(BubbleTx)
				transfer := receiverTx.decodedBody.Value.(abi.NftOwnershipAssignedMsgBody)
				newAction.success = true
				newAction.payload = transfer.ForwardPayload.Value
				return nil
			},
		},
		{
			CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.ExcessMsgOp)},
			Optional:   true,
		},
	},
}

var OldPendingWithdrawRequestLiquidStraw = Straw[BubbleWithdrawStakeRequest]{
	CheckFuncs: []bubbleCheck{Is(BubbleJettonBurn{})},
	Builder: func(newAction *BubbleWithdrawStakeRequest, bubble *Bubble) error {
		newAction.Staker = bubble.Info.(BubbleJettonBurn).sender.Address
		newAction.Success = true
		newAction.Implementation = core.StakingImplementationLiquidTF
		amount := big.Int(bubble.Info.(BubbleJettonBurn).amount)
		i := amount.Int64()
		newAction.Amount = &i
		return nil
	},
	SingleChild: &Straw[BubbleWithdrawStakeRequest]{
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.TonstakePoolWithdrawMsgOp)},
		Builder: func(newAction *BubbleWithdrawStakeRequest, bubble *Bubble) error {
			newAction.Pool = bubble.Info.(BubbleTx).account.Address
			newAction.Success = true
			newAction.attachedAmount = bubble.Info.(BubbleTx).inputAmount
			return nil
		},
		SingleChild: &Straw[BubbleWithdrawStakeRequest]{
			CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.TonstakePayoutMintJettonsMsgOp)},
			SingleChild: &Straw[BubbleWithdrawStakeRequest]{
				CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.TonstakeNftInitMsgOp)},
				SingleChild: &Straw[BubbleWithdrawStakeRequest]{
					CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.NftOwnershipAssignedMsgOp)},
					Builder: func(newAction *BubbleWithdrawStakeRequest, bubble *Bubble) error {
						newAction.Success = true
						return nil
					},
				},
			},
		},
	},
}

var PendingWithdrawRequestLiquidStraw = Straw[BubbleWithdrawStakeRequest]{
	CheckFuncs: []bubbleCheck{Is(BubbleJettonBurn{})},
	Builder: func(newAction *BubbleWithdrawStakeRequest, bubble *Bubble) error {
		newAction.Staker = bubble.Info.(BubbleJettonBurn).sender.Address
		newAction.Success = true
		newAction.Implementation = core.StakingImplementationLiquidTF
		amount := big.Int(bubble.Info.(BubbleJettonBurn).amount)
		i := amount.Int64()
		newAction.Amount = &i
		return nil
	},
	SingleChild: &Straw[BubbleWithdrawStakeRequest]{
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.TonstakePoolWithdrawMsgOp)},
		Builder: func(newAction *BubbleWithdrawStakeRequest, bubble *Bubble) error {
			newAction.Pool = bubble.Info.(BubbleTx).account.Address
			newAction.Success = true
			newAction.attachedAmount = bubble.Info.(BubbleTx).inputAmount
			return nil
		},
		SingleChild: &Straw[BubbleWithdrawStakeRequest]{
			CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.TonstakePayoutMintJettonsMsgOp)},
			SingleChild: &Straw[BubbleWithdrawStakeRequest]{
				CheckFuncs: []bubbleCheck{Is(BubbleNftTransfer{})},
				Builder: func(newAction *BubbleWithdrawStakeRequest, bubble *Bubble) error {
					newAction.Success = true
					return nil
				},
			},
		},
	},
}

var StonfiLiquidityDepositBoth = Straw[BubbleLiquidityDeposit]{
	CheckFuncs: []bubbleCheck{},
	Children: []Straw[BubbleLiquidityDeposit]{
		{
			CheckFuncs: []bubbleCheck{func(bubble *Bubble) bool {
				tx, ok := bubble.Info.(BubbleLiquidityDeposit)
				if !ok {
					return false
				}
				if tx.Protocol.Name != string(references.Stonfi) {
					return false
				}
				return true
			}},
			Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
				tx := bubble.Info.(BubbleLiquidityDeposit)
				newAction.Protocol = tx.Protocol
				newAction.From = tx.From
				newAction.Tokens = append(newAction.Tokens, tx.Tokens...)
				return nil
			},
			Children: []Straw[BubbleLiquidityDeposit]{},
		},
		{
			CheckFuncs: []bubbleCheck{IsJettonTransfer},
			Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
				jettonTx := bubble.Info.(BubbleJettonTransfer)
				if jettonTx.isWrappedTon {
					newAction.Tokens = append(newAction.Tokens, core.VaultDepositInfo{
						Price: core.Price{
							Currency: core.Currency{
								Type: core.CurrencyTON,
							},
							Amount: big.Int(jettonTx.amount),
						},
						Vault: jettonTx.recipient.Address,
					})
				} else {
					newAction.Tokens = append(newAction.Tokens, core.VaultDepositInfo{
						Price: core.Price{
							Currency: core.Currency{
								Type:   core.CurrencyJetton,
								Jetton: &jettonTx.master,
							},
							Amount: big.Int(jettonTx.amount),
						},
						Vault: jettonTx.recipientWallet,
					})
				}
				return nil
			},
			SingleChild: &Straw[BubbleLiquidityDeposit]{
				CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.StonfiProvideLpV2MsgOp), HasInterface(abi.StonfiPoolV2)},
				SingleChild: &Straw[BubbleLiquidityDeposit]{
					CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.StonfiAddLiquidityV2MsgOp)},
					Children: []Straw[BubbleLiquidityDeposit]{
						{
							CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.ExcessMsgOp)},
							Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
								tx := bubble.Info.(BubbleTx)
								newAction.Success = tx.success
								return nil
							},
						},
						{
							Optional:   true,
							CheckFuncs: []bubbleCheck{Is(BubbleContractDeploy{})},
						},
					},
				},
			},
		},
	},
}

var StonfiLiquidityDepositSingle = Straw[BubbleLiquidityDeposit]{
	CheckFuncs: []bubbleCheck{IsJettonTransfer, func(bubble *Bubble) bool {
		tx := bubble.Info.(BubbleJettonTransfer)
		body, ok := tx.payload.Value.(abi.StonfiProvideLpV2JettonPayload)
		if !ok {
			return false
		}
		if body.CrossProvideLpBody.ToAddress != tx.sender.Address.ToMsgAddress() {
			return false
		}
		_, ok = references.StonfiWhitelistVaults[tx.recipient.Address]
		if !ok {
			return false
		}
		return true
	}},
	Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
		jettonTx := bubble.Info.(BubbleJettonTransfer)
		newAction.Protocol = core.Protocol{
			Name:  string(references.Stonfi),
			Image: &references.StonfiImage,
		}
		newAction.From = jettonTx.sender.Address
		if jettonTx.isWrappedTon {
			newAction.Tokens = append(newAction.Tokens, core.VaultDepositInfo{
				Price: core.Price{
					Currency: core.Currency{
						Type: core.CurrencyTON,
					},
					Amount: big.Int(jettonTx.amount),
				},
				Vault: jettonTx.recipient.Address,
			})
		} else {
			newAction.Tokens = append(newAction.Tokens, core.VaultDepositInfo{
				Price: core.Price{
					Currency: core.Currency{
						Type:   core.CurrencyJetton,
						Jetton: &jettonTx.master,
					},
					Amount: big.Int(jettonTx.amount),
				},
				Vault: jettonTx.recipientWallet,
			})
		}
		return nil
	},
	SingleChild: &Straw[BubbleLiquidityDeposit]{
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.StonfiProvideLpV2MsgOp), HasInterface(abi.StonfiPoolV2)},
		SingleChild: &Straw[BubbleLiquidityDeposit]{
			CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.StonfiAddLiquidityV2MsgOp)},
			Children: []Straw[BubbleLiquidityDeposit]{
				{
					CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.StonfiCbAddLiquidityV2MsgOp), HasInterface(abi.StonfiPoolV2)},
					Children: []Straw[BubbleLiquidityDeposit]{
						{
							Optional:   true,
							CheckFuncs: []bubbleCheck{Is(BubbleJettonMint{})},
							SingleChild: &Straw[BubbleLiquidityDeposit]{
								CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.NftItem)},
								Children: []Straw[BubbleLiquidityDeposit]{
									{
										CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.ExcessMsgOp)},
										Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
											tx := bubble.Info.(BubbleTx)
											newAction.Success = tx.success
											return nil
										},
									},
									{
										Optional:   true,
										CheckFuncs: []bubbleCheck{Is(BubbleContractDeploy{})},
									},
								},
							},
						},
						{
							Optional:   true,
							CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.JettonInternalTransferMsgOp)},
							SingleChild: &Straw[BubbleLiquidityDeposit]{
								CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.ExcessMsgOp)},
								Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
									tx := bubble.Info.(BubbleTx)
									newAction.Success = tx.success
									return nil
								},
							},
						},
					},
				},
				{
					Optional:   true,
					CheckFuncs: []bubbleCheck{Is(BubbleContractDeploy{})},
				},
			},
		},
	},
}

var StonfiSwapStraw = Straw[BubbleJettonSwap]{
	CheckFuncs: []bubbleCheck{func(bubble *Bubble) bool {
		jettonTx, ok := bubble.Info.(BubbleJettonTransfer)
		if !ok {
			return false
		}
		if jettonTx.sender == nil {
			return false
		}
		if jettonTx.payload.SumType != abi.StonfiSwapJettonOp {
			return false
		}
		swap, ok := jettonTx.payload.Value.(abi.StonfiSwapJettonPayload)
		if !ok {
			return false
		}
		to, err := ton.AccountIDFromTlb(swap.ToAddress)
		if err != nil || to == nil {
			return false
		}
		if jettonTx.sender.Address != *to {
			return false
		}
		return true
	}},
	Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
		newAction.Dex = references.Stonfi
		jettonTx := bubble.Info.(BubbleJettonTransfer)
		newAction.UserWallet = jettonTx.sender.Address
		newAction.In.Amount = big.Int(jettonTx.amount)
		newAction.In.IsTon = jettonTx.isWrappedTon
		newAction.In.JettonMaster = jettonTx.master
		return nil
	},
	SingleChild: &Straw[BubbleJettonSwap]{
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.StonfiSwapMsgOp), HasInterface(abi.StonfiPool)},
		Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
			tx := bubble.Info.(BubbleTx)
			a, b := tx.additionalInfo.STONfiPool.Token0, tx.additionalInfo.STONfiPool.Token1
			body := tx.decodedBody.Value.(abi.StonfiSwapMsgBody)
			newAction.Out.Amount = big.Int(body.MinOut)
			s, err := tongo.AccountIDFromTlb(body.SenderAddress)
			if err != nil {
				return err
			}
			if s != nil && *s == b {
				a, b = b, a
			}
			newAction.In.JettonWallet = a
			newAction.Out.JettonWallet = b
			if tx.additionalInfo != nil {
				newAction.In.JettonMaster, _ = tx.additionalInfo.JettonMaster(a)
				newAction.Out.JettonMaster, _ = tx.additionalInfo.JettonMaster(b)
			}
			return nil
		},
		SingleChild: &Straw[BubbleJettonSwap]{
			CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.StonfiPaymentRequestMsgOp)},
			Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
				tx := bubble.Info.(BubbleTx)
				newAction.Router = tx.account.Address
				return nil
			},
			SingleChild: &Straw[BubbleJettonSwap]{
				CheckFuncs: []bubbleCheck{Is(BubbleJettonTransfer{}), Or(JettonTransferOperation(abi.StonfiSwapOkJettonOp), JettonTransferOpCode(0x5ffe1295))},
				Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
					jettonTx := bubble.Info.(BubbleJettonTransfer)
					if jettonTx.senderWallet != newAction.Out.JettonWallet {

						return nil
					}
					newAction.Out.Amount = big.Int(jettonTx.amount)
					newAction.Out.IsTon = jettonTx.isWrappedTon
					newAction.Success = true
					return nil
				},
			},
		},
	},
}

var StonfiSwapV2Straw = Straw[BubbleJettonSwap]{
	CheckFuncs: []bubbleCheck{func(bubble *Bubble) bool {
		jettonTx, ok := bubble.Info.(BubbleJettonTransfer)
		if !ok {
			return false
		}
		if jettonTx.sender == nil {
			return false
		}
		if jettonTx.payload.SumType != abi.StonfiSwapV2JettonOp {
			return false
		}
		swap, ok := jettonTx.payload.Value.(abi.StonfiSwapV2JettonPayload)
		if !ok {
			return false
		}
		to, err := ton.AccountIDFromTlb(swap.CrossSwapBody.Receiver)
		if err != nil || to == nil {
			return false
		}
		if jettonTx.sender.Address != *to {
			return false
		}
		return true
	}},
	Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
		newAction.Dex = references.Stonfi
		jettonTx := bubble.Info.(BubbleJettonTransfer)
		newAction.UserWallet = jettonTx.sender.Address
		newAction.In.Amount = big.Int(jettonTx.amount)
		newAction.In.IsTon = jettonTx.isWrappedTon
		newAction.In.JettonMaster = jettonTx.master
		return nil
	},
	SingleChild: &Straw[BubbleJettonSwap]{
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.StonfiSwapV2MsgOp), HasInterface(abi.StonfiPoolV2), func(bubble *Bubble) bool {
			tx, ok := bubble.Info.(BubbleTx)
			if !ok {
				return false
			}
			if tx.additionalInfo.STONfiPool == nil {
				return false
			}
			return true
		}},
		Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
			tx := bubble.Info.(BubbleTx)
			a, b := tx.additionalInfo.STONfiPool.Token0, tx.additionalInfo.STONfiPool.Token1
			body := tx.decodedBody.Value.(abi.StonfiSwapV2MsgBody)
			if body.QueryId > 0 && a.IsZero() && b.IsZero() {
				return nil
			}
			s, err := tongo.AccountIDFromTlb(body.DexPayload.TokenWallet1)
			if err != nil {
				return err
			}
			if s != nil && *s == a {
				a, b = b, a
			}
			newAction.In.JettonWallet = a
			newAction.Out.JettonWallet = b
			if tx.additionalInfo != nil {
				newAction.In.JettonMaster, _ = tx.additionalInfo.JettonMaster(a)
				newAction.Out.JettonMaster, _ = tx.additionalInfo.JettonMaster(b)
			}
			return nil
		},
		Children: []Straw[BubbleJettonSwap]{
			{
				CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.StonfiPayToV2MsgOp)},
				Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
					tx := bubble.Info.(BubbleTx)
					newAction.Router = tx.account.Address
					return nil
				},
				SingleChild: &Straw[BubbleJettonSwap]{
					CheckFuncs: []bubbleCheck{Is(BubbleJettonTransfer{})},
					Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
						jettonTx := bubble.Info.(BubbleJettonTransfer)
						if jettonTx.senderWallet != newAction.Out.JettonWallet {

							return nil
						}
						newAction.Out.Amount = big.Int(jettonTx.amount)
						newAction.Out.IsTon = jettonTx.isWrappedTon
						newAction.Success = true
						return nil
					},
				},
			},
			{
				CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.StonfiPayVaultV2MsgOp)},
				Optional:   true,
				SingleChild: &Straw[BubbleJettonSwap]{
					CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.StonfiDepositRefFeeV2MsgOp)},
					SingleChild: &Straw[BubbleJettonSwap]{
						CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.ExcessMsgOp)},
						Optional:   true,
					},
				},
			},
		},
	},
}

var StonfiV1PTONStraw = Straw[BubbleJettonTransfer]{
	CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.JettonWallet), HasOperation(abi.JettonTransferMsgOp)},
	Builder: func(newAction *BubbleJettonTransfer, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		newAction.master, _ = tx.additionalInfo.JettonMaster(tx.account.Address)
		newAction.senderWallet = tx.account.Address
		newAction.sender = tx.inputFrom
		body := tx.decodedBody.Value.(abi.JettonTransferMsgBody)
		newAction.amount = body.Amount
		newAction.isWrappedTon = true
		recipient, err := ton.AccountIDFromTlb(body.Destination)
		if err == nil && recipient != nil {
			newAction.recipient = &Account{Address: *recipient}
			bubble.Accounts = append(bubble.Accounts, *recipient)
		}
		return nil
	},
	SingleChild: &Straw[BubbleJettonTransfer]{
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.JettonNotifyMsgOp)},
		Builder: func(newAction *BubbleJettonTransfer, bubble *Bubble) error {
			tx := bubble.Info.(BubbleTx)
			newAction.success = true
			body := tx.decodedBody.Value.(abi.JettonNotifyMsgBody)
			newAction.amount = body.Amount
			newAction.payload = body.ForwardPayload.Value
			newAction.recipient = &tx.account
			return nil
		},
	},
}

var StonfiV2PTONStraw = Straw[BubbleJettonTransfer]{
	CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.JettonWallet), HasOperation(abi.PtonTonTransferMsgOp)},
	Builder: func(newAction *BubbleJettonTransfer, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		newAction.master, _ = tx.additionalInfo.JettonMaster(tx.account.Address)
		newAction.senderWallet = tx.account.Address
		newAction.sender = tx.inputFrom
		body := tx.decodedBody.Value.(abi.PtonTonTransferMsgBody)
		newAction.amount = tlb.VarUInteger16(*big.NewInt(int64(body.TonAmount)))
		newAction.isWrappedTon = true
		recipient, err := ton.AccountIDFromTlb(body.RefundAddress)
		if err == nil {
			newAction.recipient = &Account{Address: *recipient}
		}
		return nil
	},
	SingleChild: &Straw[BubbleJettonTransfer]{
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.JettonNotifyMsgOp)},
		Builder: func(newAction *BubbleJettonTransfer, bubble *Bubble) error {
			tx := bubble.Info.(BubbleTx)
			newAction.success = true
			body := tx.decodedBody.Value.(abi.JettonNotifyMsgBody)
			newAction.amount = body.Amount
			newAction.payload = body.ForwardPayload.Value
			newAction.recipient = &tx.account
			return nil
		},
	},
}

var StonfiV2PTONStrawReverse = Straw[BubbleJettonTransfer]{
	CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.JettonWallet), HasOperation(abi.JettonTransferMsgOp)},
	Builder: func(newAction *BubbleJettonTransfer, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		newAction.master, _ = tx.additionalInfo.JettonMaster(tx.account.Address)
		newAction.senderWallet = tx.account.Address
		newAction.sender = tx.inputFrom
		body := tx.decodedBody.Value.(abi.JettonTransferMsgBody)
		newAction.amount = body.Amount
		newAction.isWrappedTon = true
		newAction.payload = body.ForwardPayload.Value
		recipient, err := ton.AccountIDFromTlb(body.Destination)
		if err == nil {
			newAction.recipient = &Account{Address: *recipient}
		}
		return nil
	},
	Children: []Straw[BubbleJettonTransfer]{
		{
			CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.PtonTonTransferMsgOp)},
			Builder: func(newAction *BubbleJettonTransfer, bubble *Bubble) error {
				tx := bubble.Info.(BubbleTx)
				newAction.success = true
				newAction.recipient = &tx.account
				return nil
			},
		},
		{
			CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.ExcessMsgOp)},
			Optional:   true,
		},
	},
}

var StrawAuctionBigGetgems = Straw[AuctionBidBubble]{
	CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.NftAuctionV1), HasEmptyBody, AmountInterval(1, 1<<62)},
	Builder: func(newAction *AuctionBidBubble, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		newAction.Auction = tx.account.Address
		newAction.Bidder = tx.inputFrom.Address
		newAction.Amount = tx.inputAmount
		newAction.Success = tx.success
		newAction.Type = GetGemsAuction
		if tx.additionalInfo != nil && tx.additionalInfo.NftSaleContract != nil {
			newAction.NftAddress = &tx.additionalInfo.NftSaleContract.Item
		}
		return nil
	},
}

var StrawAuctionBuyFragments = Straw[BubbleNftPurchase]{
	CheckFuncs: []bubbleCheck{Is(AuctionBidBubble{})},
	Builder: func(newAction *BubbleNftPurchase, bubble *Bubble) error {
		bid := bubble.Info.(AuctionBidBubble)
		newAction.Buyer = bid.Bidder
		newAction.Nft = *bid.NftAddress
		newAction.Price = bid.Amount
		newAction.AuctionType = bid.Type
		newAction.Success = bid.Success
		return nil
	},
	SingleChild: &Straw[BubbleNftPurchase]{
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.NftOwnershipAssignedMsgOp)},
		Builder: func(newAction *BubbleNftPurchase, bubble *Bubble) error {
			seller := parseAccount(bubble.Info.(BubbleTx).decodedBody.Value.(abi.NftOwnershipAssignedMsgBody).PrevOwner)
			if seller != nil {
				newAction.Seller = seller.Address
			}
			return nil
		},
	},
}

var StrawAuctionBuyGetgems = Straw[BubbleNftPurchase]{
	CheckFuncs: []bubbleCheck{Is(AuctionBidBubble{})},
	Builder: func(newAction *BubbleNftPurchase, bubble *Bubble) error {
		bid := bubble.Info.(AuctionBidBubble)
		newAction.Buyer = bid.Bidder
		newAction.Nft = *bid.NftAddress
		newAction.Price = bid.Amount
		newAction.AuctionType = bid.Type
		newAction.Success = bid.Success
		return nil
	},
	SingleChild: &Straw[BubbleNftPurchase]{
		CheckFuncs: []bubbleCheck{IsNftTransfer},
	},
}

var StrawFindAuctionBidFragmentSimple = Straw[AuctionBidBubble]{
	CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.Teleitem), HasEmptyBody, AmountInterval(1, 1<<62)},
	Builder: func(newAction *AuctionBidBubble, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		newAction.Type = DnsTgAuction
		newAction.Amount = tx.inputAmount
		newAction.Bidder = tx.inputFrom.Address
		newAction.Success = tx.success
		newAction.Auction = tx.account.Address
		newAction.NftAddress = &tx.account.Address
		return nil
	},
}

var SubscriptionDeployStraw = Straw[BubbleSubscription]{
	CheckFuncs: []bubbleCheck{IsTx},
	Builder: func(newAction *BubbleSubscription, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		newAction.Subscriber = tx.account.Address
		newAction.First = true
		newAction.Success = tx.success
		return nil
	},
	Children: []Straw[BubbleSubscription]{
		{
			CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.SubscriptionDeployMsgOp)},
			Builder: func(newAction *BubbleSubscription, bubble *Bubble) error {
				tx := bubble.Info.(BubbleTx)
				newAction.Subscription = tx.account.Address
				if tx.additionalInfo != nil && tx.additionalInfo.SubscriptionInfo != nil {
					newAction.Admin = tx.additionalInfo.SubscriptionInfo.Admin
					newAction.WithdrawTo = tx.additionalInfo.SubscriptionInfo.WithdrawTo
					if len(bubble.Children) > 1 {
						newAction.Amount = tx.additionalInfo.SubscriptionInfo.PaymentPerPeriod
					}
				}
				newAction.Success = newAction.Success && tx.success
				return nil
			},
			Children: []Straw[BubbleSubscription]{
				{
					CheckFuncs: []bubbleCheck{Is(BubbleContractDeploy{})},
					Builder: func(newAction *BubbleSubscription, bubble *Bubble) error {
						newAction.Success = newAction.Success && bubble.Info.(BubbleContractDeploy).Success
						return nil
					},
				},
			},
		},
		{
			CheckFuncs: []bubbleCheck{Is(BubbleAddExtension{})},
			Builder: func(newAction *BubbleSubscription, bubble *Bubble) error {
				addExtTx := bubble.Info.(BubbleAddExtension)

				newAction.Success = newAction.Success && addExtTx.Success
				return nil
			},
		},
	},
}

var SubscriptionPaymentStraw = Straw[BubbleSubscription]{
	CheckFuncs: []bubbleCheck{
		IsTx,
		Or(HasInterface(abi.SubscriptionV1), HasInterface(abi.SubscriptionV2)),
		HasOperation(abi.PaymentConfirmedMsgOp),
		AmountInterval(1, 1<<62)},
	Builder: func(newAction *BubbleSubscription, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		newAction.Subscription = tx.account.Address
		if tx.additionalInfo != nil && tx.additionalInfo.SubscriptionInfo != nil {
			newAction.Subscriber = tx.additionalInfo.SubscriptionInfo.Wallet
			newAction.Admin = tx.additionalInfo.SubscriptionInfo.Admin
			newAction.WithdrawTo = tx.additionalInfo.SubscriptionInfo.WithdrawTo
			newAction.Amount = tx.additionalInfo.SubscriptionInfo.PaymentPerPeriod
		}
		if len(bubble.Children) > 0 {
			newAction.Success = tx.success
		}
		return nil
	},
}

var SubscriptionPaymentWithRequestFundsStraw = Straw[BubbleSubscription]{
	CheckFuncs: []bubbleCheck{
		IsTx,
		Or(HasInterface(abi.SubscriptionV1), HasInterface(abi.SubscriptionV2))},
	Builder: func(newAction *BubbleSubscription, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		newAction.Subscription = tx.account.Address
		if tx.additionalInfo != nil && tx.additionalInfo.SubscriptionInfo != nil {
			newAction.Subscriber = tx.additionalInfo.SubscriptionInfo.Wallet
			newAction.Admin = tx.additionalInfo.SubscriptionInfo.Admin
			newAction.WithdrawTo = tx.additionalInfo.SubscriptionInfo.WithdrawTo
			newAction.Amount = tx.additionalInfo.SubscriptionInfo.PaymentPerPeriod
		}
		newAction.First = false
		newAction.Success = false
		return nil
	},
	SingleChild: &Straw[BubbleSubscription]{
		CheckFuncs: []bubbleCheck{
			IsTx,
			Or(HasOperation(abi.PaymentRequestMsgOp), HasOperation(abi.WalletExtensionActionV5R1MsgOp)),
			func(bubble *Bubble) bool {
				if body, ok := bubble.Info.(BubbleTx).decodedBody.Value.(abi.WalletExtensionActionV5R1MsgBody); ok {
					return body.Extended == nil || len(*body.Extended) == 0
				}
				return true
			},
		},
		SingleChild: &Straw[BubbleSubscription]{
			Optional:   true,
			CheckFuncs: []bubbleCheck{Is(BubbleSubscription{})},
			Builder: func(newAction *BubbleSubscription, bubble *Bubble) error {
				sub := bubble.Info.(BubbleSubscription)
				newAction.Success = sub.Success
				return nil
			},
		},
	},
}

var TgAuctionV1InitialBidStraw = Straw[AuctionBidBubble]{
	CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.TelemintDeployMsgOp)},
	Builder: func(newAction *AuctionBidBubble, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		body := tx.decodedBody.Value.(abi.TelemintDeployMsgBody)
		newAction.Type = DnsTgAuction
		newAction.Amount = tx.inputAmount
		newAction.Bidder = tx.inputFrom.Address
		newAction.Username = string(body.Msg.Username)
		return nil
	},
	SingleChild: &Straw[AuctionBidBubble]{
		CheckFuncs: []bubbleCheck{IsTx, HasOpcode(0x299a3e15)},
		Builder: func(newAction *AuctionBidBubble, bubble *Bubble) error {
			tx := bubble.Info.(BubbleTx)
			newAction.Success = tx.success

			newAction.Auction = tx.account.Address
			newAction.NftAddress = &tx.account.Address
			if tx.additionalInfo.EmulatedTeleitemNFT != nil {
				newAction.Nft = &core.NftItem{
					Address:           tx.account.Address,
					Index:             tx.additionalInfo.EmulatedTeleitemNFT.Index,
					CollectionAddress: tx.additionalInfo.EmulatedTeleitemNFT.CollectionAddress,
					Verified:          tx.additionalInfo.EmulatedTeleitemNFT.Verified,
					Transferable:      false,
					Metadata: map[string]interface{}{
						"name":  newAction.Username,
						"image": fmt.Sprintf("https://nft.fragment.com/username/%v.webp", newAction.Username),
					},
				}
			}
			return nil
		},
	},
}

var ToncoDepositLiquidityBothStraw = Straw[BubbleLiquidityDeposit]{
	CheckFuncs: []bubbleCheck{},
	Children: []Straw[BubbleLiquidityDeposit]{
		{
			CheckFuncs: []bubbleCheck{Is(BubbleLiquidityDeposit{})},
			Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
				tx := bubble.Info.(BubbleLiquidityDeposit)
				newAction.From = tx.From
				newAction.Protocol = tx.Protocol
				newAction.Tokens = append(newAction.Tokens, tx.Tokens...)
				newAction.Success = tx.Success
				return nil
			},
		},
		{
			CheckFuncs: []bubbleCheck{IsJettonTransfer, JettonRecipientAccount(references.ToncoRouter)},
			Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
				jettonTx := bubble.Info.(BubbleJettonTransfer)
				if jettonTx.isWrappedTon {
					newAction.Tokens = append(newAction.Tokens, core.VaultDepositInfo{
						Price: core.Price{
							Currency: core.Currency{
								Type: core.CurrencyTON,
							},
							Amount: big.Int(jettonTx.amount),
						},
						Vault: jettonTx.recipient.Address,
					})
				} else {
					newAction.Tokens = append(newAction.Tokens, core.VaultDepositInfo{
						Price: core.Price{
							Currency: core.Currency{
								Type:   core.CurrencyJetton,
								Jetton: &jettonTx.master,
							},
							Amount: big.Int(jettonTx.amount),
						},
						Vault: jettonTx.recipientWallet,
					})
				}
				return nil
			},
			SingleChild: &Straw[BubbleLiquidityDeposit]{
				CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.Poolv3FundAccountMsgOp), HasInterface(abi.ToncoPool)},
				Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
					return nil
				},
				SingleChild: &Straw[BubbleLiquidityDeposit]{
					CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.Accountv3AddLiquidityMsgOp)},
					Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
						return nil
					},
				},
			},
		},
	},
}

var ToncoDepositLiquiditySingleStraw = Straw[BubbleLiquidityDeposit]{
	CheckFuncs: []bubbleCheck{IsJettonTransfer, JettonRecipientAccount(references.ToncoRouter)},
	Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
		jettonTx := bubble.Info.(BubbleJettonTransfer)
		newAction.Protocol = core.Protocol{
			Name:  string(references.Tonco),
			Image: &references.ToncoImage,
		}
		newAction.From = jettonTx.sender.Address
		if jettonTx.isWrappedTon {
			newAction.Tokens = append(newAction.Tokens, core.VaultDepositInfo{
				Price: core.Price{
					Currency: core.Currency{
						Type: core.CurrencyTON,
					},
					Amount: big.Int(jettonTx.amount),
				},
				Vault: jettonTx.recipient.Address,
			})
		} else {
			newAction.Tokens = append(newAction.Tokens, core.VaultDepositInfo{
				Price: core.Price{
					Currency: core.Currency{
						Type:   core.CurrencyJetton,
						Jetton: &jettonTx.master,
					},
					Amount: big.Int(jettonTx.amount),
				},
				Vault: jettonTx.recipientWallet,
			})
		}
		return nil
	},
	SingleChild: &Straw[BubbleLiquidityDeposit]{
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.Poolv3FundAccountMsgOp), HasInterface(abi.ToncoPool)},
		Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
			return nil
		},
		SingleChild: &Straw[BubbleLiquidityDeposit]{
			CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.Accountv3AddLiquidityMsgOp)},
			Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
				return nil
			},
			SingleChild: &Straw[BubbleLiquidityDeposit]{
				CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.Poolv3MintMsgOp), HasInterface(abi.ToncoPool)},
				Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
					tx := bubble.Info.(BubbleTx)
					newAction.Success = tx.success
					return nil
				},
				Children: []Straw[BubbleLiquidityDeposit]{
					{
						CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.PositionnftV3PositionInitMsgOp), HasInterface(abi.NftItem)},
						Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
							tx := bubble.Info.(BubbleTx)
							newAction.Success = newAction.Success && tx.success
							return nil
						},
						SingleChild: &Straw[BubbleLiquidityDeposit]{
							Optional:   true,
							CheckFuncs: []bubbleCheck{Is(BubbleContractDeploy{})},
						},
					},
					{
						Optional:   true,
						CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.ExcessMsgOp)},
						Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
							tx := bubble.Info.(BubbleTx)
							newAction.Success = newAction.Success && tx.success
							return nil
						},
					},
				},
			},
		},
	},
}

var ToncoDepositLiquidityWithRefundStraw = Straw[BubbleLiquidityDeposit]{
	CheckFuncs: []bubbleCheck{Is(BubbleLiquidityDeposit{})},
	Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
		tx := bubble.Info.(BubbleLiquidityDeposit)
		newAction.From = tx.From
		newAction.Tokens = tx.Tokens
		newAction.Protocol = tx.Protocol
		newAction.Success = tx.Success
		return nil
	},
	SingleChild: &Straw[BubbleLiquidityDeposit]{
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.PayToMsgOp), HasInterface(abi.ToncoRouter)},
		Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
			tx := bubble.Info.(BubbleTx)
			newAction.Success = newAction.Success && tx.success
			return nil
		},
		Children: []Straw[BubbleLiquidityDeposit]{
			{
				CheckFuncs: []bubbleCheck{IsJettonTransfer},
				Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
					tx := bubble.Info.(BubbleJettonTransfer)
					amount := big.Int(tx.amount)
					for i, token := range newAction.Tokens {
						if (token.Price.Currency.Type == core.CurrencyTON && !tx.isWrappedTon) ||
							(token.Price.Currency.Type != core.CurrencyTON && *token.Price.Currency.Jetton != tx.master) {
							continue
						}

						newAction.Tokens[i].Price.Amount = *new(big.Int).Sub(&newAction.Tokens[i].Price.Amount, &amount)
					}
					newAction.Success = newAction.Success && tx.success
					return nil
				},
			},
			{
				CheckFuncs: []bubbleCheck{IsJettonTransfer},
				Builder: func(newAction *BubbleLiquidityDeposit, bubble *Bubble) error {
					tx := bubble.Info.(BubbleJettonTransfer)
					amount := big.Int(tx.amount)
					for i, token := range newAction.Tokens {
						if (token.Price.Currency.Type == core.CurrencyTON && !tx.isWrappedTon) ||
							(token.Price.Currency.Type != core.CurrencyTON && *token.Price.Currency.Jetton != tx.master) {
							continue
						}

						newAction.Tokens[i].Price.Amount = *new(big.Int).Sub(&newAction.Tokens[i].Price.Amount, &amount)
					}
					newAction.Success = newAction.Success && tx.success
					return nil
				},
			},
		},
	},
}

var ToncoSwapStraw = Straw[BubbleJettonSwap]{
	CheckFuncs: []bubbleCheck{IsJettonTransfer},
	Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
		tx := bubble.Info.(BubbleJettonTransfer)
		newAction.Dex = references.Tonco
		newAction.UserWallet = tx.sender.Address
		newAction.Router = tx.recipient.Address
		newAction.In.IsTon = tx.isWrappedTon
		newAction.In.Amount = big.Int(tx.amount)
		if !newAction.In.IsTon {
			newAction.In.JettonWallet = tx.senderWallet
			newAction.In.JettonMaster = tx.master
		}
		return nil
	},
	SingleChild: &Straw[BubbleJettonSwap]{
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.Poolv3SwapMsgOp), HasInterface(abi.ToncoPool)},
		Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
			tx := bubble.Info.(BubbleTx)
			body, ok := tx.decodedBody.Value.(abi.Poolv3SwapMsgBody)
			if !ok {
				return fmt.Errorf("not a tonco pool_v3_swap_msg_body")
			}
			if body.PayloadsCell.TargetAddress != newAction.UserWallet.ToMsgAddress() {
				return fmt.Errorf("not a user wallet")
			}
			return nil
		},
		SingleChild: &Straw[BubbleJettonSwap]{
			CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.PayToMsgOp), HasInterface(abi.ToncoRouter), func(bubble *Bubble) bool {
				tx := bubble.Info.(BubbleTx)
				body, ok := tx.decodedBody.Value.(abi.PayToMsgBody)
				if !ok {
					return false
				}
				if body.PayTo.SumType != "PayToCode200" && body.PayTo.SumType != "PayToCode230" {
					return false
				}
				return true
			}},
			Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
				tx := bubble.Info.(BubbleTx)

				newAction.Success = tx.decodedBody.Value.(abi.PayToMsgBody).PayTo.SumType == "PayToCode200"
				return nil
			},
			SingleChild: &Straw[BubbleJettonSwap]{
				CheckFuncs: []bubbleCheck{IsJettonTransfer},
				Builder: func(newAction *BubbleJettonSwap, bubble *Bubble) error {
					tx := bubble.Info.(BubbleJettonTransfer)
					newAction.Out.IsTon = tx.isWrappedTon
					newAction.Out.Amount = big.Int(tx.amount)
					if !newAction.Out.IsTon {
						newAction.Out.JettonWallet = tx.recipientWallet
						newAction.Out.JettonMaster = tx.master
					}
					return nil
				},
			},
		},
	},
}

var UnSubscriptionByBeneficiaryOrExpiredStraw = Straw[BubbleUnSubscription]{
	CheckFuncs: []bubbleCheck{
		IsTx,
		Or(IsExternal, HasOperation(abi.WalletPluginDestructMsgOp)),
		Or(HasInterface(abi.SubscriptionV1), HasInterface(abi.SubscriptionV2)),
	},
	Builder: func(newAction *BubbleUnSubscription, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		newAction.Subscription = tx.account.Address
		newAction.Success = tx.success
		if tx.additionalInfo != nil && tx.additionalInfo.SubscriptionInfo != nil {
			newAction.Subscriber = tx.additionalInfo.SubscriptionInfo.Wallet
			newAction.Admin = tx.additionalInfo.SubscriptionInfo.Admin
			newAction.WithdrawTo = tx.additionalInfo.SubscriptionInfo.WithdrawTo
		}
		return nil
	},
	Children: []Straw[BubbleUnSubscription]{
		{
			CheckFuncs: []bubbleCheck{IsTx},
			Builder: func(newAction *BubbleUnSubscription, bubble *Bubble) error {
				newAction.Success = newAction.Success && bubble.Info.(BubbleTx).success
				return nil
			},
			SingleChild: &Straw[BubbleUnSubscription]{
				CheckFuncs: []bubbleCheck{Is(BubbleRemoveExtension{})},
				Builder: func(newAction *BubbleUnSubscription, bubble *Bubble) error {
					removeExtTx := bubble.Info.(BubbleRemoveExtension)
					if removeExtTx.Extension != newAction.Subscription {
						newAction.Success = false
					}
					newAction.Success = newAction.Success && removeExtTx.Success
					return nil
				},
			},
		},
	},
}

var UnSubscriptionBySubscriberStraw = Straw[BubbleUnSubscription]{
	CheckFuncs: []bubbleCheck{IsTx},
	Builder: func(newAction *BubbleUnSubscription, bubble *Bubble) error {
		newAction.Success = true
		return nil
	},
	Children: []Straw[BubbleUnSubscription]{
		{
			CheckFuncs: []bubbleCheck{
				IsTx,
				HasOperation(abi.WalletPluginDestructMsgOp),
				Or(HasInterface(abi.SubscriptionV1), HasInterface(abi.SubscriptionV2)),
			},
			Builder: func(newAction *BubbleUnSubscription, bubble *Bubble) error {
				tx := bubble.Info.(BubbleTx)
				newAction.Subscription = tx.account.Address
				if tx.additionalInfo != nil && tx.additionalInfo.SubscriptionInfo != nil {
					newAction.Subscriber = tx.additionalInfo.SubscriptionInfo.Wallet
					newAction.Admin = tx.additionalInfo.SubscriptionInfo.Admin
					newAction.WithdrawTo = tx.additionalInfo.SubscriptionInfo.WithdrawTo
				}
				newAction.Success = tx.success
				return nil
			},
		},
		{

			CheckFuncs: []bubbleCheck{Is(BubbleRemoveExtension{})},
			Builder: func(newAction *BubbleUnSubscription, bubble *Bubble) error {
				removeExtTx := bubble.Info.(BubbleRemoveExtension)
				if removeExtTx.Extension != newAction.Subscription {
					newAction.Success = false
				}
				newAction.Success = newAction.Success && removeExtTx.Success
				return nil
			},
		},
	},
}

var WithdrawEthenaStakeRequestStraw = Straw[BubbleWithdrawTokenStakeRequest]{
	CheckFuncs: []bubbleCheck{IsJettonTransfer, JettonRecipientAccount(references.EthenaPool)},
	Builder: func(newAction *BubbleWithdrawTokenStakeRequest, bubble *Bubble) error {
		tx := bubble.Info.(BubbleJettonTransfer)
		newAction.Staker = tx.sender.Address
		amount := big.Int(tx.amount)
		newAction.Protocol = core.Protocol{
			Name:  references.Ethena,
			Image: &references.EthenaImage,
		}
		newAction.StakeMeta = &core.Price{
			Currency: core.Currency{
				Type:   core.CurrencyJetton,
				Jetton: &tx.master,
			},
			Amount: amount,
		}
		return nil
	},
	SingleChild: &Straw[BubbleWithdrawTokenStakeRequest]{
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.JettonMintMsgOp)},
		SingleChild: &Straw[BubbleWithdrawTokenStakeRequest]{
			CheckFuncs: []bubbleCheck{IsTx},
			Builder: func(newAction *BubbleWithdrawTokenStakeRequest, bubble *Bubble) error {
				tx := bubble.Info.(BubbleTx)
				newAction.Success = tx.success
				return nil
			},
		},
	},
}

var WithdrawLiquidStake = Straw[BubbleWithdrawStake]{
	CheckFuncs: []bubbleCheck{Is(BubbleWithdrawStakeRequest{})},
	Builder: func(newAction *BubbleWithdrawStake, bubble *Bubble) error {
		request := bubble.Info.(BubbleWithdrawStakeRequest)
		newAction.Amount -= request.attachedAmount
		newAction.Pool = request.Pool
		newAction.Staker = request.Staker
		newAction.Implementation = request.Implementation
		return nil
	},
	SingleChild: &Straw[BubbleWithdrawStake]{
		CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.TonstakePoolWithdrawalMsgOp)},
		Builder: func(newAction *BubbleWithdrawStake, bubble *Bubble) error {
			newAction.Amount += bubble.Info.(BubbleTx).inputAmount
			return nil
		},
	},
}

var WithdrawStakeImmediatelyStraw = Straw[BubbleWithdrawStake]{
	CheckFuncs: []bubbleCheck{Is(BubbleWithdrawStakeRequest{})},
	Builder: func(newAction *BubbleWithdrawStake, bubble *Bubble) error {
		req := bubble.Info.(BubbleWithdrawStakeRequest)
		newAction.Pool = req.Pool
		newAction.Staker = req.Staker
		newAction.Amount = -req.attachedAmount
		newAction.Implementation = req.Implementation
		return nil
	},
	SingleChild: &Straw[BubbleWithdrawStake]{
		CheckFuncs: []bubbleCheck{IsTx, AmountInterval(int64(ton.OneTON), 1<<63-1)},
		Builder: func(newAction *BubbleWithdrawStake, bubble *Bubble) error {
			newAction.Amount += bubble.Info.(BubbleTx).inputAmount
			return nil
		},
	},
}

var WithdrawTFStakeRequestStraw = Straw[BubbleWithdrawStakeRequest]{
	CheckFuncs: []bubbleCheck{IsTx, HasInterface(abi.TvPool), HasTextComment("w")},
	Builder: func(newAction *BubbleWithdrawStakeRequest, bubble *Bubble) error {
		tx := bubble.Info.(BubbleTx)
		newAction.Pool = tx.account.Address
		newAction.Staker = tx.inputFrom.Address
		newAction.Success = tx.success
		newAction.attachedAmount = tx.inputAmount
		newAction.Implementation = core.StakingImplementationTF
		return nil
	},
	Children: []Straw[BubbleWithdrawStakeRequest]{
		{
			Optional:   true,
			CheckFuncs: []bubbleCheck{IsTx, AmountInterval(0, int64(ton.OneTON))},
		},
	},
}

var WtonMintStraw = Straw[BubbleJettonMint]{
	CheckFuncs: []bubbleCheck{IsTx, HasOpcode(0x77a33521)},
	Builder: func(newAction *BubbleJettonMint, bubble *Bubble) error {
		newAction.recipient = bubble.Info.(BubbleTx).account
		return nil
	},
	Children: []Straw[BubbleJettonMint]{
		{
			CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.JettonInternalTransferMsgOp)},
			Builder: func(newAction *BubbleJettonMint, bubble *Bubble) error {
				tx := bubble.Info.(BubbleTx)
				body := tx.decodedBody.Value.(abi.JettonInternalTransferMsgBody)
				newAction.amount = body.Amount
				if tx.additionalInfo != nil {
					if master, ok := tx.additionalInfo.JettonMaster(tx.account.Address); ok {
						newAction.master = master
					}
				}
				newAction.recipientWallet = tx.account.Address
				newAction.success = tx.success
				return nil
			},
			Children: []Straw[BubbleJettonMint]{
				{
					CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.JettonNotifyMsgOp)},
					Optional:   true,
				},
				{
					CheckFuncs: []bubbleCheck{Is(BubbleContractDeploy{})},
					Optional:   true,
				},
			},
		},
		{
			CheckFuncs: []bubbleCheck{IsTx, HasOperation(abi.ExcessMsgOp)},
			Optional:   true,
		},
	},
}