Account Types

type Account struct {
	Provider     rpc.RPCProvider
	ChainID      *felt.Felt
	Address      *felt.Felt
	CairoVersion CairoVersion
	// contains filtered or unexported fields
}

Provider rpc.RPCProvider

ChainID *felt.Felt

Address *felt.Felt

CairoVersion CairoVersion

package main
 
import (
	"context"
	"fmt"
	"log"
 
	"github.com/NethermindEth/starknet.go/account"
	"github.com/NethermindEth/starknet.go/rpc"
	"github.com/NethermindEth/starknet.go/utils"
)
 
func main() {
	// Create provider
	provider, err := rpc.NewProvider("https://starknet-sepolia.public.blastapi.io/rpc/v0_8")
	if err != nil {
		log.Fatal(err)
	}
 
	// Generate keys
	ks, pubKey, _ := account.GetRandomKeys()
 
	// Create account
	accountAddress, _ := utils.HexToFelt("0x1234...")
	acc, err := account.NewAccount(provider, accountAddress, pubKey.String(), ks, account.CairoV2)
	if err != nil {
		log.Fatal(err)
	}
 
	// Access account fields
	fmt.Printf("Address: %s\n", acc.Address.String())
	fmt.Printf("Chain ID: %s\n", acc.ChainID.String())
	fmt.Printf("Cairo Version: %d\n", acc.CairoVersion)
 
	// Use account
	nonce, err := acc.Nonce(context.Background())
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Nonce: %s\n", nonce.String())
}

type AccountInterface interface {
	BuildAndEstimateDeployAccountTxn(
		ctx context.Context,
		salt *felt.Felt,
		classHash *felt.Felt,
		constructorCalldata []*felt.Felt,
		opts *TxnOptions,
	) (*rpc.BroadcastDeployAccountTxnV3, *felt.Felt, error)
 
	BuildAndSendInvokeTxn(
		ctx context.Context,
		functionCalls []rpc.InvokeFunctionCall,
		opts *TxnOptions,
	) (rpc.AddInvokeTransactionResponse, error)
 
	BuildAndSendDeclareTxn(
		ctx context.Context,
		casmClass *contracts.CasmClass,
		contractClass *contracts.ContractClass,
		opts *TxnOptions,
	) (rpc.AddDeclareTransactionResponse, error)
 
	DeployContractWithUDC(
		ctx context.Context,
		classHash *felt.Felt,
		constructorCalldata []*felt.Felt,
		txnOpts *TxnOptions,
		udcOpts *UDCOptions,
	) (rpc.AddInvokeTransactionResponse, *felt.Felt, error)
 
	Nonce(ctx context.Context) (*felt.Felt, error)
 
	SendTransaction(
		ctx context.Context,
		txn rpc.BroadcastTxn,
	) (rpc.TransactionResponse, error)
 
	Sign(ctx context.Context, msg *felt.Felt) ([]*felt.Felt, error)
 
	SignInvokeTransaction(ctx context.Context, tx rpc.InvokeTxnType) error
 
	SignDeployAccountTransaction(
		ctx context.Context,
		tx rpc.DeployAccountType,
		precomputeAddress *felt.Felt,
	) error
 
	SignDeclareTransaction(ctx context.Context, tx rpc.DeclareTxnType) error
 
	TransactionHashInvoke(invokeTxn rpc.InvokeTxnType) (*felt.Felt, error)
 
	TransactionHashDeployAccount(
		tx rpc.DeployAccountType,
		contractAddress *felt.Felt,
	) (*felt.Felt, error)
 
	TransactionHashDeclare(tx rpc.DeclareTxnType) (*felt.Felt, error)
 
	Verify(msgHash *felt.Felt, signature []*felt.Felt) (bool, error)
 
	WaitForTransactionReceipt(
		ctx context.Context,
		transactionHash *felt.Felt,
		pollInterval time.Duration,
	) (*rpc.TransactionReceiptWithBlockInfo, error)
}

