Merge pull request #32 from icon-project/feat/contract-deploy-tx

feat(transaction): implement Type-1 transaction

Author: CyrusVorwald

pkg/stacks/constants.go

@@ -11,6 +11,7 @@ type PayloadType byte
 
 const (
 	PayloadTypeTokenTransfer PayloadType = 0x00
+	PayloadTypeSmartContract PayloadType = 0x01
 	PayloadTypeContractCall  PayloadType = 0x02
 )
 

pkg/transaction/auth.go

@@ -30,6 +30,10 @@ func (t *TokenTransferTransaction) GetAuth() *TransactionAuth {
 	return &t.Auth
 }
 
+func (t *SmartContractTransaction) GetAuth() *TransactionAuth {
+	return &t.Auth
+}
+
 func (t *ContractCallTransaction) GetAuth() *TransactionAuth {
 	return &t.Auth
 }

pkg/transaction/builder.go

@@ -221,6 +221,44 @@ func MakeSTXTokenTransfer(
 	return tx, nil
 }
 
+func MakeContractDeploy(
+	contractName string,
+	codeBody string,
+	network stacks.StacksNetwork,
+	senderAddress string,
+	senderKey []byte,
+	fee *big.Int,
+	nonce *big.Int,
+) (*SmartContractTransaction, error) {
+	if contractName == "" || codeBody == "" || len(senderKey) == 0 {
+		return nil, &CustomError{Message: "Invalid parameters: contractName, codeBody, or senderKey are empty"}
+	}
+
+	signer := deriveSigner(senderKey)
+
+	tx, err := NewSmartContractTransaction(
+		contractName,
+		codeBody,
+		network.Version,
+		network.ChainID,
+		signer,
+		0,
+		0,
+		stacks.AnchorModeOnChainOnly,
+		stacks.PostConditionModeDeny,
+	)
+	if err != nil {
+		return nil, &CustomError{Message: "Failed to create transaction", Err: err}
+	}
+
+	err = createAndSignTransaction(tx, network, senderAddress, senderKey, fee, nonce)
+	if err != nil {
+		return nil, err
+	}
+
+	return tx, nil
+}
+
 func MakeContractCall(
 	contractAddress string,
 	contractName string,

pkg/transaction/builder_test.go

@@ -7,7 +7,9 @@ import (
 	"testing"
 
 	"github.com/icon-project/stacks-go-sdk/pkg/clarity"
+	"github.com/icon-project/stacks-go-sdk/pkg/crypto"
 	"github.com/icon-project/stacks-go-sdk/pkg/stacks"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestMakeSTXTokenTransfer(t *testing.T) {
@@ -74,3 +76,111 @@ func TestMakeSTXTokenTransfer(t *testing.T) {
 		t.Errorf("Expected nonce %d, got %d", specifiedNonce.Uint64(), tx2.Auth.OriginAuth.Nonce)
 	}
 }
+
+func TestMakeContractDeploy(t *testing.T) {
+	contractName := "test-contract"
+	codeBody := `(define-data-var counter int 0)
+(define-public (increment)
+    (ok (var-set counter (+ (var-get counter) 1))))
+`
+	network := stacks.NewStacksTestnet()
+	senderAddress := "ST15C893XJFJ6FSKM020P9JQDB5T7X6MQTXMBPAVH"
+	senderKeyHex := "c1d5bb638aa70862621667f9997711fce692cad782694103f8d9561f62e9f19701"
+	senderKey, _ := hex.DecodeString(senderKeyHex)
+
+	tests := []struct {
+		name         string
+		contractName string
+		codeBody     string
+		fee          *big.Int
+		nonce        *big.Int
+		expectedErr  bool
+	}{
+		{
+			name:         "Valid contract with auto fee and nonce",
+			contractName: contractName,
+			codeBody:     codeBody,
+			fee:          nil,
+			nonce:        nil,
+			expectedErr:  false,
+		},
+		{
+			name:         "Valid contract with specified fee and nonce",
+			contractName: contractName,
+			codeBody:     codeBody,
+			fee:          big.NewInt(1000),
+			nonce:        big.NewInt(1),
+			expectedErr:  false,
+		},
+		{
+			name:         "Empty contract name",
+			contractName: "",
+			codeBody:     codeBody,
+			fee:          nil,
+			nonce:        nil,
+			expectedErr:  true,
+		},
+		{
+			name:         "Empty code body",
+			contractName: contractName,
+			codeBody:     "",
+			fee:          nil,
+			nonce:        nil,
+			expectedErr:  true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tx, err := MakeContractDeploy(
+				tt.contractName,
+				tt.codeBody,
+				*network,
+				senderAddress,
+				senderKey,
+				tt.fee,
+				tt.nonce,
+			)
+
+			if tt.expectedErr {
+				assert.Error(t, err)
+				assert.Nil(t, tx)
+				return
+			}
+
+			assert.NoError(t, err)
+			assert.NotNil(t, tx)
+
+			assert.Equal(t, tt.contractName, tx.Payload.ContractName)
+			assert.Equal(t, tt.codeBody, tx.Payload.CodeBody)
+
+			if tt.fee != nil {
+				assert.Equal(t, tt.fee.Uint64(), tx.Auth.OriginAuth.Fee)
+			} else {
+				assert.Greater(t, tx.Auth.OriginAuth.Fee, uint64(0), "Fee should be estimated")
+			}
+
+			if tt.nonce != nil {
+				assert.Equal(t, tt.nonce.Uint64(), tx.Auth.OriginAuth.Nonce)
+			} else {
+				assert.Greater(t, tx.Auth.OriginAuth.Nonce, uint64(0), "Nonce should be fetched")
+			}
+
+			senderPublicKey := crypto.GetPublicKeyFromPrivate(senderKey)
+			isValid, err := VerifyTransaction(tx, senderPublicKey)
+			assert.NoError(t, err)
+			assert.True(t, isValid)
+
+			serialized, err := tx.Serialize()
+			assert.NoError(t, err)
+
+			deserialized, err := DeserializeTransaction(serialized)
+			assert.NoError(t, err)
+
+			contractTx, ok := deserialized.(*SmartContractTransaction)
+			assert.True(t, ok)
+			assert.Equal(t, tx.Payload.ContractName, contractTx.Payload.ContractName)
+			assert.Equal(t, tx.Payload.CodeBody, contractTx.Payload.CodeBody)
+		})
+	}
+}

pkg/transaction/payload.go

@@ -4,6 +4,8 @@ import (
 	"bytes"
 	"encoding/binary"
 	"errors"
+	"fmt"
+	"unicode"
 
 	"github.com/icon-project/stacks-go-sdk/internal/utils"
 	"github.com/icon-project/stacks-go-sdk/pkg/clarity"
@@ -21,6 +23,11 @@ type TokenTransferPayload struct {
 	Memo      string
 }
 
+type SmartContractPayload struct {
+	ContractName string
+	CodeBody     string
+}
+
 type ContractCallPayload struct {
 	ContractAddress clarity.ClarityValue // Can be either StandardPrincipal or ContractPrincipal
 	ContractName    string
@@ -32,6 +39,10 @@ func (t *TokenTransferTransaction) GetPayload() Payload {
 	return &t.Payload
 }
 
+func (t *SmartContractTransaction) GetPayload() Payload {
+	return &t.Payload
+}
+
 func (t *ContractCallTransaction) GetPayload() Payload {
 	return &t.Payload
 }
@@ -49,6 +60,21 @@ func NewTokenTransferPayload(recipient string, amount uint64, memo string) (*Tok
 	}, nil
 }
 
+func NewSmartContractPayload(contractName string, codeBody string) (*SmartContractPayload, error) {
+	if err := validateContractName(contractName); err != nil {
+		return nil, err
+	}
+
+	if err := validateCodeBody(codeBody); err != nil {
+		return nil, err
+	}
+
+	return &SmartContractPayload{
+		ContractName: contractName,
+		CodeBody:     codeBody,
+	}, nil
+}
+
 func NewContractCallPayload(contractAddress string, contractName string, functionName string, functionArgs []clarity.ClarityValue) (*ContractCallPayload, error) {
 	principalCV, err := clarity.StringToPrincipal(contractAddress)
 	if err != nil {
@@ -114,6 +140,63 @@ func (p *TokenTransferPayload) Deserialize(data []byte) (int, error) {
 	return offset, nil
 }
 
+func (p *SmartContractPayload) Serialize() ([]byte, error) {
+	buf := make([]byte, 0, len(p.ContractName)+len(p.CodeBody)+6) // 1 + 1 + 4 bytes for headers
+
+	// Payload type
+	buf = append(buf, byte(stacks.PayloadTypeSmartContract))
+
+	// Contract name
+	if len(p.ContractName) > stacks.MaxStringLengthBytes {
+		return nil, fmt.Errorf("contract name exceeds maximum length of %d", stacks.MaxStringLengthBytes)
+	}
+	buf = append(buf, byte(len(p.ContractName)))
+	buf = append(buf, []byte(p.ContractName)...)
+
+	// Code body with 4-byte length prefix
+	codeBodyLen := make([]byte, 4)
+	binary.BigEndian.PutUint32(codeBodyLen, uint32(len(p.CodeBody)))
+	buf = append(buf, codeBodyLen...)
+	buf = append(buf, []byte(p.CodeBody)...)
+
+	return buf, nil
+}
+
+func (p *SmartContractPayload) Deserialize(data []byte) (int, error) {
+	if len(data) < 2 || stacks.PayloadType(data[0]) != stacks.PayloadTypeSmartContract {
+		return 0, errors.New("invalid smart contract payload")
+	}
+
+	offset := 1
+
+	// Contract name
+	nameLen := int(data[offset])
+	offset++
+	if nameLen > stacks.MaxStringLengthBytes {
+		return 0, fmt.Errorf("contract name length %d exceeds maximum %d", nameLen, stacks.MaxStringLengthBytes)
+	}
+	if len(data[offset:]) < nameLen {
+		return 0, errors.New("insufficient data for contract name")
+	}
+	p.ContractName = string(data[offset : offset+nameLen])
+	offset += nameLen
+
+	// Code body
+	if len(data[offset:]) < 4 {
+		return 0, errors.New("insufficient data for code body length")
+	}
+	codeBodyLen := binary.BigEndian.Uint32(data[offset : offset+4])
+	offset += 4
+
+	if len(data[offset:]) < int(codeBodyLen) {
+		return 0, errors.New("insufficient data for code body")
+	}
+	p.CodeBody = string(data[offset : offset+int(codeBodyLen)])
+	offset += int(codeBodyLen)
+
+	return offset, nil
+}
+
 func (p *ContractCallPayload) Serialize() ([]byte, error) {
 	buf := make([]byte, 0, 128)
 
@@ -202,3 +285,32 @@ func (p *ContractCallPayload) Deserialize(data []byte) (int, error) {
 
 	return offset, nil
 }
+
+func validateContractName(name string) error {
+	if len(name) == 0 || len(name) > stacks.MaxStringLengthBytes {
+		return fmt.Errorf("contract name must be between 1 and %d characters", stacks.MaxStringLengthBytes)
+	}
+
+	// First character must be a letter
+	if !unicode.IsLetter(rune(name[0])) {
+		return errors.New("contract name must start with a letter")
+	}
+
+	// Subsequent characters must be letters, numbers, hyphens, or underscores
+	for _, r := range name[1:] {
+		if !unicode.IsLetter(r) && !unicode.IsNumber(r) && r != '-' && r != '_' {
+			return errors.New("contract name can only contain letters, numbers, hyphens, and underscores")
+		}
+	}
+
+	return nil
+}
+
+func validateCodeBody(code string) error {
+	for i, r := range code {
+		if r != '\n' && r != '\t' && (r < 0x20 || r > 0x7e) {
+			return fmt.Errorf("invalid character in code body at position %d: %q", i, r)
+		}
+	}
+	return nil
+}