Refactor/kos-go

packages/kos-go/demo/main.go

@@ -4,17 +4,14 @@ import (
 	"encoding/hex"
 	"fmt"
 
-	"github.com/klever-io/kos-rs/packages/kos-go/kos_mobile"
+	kosgo "github.com/klever-io/kos-rs/packages/kos-go"
 )
 
 func main() {
 	chainID := uint32(18) // BCH
 
-	walletOptions := kos_mobile.WalletOptions{
-		UseLegacyPath: false,
-		Specific:      nil,
-	}
-	account, err := kos_mobile.GenerateWalletFromMnemonic(
+	walletOptions := kosgo.NewWalletOptions(false)
+	account, err := kosgo.GenerateWalletFromMnemonic(
 		"abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
 		chainID,
 		0,
@@ -27,16 +24,20 @@ func main() {
 
 	rawTx := "0100000002afa8838dbaa03cd3e4fee38bdcb6a428965559ae941dca5a8f91999cfd6d8b0d0100000000ffffffffdb6d60d4a93a95738e72f641bcdd166c94f6e1f439dfe695e40583997284463c0100000000ffffffff0240420f00000000001976a91434bf902df5d66f0e9b89d0f83fbcad638ad19ae988acea970700000000001976a9145bb0ba5ba58cdab459f27f2d29f40e1dd5db238188ac00000000"
 
-	prevScript1, _ := hex.DecodeString("76a9145bb0ba5ba58cdab459f27f2d29f40e1dd5db238188ac")
-	prevScript2, _ := hex.DecodeString("76a9145bb0ba5ba58cdab459f27f2d29f40e1dd5db238188ac")
-
-	var options kos_mobile.TransactionChainOptions = kos_mobile.TransactionChainOptions(kos_mobile.TransactionChainOptionsBtc{
+	prevScript, err := hex.DecodeString("76a9145bb0ba5ba58cdab459f27f2d29f40e1dd5db238188ac")
+	if err != nil {
+		fmt.Printf("failed to decode prevScript: %v\n", err)
+		return
+	}
+	options := kosgo.TransactionChainOptionsBtc{
+		PrevScripts:  [][]byte{prevScript, prevScript},
 		InputAmounts: []uint64{498870, 1001016},
-		PrevScripts:  [][]byte{prevScript1, prevScript2},
-	})
-	transaction, err := kos_mobile.SignTransaction(account, rawTx, &options)
+	}
+
+	transaction, err := kosgo.SignTransaction(account, rawTx, options)
 	if err != nil {
-		fmt.Printf("failed to sign transaction: %v", err)
+		fmt.Printf("failed to sign transaction: %v\n", err)
+		return
 	}
 
 	expectedRaw :=

packages/kos-go/models.go

@@ -0,0 +1,60 @@
+package kosgo
+
+import kos_mobile "github.com/klever-io/kos-rs/packages/kos-go/kos_mobile"
+
+type TransactionChainOptions = kos_mobile.TransactionChainOptions
+type TransactionChainOptionsEvm = kos_mobile.TransactionChainOptionsEvm
+type TransactionChainOptionsBtc = kos_mobile.TransactionChainOptionsBtc
+type TransactionChainOptionsSubstrate = kos_mobile.TransactionChainOptionsSubstrate
+type TransactionChainOptionsCosmos = kos_mobile.TransactionChainOptionsCosmos
+
+type WalletChainOptions = kos_mobile.WalletChainOptions
+type WalletChainOptionsCustomEth = kos_mobile.WalletChainOptionsCustomEth
+type WalletChainOptionsCustomIcp = kos_mobile.WalletChainOptionsCustomIcp
+
+type WalletOptions = kos_mobile.WalletOptions
+
+func NewSubstrateTransactionOptions(
+	call string,
+	era string,
+	nonce uint32,
+	tip uint64,
+	assetId *string,
+	blockHash string,
+	genesisHash string,
+	specVersion uint32,
+	transactionVersion uint32,
+	appId *uint32,
+	signedExtensions *[]string,
+) TransactionChainOptions {
+	return kos_mobile.NewSubstrateTransactionOptions(
+		call, era, nonce, tip, assetId,
+		blockHash, genesisHash,
+		specVersion, transactionVersion,
+		appId, signedExtensions,
+	)
+}
+
+func NewBitcoinTransactionOptions(inputAmounts []uint64, prevScripts []string) TransactionChainOptions {
+	return kos_mobile.NewBitcoinTransactionOptions(inputAmounts, prevScripts)
+}
+
+func NewEvmTransactionOptions(chainId uint32) TransactionChainOptions {
+	return kos_mobile.NewEvmTransactionOptions(chainId)
+}
+
+func NewCosmosTransactionOptions(chainId string, accountNumber uint64) TransactionChainOptions {
+	return kos_mobile.NewCosmosTransactionOptions(chainId, accountNumber)
+}
+
+func NewWalletOptions(useLegacyPath bool) WalletOptions {
+	return kos_mobile.NewWalletOptions(useLegacyPath)
+}
+
+func NewEthWalletOptions(useLegacyPath bool, chainId uint32) WalletOptions {
+	return kos_mobile.NewEthWalletOptions(useLegacyPath, chainId)
+}
+
+func NewIcpWalletOptions(useLegacyPath bool, keyType string) WalletOptions {
+	return kos_mobile.NewIcpWalletOptions(useLegacyPath, keyType)
+}

packages/kos-go/number.go

@@ -0,0 +1,182 @@
+package kosgo
+
+import (
+	"fmt"
+
+	kos_mobile "github.com/klever-io/kos-rs/packages/kos-go/kos_mobile"
+)
+
+type Sign = kos_mobile.Sign
+
+const (
+	Minus  = kos_mobile.SignMinus
+	NoSign = kos_mobile.SignNoSign
+	Plus   = kos_mobile.SignPlus
+)
+
+type BigNumber struct {
+	inner kos_mobile.BigNumber
+}
+
+func NewBigNumber(value string) (*BigNumber, error) {
+	bn, err := kos_mobile.BigNumberNew(value)
+	if err != nil {
+		return nil, fmt.Errorf("invalid number: %w", err)
+	}
+	return &BigNumber{inner: bn}, nil
+}
+
+func NewBigNumberZero() *BigNumber {
+	return &BigNumber{inner: kos_mobile.BigNumberNewZero()}
+}
+
+func (b *BigNumber) String() string {
+	if b == nil {
+		return ""
+	}
+	return kos_mobile.BigNumberString(b.inner)
+}
+
+func Add(lhs, rhs *BigNumber) (*BigNumber, error) {
+	if lhs == nil || rhs == nil {
+		return nil, fmt.Errorf("nil BigNumber operand")
+	}
+	result, err := kos_mobile.BigNumberAdd(lhs.inner, rhs.inner)
+	if err != nil {
+		return nil, err
+	}
+	return &BigNumber{inner: result}, nil
+}
+
+func Sub(lhs, rhs *BigNumber) (*BigNumber, error) {
+	if lhs == nil || rhs == nil {
+		return nil, fmt.Errorf("nil BigNumber operand")
+	}
+	result, err := kos_mobile.BigNumberSubtract(lhs.inner, rhs.inner)
+	if err != nil {
+		return nil, err
+	}
+	return &BigNumber{inner: result}, nil
+}
+
+func Mul(lhs, rhs *BigNumber) (*BigNumber, error) {
+	if lhs == nil || rhs == nil {
+		return nil, fmt.Errorf("nil BigNumber operand")
+	}
+	result, err := kos_mobile.BigNumberMultiply(lhs.inner, rhs.inner)
+	if err != nil {
+		return nil, err
+	}
+	return &BigNumber{inner: result}, nil
+}
+
+func Div(lhs, rhs *BigNumber) (*BigNumber, error) {
+	if lhs == nil || rhs == nil {
+		return nil, fmt.Errorf("nil BigNumber operand")
+	}
+	result, err := kos_mobile.BigNumberDivide(lhs.inner, rhs.inner)
+	if err != nil {
+		return nil, err
+	}
+	return &BigNumber{inner: result}, nil
+}
+
+func Pow(base, exp *BigNumber) (*BigNumber, error) {
+	if base == nil || exp == nil {
+		return nil, fmt.Errorf("nil BigNumber operand")
+	}
+	result, err := kos_mobile.BigNumberPow(base.inner, exp.inner)
+	if err != nil {
+		return nil, err
+	}
+	return &BigNumber{inner: result}, nil
+}
+
+func IsEqual(lhs, rhs *BigNumber) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	return kos_mobile.BigNumberIsEqual(lhs.inner, rhs.inner)
+}
+
+func IsGt(lhs, rhs *BigNumber) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	return kos_mobile.BigNumberIsGt(lhs.inner, rhs.inner)
+}
+
+func IsGte(lhs, rhs *BigNumber) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	return kos_mobile.BigNumberIsGte(lhs.inner, rhs.inner)
+}
+
+func IsLt(lhs, rhs *BigNumber) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	return kos_mobile.BigNumberIsLt(lhs.inner, rhs.inner)
+}
+
+func IsLte(lhs, rhs *BigNumber) bool {
+	if lhs == nil || rhs == nil {
+		return false
+	}
+	return kos_mobile.BigNumberIsLte(lhs.inner, rhs.inner)
+}
+
+func Abs(b *BigNumber) (*BigNumber, error) {
+	if b == nil {
+		return nil, fmt.Errorf("nil BigNumber operand")
+	}
+	result, err := kos_mobile.BigNumberAbsolute(b.inner)
+	if err != nil {
+		return nil, err
+	}
+	return &BigNumber{inner: result}, nil
+}
+
+func IsZero(b *BigNumber) bool {
+	if b == nil {
+		return false
+	}
+	return kos_mobile.BigNumberIsZero(b.inner)
+}
+
+func Increment(b *BigNumber) (*BigNumber, error) {
+	if b == nil {
+		return nil, fmt.Errorf("nil BigNumber operand")
+	}
+	result, err := kos_mobile.BigNumberIncrement(b.inner)
+	if err != nil {
+		return nil, err
+	}
+	return &BigNumber{inner: result}, nil
+}
+
+func Decrement(b *BigNumber) (*BigNumber, error) {
+	if b == nil {
+		return nil, fmt.Errorf("nil BigNumber operand")
+	}
+	result, err := kos_mobile.BigNumberDecrement(b.inner)
+	if err != nil {
+		return nil, err
+	}
+	return &BigNumber{inner: result}, nil
+}
+
+func IsPositive(b *BigNumber) bool {
+	if b == nil {
+		return false
+	}
+	return kos_mobile.BigNumberIsPositive(b.inner)
+}
+
+func IsNegative(b *BigNumber) bool {
+	if b == nil {
+		return false
+	}
+	return kos_mobile.BigNumberIsNegative(b.inner)
+}