package main
 
import (
	"context"
	"fmt"
 
	"github.com/NethermindEth/starknet.go/account"
	"github.com/NethermindEth/starknet.go/rpc"
)
 
// Function accepting any account implementation
func GetAccountInfo(acc account.AccountInterface) error {
	nonce, err := acc.Nonce(context.Background())
	if err != nil {
		return err
	}
 
	fmt.Printf("Account nonce: %s\n", nonce.String())
	return nil
}
 
func main() {
	// Can pass any AccountInterface implementation
	var acc *account.Account // Standard account
	GetAccountInfo(acc)
 
	// Or a custom implementation
	// var customAcc account.AccountInterface = &CustomAccount{}
	// GetAccountInfo(customAcc)
}

package main
 
import (
	"context"
	"time"
 
	"github.com/NethermindEth/juno/core/felt"
	"github.com/NethermindEth/starknet.go/account"
	"github.com/NethermindEth/starknet.go/contracts"
	"github.com/NethermindEth/starknet.go/rpc"
)
 
// CustomAccount implements AccountInterface with custom behavior
type CustomAccount struct {
	*account.Account
	// Additional fields...
}
 
// Override methods as needed
func (ca *CustomAccount) BuildAndSendInvokeTxn(
	ctx context.Context,
	functionCalls []rpc.InvokeFunctionCall,
	opts *account.TxnOptions,
) (rpc.AddInvokeTransactionResponse, error) {
	// Custom logic before sending
	fmt.Println("Custom account sending transaction...")
 
	// Call base implementation or implement from scratch
	return ca.Account.BuildAndSendInvokeTxn(ctx, functionCalls, opts)
}
 
// Ensure CustomAccount implements AccountInterface
var _ account.AccountInterface = (*CustomAccount)(nil)

type CairoVersion int
 
const (
	CairoV0 CairoVersion = 0
	CairoV2 CairoVersion = 2
)

const CairoV0 CairoVersion = 0

const CairoV2 CairoVersion = 2

package main
 
import (
	"fmt"
 
	"github.com/NethermindEth/starknet.go/account"
)
 
func main() {
	// Create account with Cairo 2
	acc, err := account.NewAccount(provider, address, pubKey, ks, account.CairoV2)
	if err != nil {
		log.Fatal(err)
	}
 
	// Check Cairo version
	if acc.CairoVersion == account.CairoV0 {
		fmt.Println("Using Cairo 0 account")
	} else if acc.CairoVersion == account.CairoV2 {
		fmt.Println("Using Cairo 2 account")
	}
 
	// The account automatically formats calldata based on its version
	response, err := acc.BuildAndSendInvokeTxn(ctx, functionCalls, nil)
}

type TxnOptions struct {
	// The multiplier to be used when estimating the tip when no custom tip is set.
	// If <= 0, it'll be set to 1.0 (no multiplier, just the estimated tip).
	TipMultiplier float64
 
	// A custom tip amount in FRI for the transaction in hexadecimal format.
	// If not set, the tip will be automatically estimated for the transaction.
	CustomTip rpc.U64
 
	// A boolean flag indicating whether the transaction version should have
	// the query bit when estimating fees. If true, the transaction version
	// will be `rpc.TransactionV3WithQueryBit` (0x100000000000000000000000000000003).
	// If false, the transaction version will be `rpc.TransactionV3` (0x3).
	// In case of doubt, set to `false`. Default: `false`.
	UseQueryBit bool
 
	// A safety factor for fee estimation that helps prevent transaction
	// failures due to fee fluctuations. It multiplies both the max amount
	// and max price per unit by this value.
	// A value of 1.5 (estimated fee + 50%) is recommended to balance between
	// transaction success rate and avoiding excessive fees. Higher values
	// provide more safety margin but may result in overpayment.
	// If FeeMultiplier <= 0, it'll be set to 1.5.
	FeeMultiplier float64
 
	// A boolean flag indicating whether to use the latest block tag
	// when estimating fees instead of the pre_confirmed block. Default: `false`.
	UseLatest bool
 
	// The simulation flag to be used when estimating fees. Default: none.
	SimulationFlag rpc.SimulationFlag
}

