Highload v3 support

abi/generated_test.go

@@ -1876,6 +1876,27 @@ func TestMessageDecoder(t *testing.T) {
 			},
 			interfaces: []ContractInterface{WalletV5R1},
 		},
+		{
+			name:       "highload V3 internal transfer",
+			boc:        "te6ccgEBBQEAWQABGK5C5aQAAAAAADVe6gECCg7DyG0DAgQCCg7DyG0DAwQAAABoQgA2ZpktQsYby0n9cV5VWOFINBjScIU2HdondFsK3lDpECAvrwgAAAAAAAAAAAAAAAAAAA==",
+			wantOpName: HighloadWalletInternalTransferMsgOp,
+			wantValue: HighloadWalletInternalTransferMsgBody{
+				QueryId: 3497706,
+				Actions: W5Actions{
+					W5SendMessageAction{
+						Magic: 0xec3c86d,
+						Mode:  3,
+						Msg:   mustBocToMessageRelaxed("b5ee9c7201010101003600006842003666992d42c61bcb49fd715e5558e1483418d27085361dda27745b0ade50e910202faf080000000000000000000000000000"),
+					},
+					W5SendMessageAction{
+						Magic: 0xec3c86d,
+						Mode:  3,
+						Msg:   mustBocToMessageRelaxed("b5ee9c7201010101003600006842003666992d42c61bcb49fd715e5558e1483418d27085361dda27745b0ade50e910202faf080000000000000000000000000000"),
+					},
+				},
+			},
+			interfaces: []ContractInterface{WalletHighloadV3R1},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

abi/interfaces.go

@@ -1299,6 +1299,10 @@ func (c ContractInterface) IntMsgs() []msgDecoderFunc {
 			decodeFuncStormVaultInitMsgBody,
 			decodeFuncStormVaultRequestWithdrawPositionMsgBody,
 		}
+	case WalletHighloadV3R1:
+		return []msgDecoderFunc{
+			decodeFuncHighloadWalletInternalTransferMsgBody,
+		}
 	case WalletV5R1:
 		return []msgDecoderFunc{
 			decodeFuncWalletSignedInternalV5R1MsgBody,

abi/messages.md

@@ -50,6 +50,7 @@ The list below contains the supported message operations, their names and opcode
 | GetStaticData| 0x2fcb26a2 |
 | GramSubmitProofOfWork| 0x4d696e65 |
 | HighloadWalletSignedV2| 0x00000000 |
+| HighloadWalletInternalTransfer| 0xae42e5a4 |
 | HighloadWalletSignedV3| 0x00000000 |
 | InitPaymentChannel| 0x0e0620c2 |
 | JettonBurn| 0x595f07bc |

abi/messages_generated.go

@@ -251,6 +251,8 @@ var (
 	decodeFuncStorageRewardWithdrawalMsgBody = decodeMsg(tlb.Tag{Val: 0xa91baf56, Len: 32}, StorageRewardWithdrawalMsgOp, StorageRewardWithdrawalMsgBody{})
 	// 0xad4eb6f5
 	decodeFuncDedustPayoutFromPoolMsgBody = decodeMsg(tlb.Tag{Val: 0xad4eb6f5, Len: 32}, DedustPayoutFromPoolMsgOp, DedustPayoutFromPoolMsgBody{})
+	// 0xae42e5a4
+	decodeFuncHighloadWalletInternalTransferMsgBody = decodeMsg(tlb.Tag{Val: 0xae42e5a4, Len: 32}, HighloadWalletInternalTransferMsgOp, HighloadWalletInternalTransferMsgBody{})
 	// 0xafaf283e
 	decodeFuncMultisigApproveRejectedMsgBody = decodeMsg(tlb.Tag{Val: 0xafaf283e, Len: 32}, MultisigApproveRejectedMsgOp, MultisigApproveRejectedMsgBody{})
 	// 0xb1ebae06
@@ -709,6 +711,9 @@ var opcodedMsgInDecodeFunctions = map[uint32]msgDecoderFunc{
 	// 0xad4eb6f5
 	DedustPayoutFromPoolMsgOpCode: decodeFuncDedustPayoutFromPoolMsgBody,
 
+	// 0xae42e5a4
+	HighloadWalletInternalTransferMsgOpCode: decodeFuncHighloadWalletInternalTransferMsgBody,
+
 	// 0xafaf283e
 	MultisigApproveRejectedMsgOpCode: decodeFuncMultisigApproveRejectedMsgBody,
 
@@ -962,6 +967,7 @@ const (
 	ReportRoyaltyParamsMsgOp                     MsgOpName = "ReportRoyaltyParams"
 	StorageRewardWithdrawalMsgOp                 MsgOpName = "StorageRewardWithdrawal"
 	DedustPayoutFromPoolMsgOp                    MsgOpName = "DedustPayoutFromPool"
+	HighloadWalletInternalTransferMsgOp          MsgOpName = "HighloadWalletInternalTransfer"
 	MultisigApproveRejectedMsgOp                 MsgOpName = "MultisigApproveRejected"
 	TonstakeImanagerRequestNotificationMsgOp     MsgOpName = "TonstakeImanagerRequestNotification"
 	TonstakePoolDeployControllerMsgOp            MsgOpName = "TonstakePoolDeployController"
@@ -1130,6 +1136,7 @@ const (
 	ReportRoyaltyParamsMsgOpCode                     MsgOpCode = 0xa8cb00ad
 	StorageRewardWithdrawalMsgOpCode                 MsgOpCode = 0xa91baf56
 	DedustPayoutFromPoolMsgOpCode                    MsgOpCode = 0xad4eb6f5
+	HighloadWalletInternalTransferMsgOpCode          MsgOpCode = 0xae42e5a4
 	MultisigApproveRejectedMsgOpCode                 MsgOpCode = 0xafaf283e
 	TonstakeImanagerRequestNotificationMsgOpCode     MsgOpCode = 0xb1ebae06
 	TonstakePoolDeployControllerMsgOpCode            MsgOpCode = 0xb27edcad
@@ -1902,6 +1909,11 @@ type DedustPayoutFromPoolMsgBody struct {
 	Payload       *tlb.Any `tlb:"maybe^"`
 }
 
+type HighloadWalletInternalTransferMsgBody struct {
+	QueryId uint64
+	Actions W5Actions `tlb:"^"`
+}
+
 type MultisigApproveRejectedMsgBody struct {
 	QueryId  uint64
 	ExitCode uint32
@@ -2277,6 +2289,7 @@ var KnownMsgInTypes = map[string]any{
 	ReportRoyaltyParamsMsgOp:                     ReportRoyaltyParamsMsgBody{},
 	StorageRewardWithdrawalMsgOp:                 StorageRewardWithdrawalMsgBody{},
 	DedustPayoutFromPoolMsgOp:                    DedustPayoutFromPoolMsgBody{},
+	HighloadWalletInternalTransferMsgOp:          HighloadWalletInternalTransferMsgBody{},
 	MultisigApproveRejectedMsgOp:                 MultisigApproveRejectedMsgBody{},
 	TonstakeImanagerRequestNotificationMsgOp:     TonstakeImanagerRequestNotificationMsgBody{},
 	TonstakePoolDeployControllerMsgOp:            TonstakePoolDeployControllerMsgBody{},

abi/schemas/wallets.xml

@@ -136,6 +136,7 @@
         <get_method name="get_timeout"/>
         <msg_in>
             <ext_in name="highload_wallet_signed_v3"/>
+            <internal name="highload_wallet_internal_transfer"/>
         </msg_in>
     </interface>
 
@@ -216,6 +217,9 @@
     <internal name="wallet_extension_action_v5r1" >
         extension_action#6578746e query_id:uint64 actions:(Maybe ^W5Actions) extended:(Maybe W5ExtendedActions) = InternalMsgBody;
     </internal>
+    <internal name="highload_wallet_internal_transfer" >
+        internal_transfer#ae42e5a4 query_id:uint64 actions:^W5Actions = InternalMsgBody;
+    </internal>
     <ext_in name="highload_wallet_signed_v2">
         signed#_ signature:bits512 subwallet_id:uint32 query_id:uint64 payload:(HashmapE 16 SendMessageAction) = ExternalMsgBody;
     </ext_in>

wallet/messages.go

@@ -4,6 +4,7 @@ import (
 	"crypto/ed25519"
 	"errors"
 	"fmt"
+	"github.com/tonkeeper/tongo/ton"
 
 	"github.com/tonkeeper/tongo/boc"
 	"github.com/tonkeeper/tongo/tlb"
@@ -245,6 +246,12 @@ func ExtractRawMessages(ver Version, msg *boc.Cell) ([]RawMessage, error) {
 			return nil, err
 		}
 		return hl.RawMessages, nil
+	case HighLoadV3R1:
+		hl, err := DecodeHighloadV3Message(msg)
+		if err != nil {
+			return nil, err
+		}
+		return hl.Messages, nil
 	default:
 		return nil, fmt.Errorf("wallet version is not supported: %v", ver)
 	}
@@ -552,3 +559,208 @@ func (extendedActions W5ExtendedActions) MarshalTLB(c *boc.Cell, encoder *tlb.En
 	}
 	return nil
 }
+
+// HighloadV3InternalTransfer TLB: internal_transfer#ae42e5a4 {n:#} query_id:uint64 actions:^(OutList n) = InternalMsgBody n;
+type HighloadV3InternalTransfer struct {
+	Magic   tlb.Magic `tlb:"#ae42e5a4"`
+	QueryId uint64
+	Actions W5Actions `tlb:"^"`
+}
+
+type HighloadV3MsgInner struct {
+	SubwalletID   uint32
+	MessageToSend *boc.Cell `tlb:"^"`
+	SendMode      uint8
+	QueryID       tlb.Uint23 // _ shift:uint13 bit_number:(## 10) { bit_number >= 0 } { bit_number < 1023 } = QueryId;
+	CreatedAt     uint64
+	Timeout       tlb.Uint22
+}
+
+type HighloadV3Message struct {
+	SubwalletID uint32
+	Messages    []RawMessage
+	SendMode    uint8
+	QueryID     tlb.Uint23
+	CreatedAt   uint64
+	Timeout     tlb.Uint22
+	wallet      ton.AccountID // technical field for storing the wallet address for forming attached messages
+}
+
+func (p HighloadV3Message) MarshalTLB(c *boc.Cell, encoder *tlb.Encoder) error {
+	var (
+		msg RawMessage
+		err error
+	)
+	ln := len(p.Messages)
+	switch {
+	case ln > 254*254:
+		return fmt.Errorf("PayloadHighloadV3 supports only up to 254*254 messages")
+	case ln < 1:
+		return fmt.Errorf("must be at least one message")
+	case ln == 1:
+		var m tlb.Message
+		err := tlb.Unmarshal(p.Messages[0].Message, &m)
+		if err != nil {
+			return err
+		}
+		// IntMsg with state init and extOutMsg must be packed because of message validation
+		// throw_if(error::invalid_message_to_send, maybe_state_init); ;; throw if state-init included (state-init not supported)
+		// throw_if(error::invalid_message_to_send, message_slice~load_uint(1)); ;; int_msg_info$0
+		if !m.Init.Exists && m.Info.SumType == "IntMsgInfo" { // no need to pack
+			msg = p.Messages[0]
+		} else {
+			msg, err = packHighloadV3Messages(uint64(p.QueryID), p.wallet, p.Messages, p.SendMode)
+			if err != nil {
+				return err
+			}
+		}
+	default:
+		msg, err = packHighloadV3Messages(uint64(p.QueryID), p.wallet, p.Messages, p.SendMode)
+		if err != nil {
+			return err
+		}
+	}
+	return tlb.Marshal(c, HighloadV3MsgInner{
+		SubwalletID:   p.SubwalletID,
+		MessageToSend: msg.Message,
+		SendMode:      msg.Mode,
+		QueryID:       p.QueryID,
+		CreatedAt:     p.CreatedAt,
+		Timeout:       p.Timeout,
+	})
+}
+
+func packHighloadV3Messages(queryID uint64, wallet ton.AccountID, msgs []RawMessage, mode uint8) (RawMessage, error) {
+	const messagesPerPack = 253
+	var (
+		totalAmount uint64 = 0
+		actions     W5Actions
+	)
+	rawMsgs := make([]RawMessage, len(msgs))
+	copy(rawMsgs, msgs) // to prevent corruption of msgs
+	if len(rawMsgs) > messagesPerPack {
+		rest, err := packHighloadV3Messages(queryID, wallet, rawMsgs[messagesPerPack:], mode)
+		if err != nil {
+			return RawMessage{}, err
+		}
+		rawMsgs = append(rawMsgs[:messagesPerPack], rest)
+	}
+	for _, rawMsg := range rawMsgs {
+		var m tlb.Message
+		err := tlb.Unmarshal(rawMsg.Message, &m)
+		if err != nil {
+			return RawMessage{}, err
+		}
+		if m.Info.SumType == "IntMsgInfo" {
+			totalAmount += uint64(m.Info.IntMsgInfo.Value.Grams)
+		} else {
+			totalAmount += uint64(1_000_000) // add some amount for execution
+		}
+		actions = append(actions, W5SendMessageAction{
+			Mode: rawMsg.Mode,
+			Msg:  rawMsg.Message,
+		})
+	}
+	body := boc.NewCell()
+	err := tlb.Marshal(body, HighloadV3InternalTransfer{
+		QueryId: queryID,
+		Actions: actions,
+	})
+	if err != nil {
+		return RawMessage{}, err
+	}
+	msgInt, _, err := Message{
+		Amount:  tlb.Grams(totalAmount),
+		Bounce:  false,
+		Address: wallet,
+		Body:    body,
+	}.ToInternal()
+	if err != nil {
+		return RawMessage{}, err
+	}
+	c := boc.NewCell()
+	err = tlb.Marshal(c, msgInt)
+	if err != nil {
+		return RawMessage{}, err
+	}
+	return RawMessage{
+		Mode:    mode,
+		Message: c,
+	}, nil
+}
+
+const highloadV3InternalTransferOp = 0xae42e5a4
+
+func (p *HighloadV3Message) UnmarshalTLB(c *boc.Cell, decoder *tlb.Decoder) error {
+	var msgInner HighloadV3MsgInner
+	err := tlb.Unmarshal(c, &msgInner)
+	if err != nil {
+		return err
+	}
+	res := HighloadV3Message{
+		SubwalletID: msgInner.SubwalletID,
+		SendMode:    msgInner.SendMode,
+		QueryID:     msgInner.QueryID,
+		CreatedAt:   msgInner.CreatedAt,
+		Timeout:     msgInner.Timeout,
+	}
+	var msgs []RawMessage
+	msgs, err = unpackHighloadV3Messages(msgInner.MessageToSend, msgInner.QueryID, msgInner.SendMode, msgs)
+	if err != nil {
+		return err
+	}
+	res.Messages = msgs
+	*p = res
+	return nil
+}
+
+func unpackHighloadV3Messages(msg *boc.Cell, queryID tlb.Uint23, mode uint8, messages []RawMessage) ([]RawMessage, error) {
+	var m tlb.Message
+	err := tlb.Unmarshal(msg, &m)
+	if err != nil {
+		return nil, err
+	}
+	if m.Info.SumType != "IntMsgInfo" {
+		// TODO: reset counters for msgInner.MessageToSend ?
+		messages = append(messages, RawMessage{msg, mode})
+		return messages, nil
+	}
+	body := boc.Cell(m.Body.Value)
+	op, err := body.PickUint(32)
+	if err != nil || op != highloadV3InternalTransferOp {
+		messages = append(messages, RawMessage{msg, mode})
+		return messages, nil
+	}
+	var intTransfer HighloadV3InternalTransfer
+	err = tlb.Unmarshal(&body, &intTransfer)
+	if err != nil {
+		return nil, err
+	}
+	if intTransfer.QueryId != uint64(queryID) {
+		return nil, errors.New("mismatch queryID for internal transfer") // TODO: need to check?
+	}
+	for _, a := range intTransfer.Actions {
+		messages, err = unpackHighloadV3Messages(a.Msg, queryID, a.Mode, messages)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return messages, nil
+}
+
+func DecodeHighloadV3Message(msg *boc.Cell) (*HighloadV3Message, error) {
+	var m tlb.Message
+	if err := tlb.Unmarshal(msg, &m); err != nil {
+		return nil, err
+	}
+	c := boc.Cell(m.Body.Value)
+	payloadCell, err := c.NextRef()
+	if err != nil {
+		return nil, err
+	}
+	var res HighloadV3Message
+	if err := tlb.Unmarshal(payloadCell, &res); err != nil {
+		return nil, err
+	}
+	return &res, nil
+}