Token v0 foundation (#101)

token V.0  foundation, state interface refactoring

Author: vitiko

examples/token/chaincode/erc20/README.md

@@ -0,0 +1,8 @@
+# ERC-20 token with fixed `total supply`
+
+With:
+
+* [addresses](../../service/account)
+* [config for 1 token per chaincode](../../service/config_erc20)
+* [balances and transfers between balances](../../service/balance)
+* [allowance and transfers by spender from owner account](../../service/allowance)

examples/token/chaincode/erc20/erc20.go

@@ -0,0 +1,74 @@
+package erc20
+
+import (
+	"errors"
+
+	"github.com/s7techlab/cckit/examples/token/service/account"
+	"github.com/s7techlab/cckit/examples/token/service/allowance"
+	"github.com/s7techlab/cckit/examples/token/service/balance"
+	"github.com/s7techlab/cckit/examples/token/service/config"
+	"github.com/s7techlab/cckit/examples/token/service/config_erc20"
+	"github.com/s7techlab/cckit/router"
+)
+
+var (
+	Token = &config.CreateTokenTypeRequest{
+		Name:        `SomeToken`,
+		Symbol:      `@`,
+		Decimals:    2,
+		TotalSupply: 10000000,
+	}
+)
+
+func New() (*router.Chaincode, error) {
+	r := router.New(`erc20`)
+
+	// accountSvc resolves address as base58( invoker.Cert.PublicKey )
+	accountSvc := account.NewLocalService()
+	configSvc := config.NewStateService()
+	// Balance management service
+	balanceSvc := balance.New(accountSvc, configSvc)
+	// Allowance management service
+	allowanceSvc := allowance.NewService(balanceSvc)
+
+	erc20ConfigSvc := &config_erc20.ERC20Service{Token: configSvc}
+
+	r.Init(func(ctx router.Context) (interface{}, error) {
+		// add token definition to state if not exists
+		token, err := config.CreateDefaultToken(ctx, configSvc, Token)
+		if err != nil {
+			if errors.Is(err, config.ErrTokenAlreadyExists) {
+				return nil, nil
+			}
+			return nil, err
+		}
+
+		// get chaincode instantiator address
+		ownerAddress, err := accountSvc.GetInvokerAddress(ctx, nil)
+		if err != nil {
+			return nil, err
+		}
+
+		// add  `TotalSupply` to chaincode first committer
+		if err = balance.NewStore(ctx).Add(ownerAddress.Address, token, Token.TotalSupply); err != nil {
+			return nil, err
+		}
+
+		return nil, nil
+	})
+
+	if err := balance.RegisterBalanceServiceChaincode(r, balanceSvc); err != nil {
+		return nil, err
+	}
+	if err := account.RegisterAccountServiceChaincode(r, accountSvc); err != nil {
+		return nil, err
+	}
+	if err := config_erc20.RegisterConfigERC20ServiceChaincode(r, erc20ConfigSvc); err != nil {
+		return nil, err
+	}
+	if err := allowance.RegisterAllowanceServiceChaincode(r, allowanceSvc); err != nil {
+		return nil, err
+	}
+
+	return router.NewChaincode(r), nil
+}

examples/token/chaincode/erc20/erc20_test.go

@@ -0,0 +1,216 @@
+package erc20_test
+
+import (
+	"encoding/base64"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"github.com/s7techlab/cckit/examples/token/chaincode/erc20"
+	"github.com/s7techlab/cckit/examples/token/service/account"
+	"github.com/s7techlab/cckit/examples/token/service/allowance"
+	"github.com/s7techlab/cckit/examples/token/service/balance"
+	"github.com/s7techlab/cckit/examples/token/service/config_erc20"
+	"github.com/s7techlab/cckit/identity"
+	"github.com/s7techlab/cckit/identity/testdata"
+	testcc "github.com/s7techlab/cckit/testing"
+	expectcc "github.com/s7techlab/cckit/testing/expect"
+)
+
+func TestERC20(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "ERC20 Test suite")
+}
+
+var (
+	ownerIdentity = testdata.Certificates[0].MustIdentity(testdata.DefaultMSP)
+	user1Identity = testdata.Certificates[1].MustIdentity(testdata.DefaultMSP)
+	user2Identity = testdata.Certificates[2].MustIdentity(testdata.DefaultMSP)
+
+	ownerAddress = base64.StdEncoding.EncodeToString(identity.MarshalPublicKey(ownerIdentity.Cert.PublicKey))
+	user1Address = base64.StdEncoding.EncodeToString(identity.MarshalPublicKey(user1Identity.Cert.PublicKey))
+	user2Address = base64.StdEncoding.EncodeToString(identity.MarshalPublicKey(user2Identity.Cert.PublicKey))
+
+	cc *testcc.MockStub
+)
+
+var _ = Describe(`ERC`, func() {
+
+	BeforeSuite(func() {
+		chaincode, err := erc20.New()
+		Expect(err).NotTo(HaveOccurred())
+		cc = testcc.NewMockStub(`erc20`, chaincode)
+
+		expectcc.ResponseOk(cc.From(ownerIdentity).Init())
+	})
+
+	It(`Allow to call init once more time `, func() {
+		expectcc.ResponseOk(cc.From(ownerIdentity).Init())
+	})
+
+	Context(`token info`, func() {
+
+		It(`Allow to get token name`, func() {
+			name := expectcc.PayloadIs(
+				cc.From(user1Identity).
+					Query(config_erc20.ConfigERC20ServiceChaincode_GetName, nil),
+				&config_erc20.NameResponse{}).(*config_erc20.NameResponse)
+
+			Expect(name.Name).To(Equal(erc20.Token.Name))
+		})
+	})
+
+	Context(`initial balance`, func() {
+
+		It(`Allow to know invoker address `, func() {
+			address := expectcc.PayloadIs(
+				cc.From(user1Identity).
+					Query(account.AccountServiceChaincode_GetInvokerAddress, nil),
+				&account.AddressId{}).(*account.AddressId)
+
+			Expect(address.Address).To(Equal(user1Address))
+
+			address = expectcc.PayloadIs(
+				cc.From(user2Identity).
+					Query(account.AccountServiceChaincode_GetInvokerAddress, nil),
+				&account.AddressId{}).(*account.AddressId)
+
+			Expect(address.Address).To(Equal(user2Address))
+		})
+
+		It(`Allow to get owner balance`, func() {
+			b := expectcc.PayloadIs(
+				cc.From(user1Identity). // call by any user
+							Query(balance.BalanceServiceChaincode_GetBalance,
+						&balance.BalanceId{Address: ownerAddress, Token: []string{erc20.Token.Name}}),
+				&balance.Balance{}).(*balance.Balance)
+
+			Expect(b.Address).To(Equal(ownerAddress))
+			Expect(b.Amount).To(Equal(uint64(erc20.Token.TotalSupply)))
+		})
+
+		It(`Allow to get zero balance`, func() {
+			b := expectcc.PayloadIs(
+				cc.From(user1Identity).
+					Query(balance.BalanceServiceChaincode_GetBalance,
+						&balance.BalanceId{Address: user1Address, Token: []string{erc20.Token.Name}}),
+				&balance.Balance{}).(*balance.Balance)
+
+			Expect(b.Amount).To(Equal(uint64(0)))
+		})
+
+	})
+
+	Context(`transfer`, func() {
+		var transferAmount uint64 = 100
+
+		It(`Disallow to transfer balance by user with zero balance`, func() {
+			expectcc.ResponseError(
+				cc.From(user1Identity).
+					Invoke(balance.BalanceServiceChaincode_Transfer,
+						&balance.TransferRequest{
+							RecipientAddress: user2Address,
+							Token:            []string{erc20.Token.Name},
+							Amount:           transferAmount,
+						}), balance.ErrAmountInsuficcient)
+
+		})
+
+		It(`Allow to transfer balance by owner`, func() {
+			r := expectcc.PayloadIs(
+				cc.From(ownerIdentity).
+					Invoke(balance.BalanceServiceChaincode_Transfer,
+						&balance.TransferRequest{
+							RecipientAddress: user1Address,
+							Token:            []string{erc20.Token.Name},
+							Amount:           transferAmount,
+						}),
+				&balance.TransferResponse{}).(*balance.TransferResponse)
+
+			Expect(r.SenderAddress).To(Equal(ownerAddress))
+			Expect(r.Amount).To(Equal(transferAmount))
+		})
+
+		It(`Allow to get new non zero balance`, func() {
+			b := expectcc.PayloadIs(
+				cc.From(user1Identity).
+					Query(balance.BalanceServiceChaincode_GetBalance,
+						&balance.BalanceId{Address: user1Address, Token: []string{erc20.Token.Name}}),
+				&balance.Balance{}).(*balance.Balance)
+
+			Expect(b.Amount).To(Equal(transferAmount))
+		})
+
+	})
+
+	Context(`Allowance`, func() {
+
+		var allowAmount uint64 = 50
+
+		It(`Allow to approve amount by owner for spender even if balance is zero`, func() {
+			a := expectcc.PayloadIs(
+				cc.From(user2Identity).
+					Invoke(allowance.AllowanceServiceChaincode_Approve,
+						&allowance.ApproveRequest{
+							OwnerAddress:   user2Address,
+							SpenderAddress: user1Address,
+							Token:          []string{erc20.Token.Name},
+							Amount:         allowAmount,
+						}),
+				&allowance.Allowance{}).(*allowance.Allowance)
+
+			Expect(a.OwnerAddress).To(Equal(user2Address))
+			Expect(a.SpenderAddress).To(Equal(user1Address))
+			Expect(a.Amount).To(Equal(allowAmount))
+		})
+		It(`Disallow to approve amount by non owner`, func() {
+			expectcc.ResponseError(
+				cc.From(user2Identity).
+					Invoke(allowance.AllowanceServiceChaincode_Approve,
+						&allowance.ApproveRequest{
+							OwnerAddress:   ownerAddress,
+							SpenderAddress: user1Address,
+							Token:          []string{erc20.Token.Name},
+							Amount:         allowAmount,
+						}), allowance.ErrOwnerOnly)
+		})
+
+		It(`Allow to approve amount by owner for spender if amount is sufficient`, func() {
+			a := expectcc.PayloadIs(
+				cc.From(ownerIdentity).
+					Invoke(allowance.AllowanceServiceChaincode_Approve,
+						&allowance.ApproveRequest{
+							OwnerAddress:   ownerAddress,
+							SpenderAddress: user2Address,
+							Token:          []string{erc20.Token.Name},
+							Amount:         allowAmount,
+						}),
+				&allowance.Allowance{}).(*allowance.Allowance)
+
+			Expect(a.OwnerAddress).To(Equal(ownerAddress))
+			Expect(a.SpenderAddress).To(Equal(user2Address))
+			Expect(a.Amount).To(Equal(allowAmount))
+		})
+
+		It(`Allow to transfer from`, func() {
+			spenderIdentity := user2Identity
+			spenderAddress := user2Address
+
+			t := expectcc.PayloadIs(
+				cc.From(spenderIdentity).
+					Invoke(allowance.AllowanceServiceChaincode_TransferFrom,
+						&allowance.TransferFromRequest{
+							OwnerAddress:     ownerAddress,
+							RecipientAddress: spenderAddress,
+							Token:            []string{erc20.Token.Name},
+							Amount:           allowAmount,
+						}),
+				&allowance.TransferFromResponse{}).(*allowance.TransferFromResponse)
+
+			Expect(t.OwnerAddress).To(Equal(ownerAddress))
+			Expect(t.RecipientAddress).To(Equal(spenderAddress))
+			Expect(t.Amount).To(Equal(allowAmount))
+		})
+	})
+})