TipMultiplier float64

CustomTip rpc.U64

UseQueryBit bool

FeeMultiplier float64

UseLatest bool

SimulationFlag rpc.SimulationFlag

package main
 
import (
	"context"
	"log"
 
	"github.com/NethermindEth/starknet.go/account"
	"github.com/NethermindEth/starknet.go/rpc"
)
 
func main() {
	// Assume acc and functionCalls are already created
	var acc *account.Account
	var functionCalls []rpc.InvokeFunctionCall
 
	// Example 1: Use default options (nil)
	response, err := acc.BuildAndSendInvokeTxn(context.Background(), functionCalls, nil)
	if err != nil {
		log.Fatal(err)
	}
 
	// Example 2: Configure specific options with auto-estimated tip
	opts := &account.TxnOptions{
		TipMultiplier:  1.5,              // Add 50% to estimated tip
		UseQueryBit:    false,            // Standard version
		FeeMultiplier:  1.5,              // 50% safety margin
		UseLatest:      false,            // Use pre_confirmed block
		SimulationFlag: rpc.SkipValidate, // Skip validation
	}
 
	response, err = acc.BuildAndSendInvokeTxn(context.Background(), functionCalls, opts)
	if err != nil {
		log.Fatal(err)
	}
 
	// Example 3: Custom tip amount
	customTipOpts := &account.TxnOptions{
		CustomTip:     "0x1000",  // Custom tip of 4096 FRI
		FeeMultiplier: 1.5,       // 50% safety margin
	}
 
	response, err = acc.BuildAndSendInvokeTxn(context.Background(), functionCalls, customTipOpts)
	if err != nil {
		log.Fatal(err)
	}
 
	// Example 4: Conservative fee estimation
	conservativeOpts := &account.TxnOptions{
		FeeMultiplier: 2.0,  // 100% safety margin
		UseLatest:     true, // Use latest block
	}
 
	response, err = acc.BuildAndSendInvokeTxn(context.Background(), functionCalls, conservativeOpts)
}

func (opts *TxnOptions) BlockID() rpc.BlockID

opts := &account.TxnOptions{UseLatest: true}
blockID := opts.BlockID() // Returns WithBlockTag("latest")

func (opts *TxnOptions) FmtFeeMultiplier() float64

opts := &account.TxnOptions{FeeMultiplier: 2.0}
multiplier := opts.FmtFeeMultiplier() // Returns 2.0
 
nilOpts := &account.TxnOptions{}
multiplier = nilOpts.FmtFeeMultiplier() // Returns 1.5 (default)

func (opts *TxnOptions) FmtTipMultiplier() float64

opts := &account.TxnOptions{TipMultiplier: 1.5}
multiplier := opts.FmtTipMultiplier() // Returns 1.5
 
nilOpts := &account.TxnOptions{}
multiplier = nilOpts.FmtTipMultiplier() // Returns 1.0 (default)

func (opts *TxnOptions) SimulationFlags() []rpc.SimulationFlag

opts := &account.TxnOptions{SimulationFlag: rpc.SkipValidate}
flags := opts.SimulationFlags() // Returns []rpc.SimulationFlag{rpc.SkipValidate}
 
nilOpts := &account.TxnOptions{}
flags = nilOpts.SimulationFlags() // Returns []rpc.SimulationFlag{}

// These are equivalent:
acc.BuildAndSendInvokeTxn(ctx, calls, nil)
 
acc.BuildAndSendInvokeTxn(ctx, calls, &account.TxnOptions{
	TipMultiplier:  1.0,   // No tip multiplier (use estimated tip)
	CustomTip:      "",    // No custom tip (auto-estimate)
	UseQueryBit:    false, // Use standard transaction version
	FeeMultiplier:  1.5,   // 50% safety margin for fees
	UseLatest:      false, // Use pre_confirmed block
	SimulationFlag: "",    // No simulation flags
})