examples/token/service/account/account.go

@@ -0,0 +1,41 @@
+package account
+
+import (
+	"encoding/base64"
+	"errors"
+
+	"google.golang.org/protobuf/types/known/emptypb"
+
+	"github.com/s7techlab/cckit/identity"
+	"github.com/s7techlab/cckit/router"
+)
+
+type LocalService struct {
+}
+
+func NewLocalService() *LocalService {
+	return &LocalService{}
+}
+
+func (l *LocalService) GetInvokerAddress(ctx router.Context, _ *emptypb.Empty) (*AddressId, error) {
+	invoker, err := identity.FromStub(ctx.Stub())
+	if err != nil {
+		return nil, err
+	}
+
+	return l.GetAddress(ctx,
+		&GetAddressRequest{PublicKey: identity.MarshalPublicKey(invoker.Cert.PublicKey)})
+}
+
+func (l *LocalService) GetAddress(ctx router.Context, req *GetAddressRequest) (*AddressId, error) {
+	return &AddressId{
+		Address: base64.StdEncoding.EncodeToString(req.PublicKey),
+	}, nil
+}
+
+func (l *LocalService) GetAccount(ctx router.Context, id *AccountId) (*Account, error) {
+	return nil, errors.New(`no accounts implemented`)
+}
+
+type Remote struct {
+}