// Low risk, predictable fees (testnet, low value)
opts := &account.TxnOptions{FeeMultiplier: 1.2} // 20% safety
 
// Recommended for most cases
opts := &account.TxnOptions{FeeMultiplier: 1.5} // 50% safety (default)
 
// High risk or volatile fees (mainnet, high value)
opts := &account.TxnOptions{FeeMultiplier: 2.0} // 100% safety
 
// Maximum safety (critical transactions)
opts := &account.TxnOptions{FeeMultiplier: 3.0} // 200% safety

// Use estimated tip as-is (default)
opts := &account.TxnOptions{TipMultiplier: 1.0}
 
// Add safety margin to estimated tip
opts := &account.TxnOptions{TipMultiplier: 1.5} // 50% higher tip
 
// Set custom tip for guaranteed prioritization
opts := &account.TxnOptions{CustomTip: "0x2710"} // 10000 FRI custom tip
 
// No tip (may be slower)
opts := &account.TxnOptions{CustomTip: "0x0"} // Explicitly set to 0

type UDCOptions = utils.UDCOptions

type UDCOptions struct {
	Salt   *felt.Felt // Salt for address computation
	Unique bool       // Whether to make address unique to deployer
}

package main
 
import (
	"context"
	"fmt"
	"log"
 
	"github.com/NethermindEth/juno/core/felt"
	"github.com/NethermindEth/starknet.go/account"
	"github.com/NethermindEth/starknet.go/utils"
)
 
func main() {
	// Assume acc is already created
	var acc *account.Account
	var classHash *felt.Felt
	var constructorCalldata []*felt.Felt
 
	// Example 1: Use default options (random salt, unique=true)
	response, salt, err := acc.DeployContractWithUDC(
		context.Background(),
		classHash,
		constructorCalldata,
		nil, // Transaction options
		nil, // UDC options - will use defaults
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Deployed with random salt: %s\n", salt.String())
 
	// Example 2: Specify custom salt
	udcOpts := &utils.UDCOptions{
		Salt:   new(felt.Felt).SetUint64(42),
		Unique: true,
	}
 
	response, salt, err = acc.DeployContractWithUDC(
		context.Background(),
		classHash,
		constructorCalldata,
		nil,
		udcOpts,
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Deployed with custom salt: %s\n", salt.String())
 
	// Example 3: Non-unique deployment (counterfactual address)
	nonUniqueOpts := &utils.UDCOptions{
		Salt:   new(felt.Felt).SetUint64(123),
		Unique: false, // Anyone can deploy to this address
	}
 
	response, salt, err = acc.DeployContractWithUDC(
		context.Background(),
		classHash,
		constructorCalldata,
		nil,
		nonUniqueOpts,
	)
}

// After deployment, calculate the address
deployedAddress := utils.CalculateUDCAddress(
	classHash,
	salt,
	constructorCalldata,
	acc.Address, // Include if Unique: true
)
fmt.Printf("Contract deployed at: %s\n", deployedAddress.String())

var ErrTxnTypeUnSupported = errors.New("unsupported transaction type")

hash, err := acc.TransactionHashInvoke(invalidTxType)
if err != nil {
	if errors.Is(err, account.ErrTxnTypeUnSupported) {
		fmt.Println("Transaction type not supported")
	}
}

var ErrTxnVersionUnSupported = errors.New("unsupported transaction version")

hash, err := acc.TransactionHashDeclare(declareTxnV0)
if err != nil {
	if errors.Is(err, account.ErrTxnVersionUnSupported) {
		fmt.Println("Declare V0 hash calculation not supported")
	}
}

var ErrSenderNoExist = errors.New("sender does not exist")

key, err := ks.Get(publicKey)
if err != nil {
	if errors.Is(err, account.ErrSenderNoExist) {
		fmt.Println("Key not found in keystore")
	}
}