github.com/s7techlab/cckit@v0.10.5/examples/erc20_service/erc20.pb.cc.go (about)

     1  // Code generated by protoc-gen-cc-gateway. DO NOT EDIT.
     2  // source: erc20_service/erc20.proto
     3  
     4  /*
     5  Package erc20_service contains
     6    *   chaincode methods names {service_name}Chaincode_{method_name}
     7    *   chaincode interface definition {service_name}Chaincode
     8    *   chaincode gateway definition {service_name}}Gateway
     9    *   chaincode service to cckit router registration func
    10  */
    11  package erc20_service
    12  
    13  import (
    14  	context "context"
    15  	_ "embed"
    16  	errors "errors"
    17  
    18  	cckit_gateway "github.com/s7techlab/cckit/gateway"
    19  	cckit_router "github.com/s7techlab/cckit/router"
    20  	cckit_defparam "github.com/s7techlab/cckit/router/param/defparam"
    21  	cckit_sdk "github.com/s7techlab/cckit/sdk"
    22  	"google.golang.org/protobuf/types/known/emptypb"
    23  )
    24  
    25  // ERC20Chaincode method names
    26  const (
    27  
    28  	// ERC20ChaincodeMethodPrefix allows to use multiple services with same method names in one chaincode
    29  	ERC20ChaincodeMethodPrefix = ""
    30  
    31  	ERC20Chaincode_Name = ERC20ChaincodeMethodPrefix + "Name"
    32  
    33  	ERC20Chaincode_Symbol = ERC20ChaincodeMethodPrefix + "Symbol"
    34  
    35  	ERC20Chaincode_Decimals = ERC20ChaincodeMethodPrefix + "Decimals"
    36  
    37  	ERC20Chaincode_TotalSupply = ERC20ChaincodeMethodPrefix + "TotalSupply"
    38  
    39  	ERC20Chaincode_BalanceOf = ERC20ChaincodeMethodPrefix + "BalanceOf"
    40  
    41  	ERC20Chaincode_Transfer = ERC20ChaincodeMethodPrefix + "Transfer"
    42  
    43  	ERC20Chaincode_Allowance = ERC20ChaincodeMethodPrefix + "Allowance"
    44  
    45  	ERC20Chaincode_Approve = ERC20ChaincodeMethodPrefix + "Approve"
    46  
    47  	ERC20Chaincode_TransferFrom = ERC20ChaincodeMethodPrefix + "TransferFrom"
    48  )
    49  
    50  // ERC20Chaincode chaincode methods interface
    51  type ERC20Chaincode interface {
    52  	Name(cckit_router.Context, *emptypb.Empty) (*NameResponse, error)
    53  
    54  	Symbol(cckit_router.Context, *emptypb.Empty) (*SymbolResponse, error)
    55  
    56  	Decimals(cckit_router.Context, *emptypb.Empty) (*DecimalsResponse, error)
    57  
    58  	TotalSupply(cckit_router.Context, *emptypb.Empty) (*TotalSupplyResponse, error)
    59  
    60  	BalanceOf(cckit_router.Context, *BalanceOfRequest) (*BalanceOfResponse, error)
    61  
    62  	Transfer(cckit_router.Context, *TransferRequest) (*TransferResponse, error)
    63  
    64  	Allowance(cckit_router.Context, *AllowanceRequest) (*AllowanceResponse, error)
    65  
    66  	Approve(cckit_router.Context, *ApproveRequest) (*ApproveResponse, error)
    67  
    68  	TransferFrom(cckit_router.Context, *TransferFromRequest) (*TransferResponse, error)
    69  }
    70  
    71  // RegisterERC20Chaincode registers service methods as chaincode router handlers
    72  func RegisterERC20Chaincode(r *cckit_router.Group, cc ERC20Chaincode) error {
    73  
    74  	r.Query(ERC20Chaincode_Name,
    75  		func(ctx cckit_router.Context) (interface{}, error) {
    76  			return cc.Name(ctx, ctx.Param().(*emptypb.Empty))
    77  		},
    78  		cckit_defparam.Proto(&emptypb.Empty{}))
    79  
    80  	r.Query(ERC20Chaincode_Symbol,
    81  		func(ctx cckit_router.Context) (interface{}, error) {
    82  			return cc.Symbol(ctx, ctx.Param().(*emptypb.Empty))
    83  		},
    84  		cckit_defparam.Proto(&emptypb.Empty{}))
    85  
    86  	r.Query(ERC20Chaincode_Decimals,
    87  		func(ctx cckit_router.Context) (interface{}, error) {
    88  			return cc.Decimals(ctx, ctx.Param().(*emptypb.Empty))
    89  		},
    90  		cckit_defparam.Proto(&emptypb.Empty{}))
    91  
    92  	r.Query(ERC20Chaincode_TotalSupply,
    93  		func(ctx cckit_router.Context) (interface{}, error) {
    94  			return cc.TotalSupply(ctx, ctx.Param().(*emptypb.Empty))
    95  		},
    96  		cckit_defparam.Proto(&emptypb.Empty{}))
    97  
    98  	r.Query(ERC20Chaincode_BalanceOf,
    99  		func(ctx cckit_router.Context) (interface{}, error) {
   100  			return cc.BalanceOf(ctx, ctx.Param().(*BalanceOfRequest))
   101  		},
   102  		cckit_defparam.Proto(&BalanceOfRequest{}))
   103  
   104  	r.Invoke(ERC20Chaincode_Transfer,
   105  		func(ctx cckit_router.Context) (interface{}, error) {
   106  			return cc.Transfer(ctx, ctx.Param().(*TransferRequest))
   107  		},
   108  		cckit_defparam.Proto(&TransferRequest{}))
   109  
   110  	r.Query(ERC20Chaincode_Allowance,
   111  		func(ctx cckit_router.Context) (interface{}, error) {
   112  			return cc.Allowance(ctx, ctx.Param().(*AllowanceRequest))
   113  		},
   114  		cckit_defparam.Proto(&AllowanceRequest{}))
   115  
   116  	r.Invoke(ERC20Chaincode_Approve,
   117  		func(ctx cckit_router.Context) (interface{}, error) {
   118  			return cc.Approve(ctx, ctx.Param().(*ApproveRequest))
   119  		},
   120  		cckit_defparam.Proto(&ApproveRequest{}))
   121  
   122  	r.Invoke(ERC20Chaincode_TransferFrom,
   123  		func(ctx cckit_router.Context) (interface{}, error) {
   124  			return cc.TransferFrom(ctx, ctx.Param().(*TransferFromRequest))
   125  		},
   126  		cckit_defparam.Proto(&TransferFromRequest{}))
   127  
   128  	return nil
   129  }
   130  
   131  //go:embed erc20.swagger.json
   132  var ERC20Swagger []byte
   133  
   134  // NewERC20Gateway creates gateway to access chaincode method via chaincode service
   135  func NewERC20Gateway(sdk cckit_sdk.SDK, channel, chaincode string, opts ...cckit_gateway.Opt) *ERC20Gateway {
   136  	return NewERC20GatewayFromInstance(
   137  		cckit_gateway.NewChaincodeInstanceService(
   138  			sdk,
   139  			&cckit_gateway.ChaincodeLocator{Channel: channel, Chaincode: chaincode},
   140  			opts...,
   141  		))
   142  }
   143  
   144  func NewERC20GatewayFromInstance(chaincodeInstance cckit_gateway.ChaincodeInstance) *ERC20Gateway {
   145  	return &ERC20Gateway{
   146  		ChaincodeInstance: chaincodeInstance,
   147  	}
   148  }
   149  
   150  // gateway implementation
   151  // gateway can be used as kind of SDK, GRPC or REST server ( via grpc-gateway or clay )
   152  type ERC20Gateway struct {
   153  	ChaincodeInstance cckit_gateway.ChaincodeInstance
   154  }
   155  
   156  func (c *ERC20Gateway) Invoker() cckit_gateway.ChaincodeInstanceInvoker {
   157  	return cckit_gateway.NewChaincodeInstanceServiceInvoker(c.ChaincodeInstance)
   158  }
   159  
   160  // ServiceDef returns service definition
   161  func (c *ERC20Gateway) ServiceDef() cckit_gateway.ServiceDef {
   162  	return cckit_gateway.NewServiceDef(
   163  		_ERC20_serviceDesc.ServiceName,
   164  		ERC20Swagger,
   165  		&_ERC20_serviceDesc,
   166  		c,
   167  		RegisterERC20HandlerFromEndpoint,
   168  	)
   169  }
   170  
   171  func (c *ERC20Gateway) Name(ctx context.Context, in *emptypb.Empty) (*NameResponse, error) {
   172  	var inMsg interface{} = in
   173  	if v, ok := inMsg.(interface{ Validate() error }); ok {
   174  		if err := v.Validate(); err != nil {
   175  			return nil, err
   176  		}
   177  	}
   178  
   179  	if res, err := c.Invoker().Query(ctx, ERC20Chaincode_Name, []interface{}{in}, &NameResponse{}); err != nil {
   180  		return nil, err
   181  	} else {
   182  		return res.(*NameResponse), nil
   183  	}
   184  }
   185  
   186  func (c *ERC20Gateway) Symbol(ctx context.Context, in *emptypb.Empty) (*SymbolResponse, error) {
   187  	var inMsg interface{} = in
   188  	if v, ok := inMsg.(interface{ Validate() error }); ok {
   189  		if err := v.Validate(); err != nil {
   190  			return nil, err
   191  		}
   192  	}
   193  
   194  	if res, err := c.Invoker().Query(ctx, ERC20Chaincode_Symbol, []interface{}{in}, &SymbolResponse{}); err != nil {
   195  		return nil, err
   196  	} else {
   197  		return res.(*SymbolResponse), nil
   198  	}
   199  }
   200  
   201  func (c *ERC20Gateway) Decimals(ctx context.Context, in *emptypb.Empty) (*DecimalsResponse, error) {
   202  	var inMsg interface{} = in
   203  	if v, ok := inMsg.(interface{ Validate() error }); ok {
   204  		if err := v.Validate(); err != nil {
   205  			return nil, err
   206  		}
   207  	}
   208  
   209  	if res, err := c.Invoker().Query(ctx, ERC20Chaincode_Decimals, []interface{}{in}, &DecimalsResponse{}); err != nil {
   210  		return nil, err
   211  	} else {
   212  		return res.(*DecimalsResponse), nil
   213  	}
   214  }
   215  
   216  func (c *ERC20Gateway) TotalSupply(ctx context.Context, in *emptypb.Empty) (*TotalSupplyResponse, error) {
   217  	var inMsg interface{} = in
   218  	if v, ok := inMsg.(interface{ Validate() error }); ok {
   219  		if err := v.Validate(); err != nil {
   220  			return nil, err
   221  		}
   222  	}
   223  
   224  	if res, err := c.Invoker().Query(ctx, ERC20Chaincode_TotalSupply, []interface{}{in}, &TotalSupplyResponse{}); err != nil {
   225  		return nil, err
   226  	} else {
   227  		return res.(*TotalSupplyResponse), nil
   228  	}
   229  }
   230  
   231  func (c *ERC20Gateway) BalanceOf(ctx context.Context, in *BalanceOfRequest) (*BalanceOfResponse, error) {
   232  	var inMsg interface{} = in
   233  	if v, ok := inMsg.(interface{ Validate() error }); ok {
   234  		if err := v.Validate(); err != nil {
   235  			return nil, err
   236  		}
   237  	}
   238  
   239  	if res, err := c.Invoker().Query(ctx, ERC20Chaincode_BalanceOf, []interface{}{in}, &BalanceOfResponse{}); err != nil {
   240  		return nil, err
   241  	} else {
   242  		return res.(*BalanceOfResponse), nil
   243  	}
   244  }
   245  
   246  func (c *ERC20Gateway) Transfer(ctx context.Context, in *TransferRequest) (*TransferResponse, error) {
   247  	var inMsg interface{} = in
   248  	if v, ok := inMsg.(interface{ Validate() error }); ok {
   249  		if err := v.Validate(); err != nil {
   250  			return nil, err
   251  		}
   252  	}
   253  
   254  	if res, err := c.Invoker().Invoke(ctx, ERC20Chaincode_Transfer, []interface{}{in}, &TransferResponse{}); err != nil {
   255  		return nil, err
   256  	} else {
   257  		return res.(*TransferResponse), nil
   258  	}
   259  }
   260  
   261  func (c *ERC20Gateway) Allowance(ctx context.Context, in *AllowanceRequest) (*AllowanceResponse, error) {
   262  	var inMsg interface{} = in
   263  	if v, ok := inMsg.(interface{ Validate() error }); ok {
   264  		if err := v.Validate(); err != nil {
   265  			return nil, err
   266  		}
   267  	}
   268  
   269  	if res, err := c.Invoker().Query(ctx, ERC20Chaincode_Allowance, []interface{}{in}, &AllowanceResponse{}); err != nil {
   270  		return nil, err
   271  	} else {
   272  		return res.(*AllowanceResponse), nil
   273  	}
   274  }
   275  
   276  func (c *ERC20Gateway) Approve(ctx context.Context, in *ApproveRequest) (*ApproveResponse, error) {
   277  	var inMsg interface{} = in
   278  	if v, ok := inMsg.(interface{ Validate() error }); ok {
   279  		if err := v.Validate(); err != nil {
   280  			return nil, err
   281  		}
   282  	}
   283  
   284  	if res, err := c.Invoker().Invoke(ctx, ERC20Chaincode_Approve, []interface{}{in}, &ApproveResponse{}); err != nil {
   285  		return nil, err
   286  	} else {
   287  		return res.(*ApproveResponse), nil
   288  	}
   289  }
   290  
   291  func (c *ERC20Gateway) TransferFrom(ctx context.Context, in *TransferFromRequest) (*TransferResponse, error) {
   292  	var inMsg interface{} = in
   293  	if v, ok := inMsg.(interface{ Validate() error }); ok {
   294  		if err := v.Validate(); err != nil {
   295  			return nil, err
   296  		}
   297  	}
   298  
   299  	if res, err := c.Invoker().Invoke(ctx, ERC20Chaincode_TransferFrom, []interface{}{in}, &TransferResponse{}); err != nil {
   300  		return nil, err
   301  	} else {
   302  		return res.(*TransferResponse), nil
   303  	}
   304  }
   305  
   306  // ERC20ChaincodeResolver interface for service resolver
   307  type (
   308  	ERC20ChaincodeResolver interface {
   309  		Resolve(ctx cckit_router.Context) (ERC20Chaincode, error)
   310  	}
   311  
   312  	ERC20ChaincodeLocalResolver struct {
   313  		service ERC20Chaincode
   314  	}
   315  
   316  	ERC20ChaincodeLocatorResolver struct {
   317  		locatorResolver cckit_gateway.ChaincodeLocatorResolver
   318  		service         ERC20Chaincode
   319  	}
   320  )
   321  
   322  func NewERC20ChaincodeLocalResolver(service ERC20Chaincode) *ERC20ChaincodeLocalResolver {
   323  	return &ERC20ChaincodeLocalResolver{
   324  		service: service,
   325  	}
   326  }
   327  
   328  func (r *ERC20ChaincodeLocalResolver) Resolve(ctx cckit_router.Context) (ERC20Chaincode, error) {
   329  	if r.service == nil {
   330  		return nil, errors.New("service not set for local chaincode resolver")
   331  	}
   332  
   333  	return r.service, nil
   334  }
   335  
   336  func NewERC20ChaincodeResolver(locatorResolver cckit_gateway.ChaincodeLocatorResolver) *ERC20ChaincodeLocatorResolver {
   337  	return &ERC20ChaincodeLocatorResolver{
   338  		locatorResolver: locatorResolver,
   339  	}
   340  }
   341  
   342  func (r *ERC20ChaincodeLocatorResolver) Resolve(ctx cckit_router.Context) (ERC20Chaincode, error) {
   343  	if r.service != nil {
   344  		return r.service, nil
   345  	}
   346  
   347  	locator, err := r.locatorResolver(ctx, _ERC20_serviceDesc.ServiceName)
   348  	if err != nil {
   349  		return nil, err
   350  	}
   351  
   352  	r.service = NewERC20ChaincodeStubInvoker(locator)
   353  	return r.service, nil
   354  }
   355  
   356  type ERC20ChaincodeStubInvoker struct {
   357  	Invoker cckit_gateway.ChaincodeStubInvoker
   358  }
   359  
   360  func NewERC20ChaincodeStubInvoker(locator *cckit_gateway.ChaincodeLocator) *ERC20ChaincodeStubInvoker {
   361  	return &ERC20ChaincodeStubInvoker{
   362  		Invoker: &cckit_gateway.LocatorChaincodeStubInvoker{Locator: locator},
   363  	}
   364  }
   365  
   366  func (c *ERC20ChaincodeStubInvoker) Name(ctx cckit_router.Context, in *emptypb.Empty) (*NameResponse, error) {
   367  
   368  	var inMsg interface{} = in
   369  	if v, ok := inMsg.(interface{ Validate() error }); ok {
   370  		if err := v.Validate(); err != nil {
   371  			return nil, err
   372  		}
   373  	}
   374  
   375  	if res, err := c.Invoker.Query(ctx.Stub(), ERC20Chaincode_Name, []interface{}{in}, &NameResponse{}); err != nil {
   376  		return nil, err
   377  	} else {
   378  		return res.(*NameResponse), nil
   379  	}
   380  
   381  }
   382  
   383  func (c *ERC20ChaincodeStubInvoker) Symbol(ctx cckit_router.Context, in *emptypb.Empty) (*SymbolResponse, error) {
   384  
   385  	var inMsg interface{} = in
   386  	if v, ok := inMsg.(interface{ Validate() error }); ok {
   387  		if err := v.Validate(); err != nil {
   388  			return nil, err
   389  		}
   390  	}
   391  
   392  	if res, err := c.Invoker.Query(ctx.Stub(), ERC20Chaincode_Symbol, []interface{}{in}, &SymbolResponse{}); err != nil {
   393  		return nil, err
   394  	} else {
   395  		return res.(*SymbolResponse), nil
   396  	}
   397  
   398  }
   399  
   400  func (c *ERC20ChaincodeStubInvoker) Decimals(ctx cckit_router.Context, in *emptypb.Empty) (*DecimalsResponse, error) {
   401  
   402  	var inMsg interface{} = in
   403  	if v, ok := inMsg.(interface{ Validate() error }); ok {
   404  		if err := v.Validate(); err != nil {
   405  			return nil, err
   406  		}
   407  	}
   408  
   409  	if res, err := c.Invoker.Query(ctx.Stub(), ERC20Chaincode_Decimals, []interface{}{in}, &DecimalsResponse{}); err != nil {
   410  		return nil, err
   411  	} else {
   412  		return res.(*DecimalsResponse), nil
   413  	}
   414  
   415  }
   416  
   417  func (c *ERC20ChaincodeStubInvoker) TotalSupply(ctx cckit_router.Context, in *emptypb.Empty) (*TotalSupplyResponse, error) {
   418  
   419  	var inMsg interface{} = in
   420  	if v, ok := inMsg.(interface{ Validate() error }); ok {
   421  		if err := v.Validate(); err != nil {
   422  			return nil, err
   423  		}
   424  	}
   425  
   426  	if res, err := c.Invoker.Query(ctx.Stub(), ERC20Chaincode_TotalSupply, []interface{}{in}, &TotalSupplyResponse{}); err != nil {
   427  		return nil, err
   428  	} else {
   429  		return res.(*TotalSupplyResponse), nil
   430  	}
   431  
   432  }
   433  
   434  func (c *ERC20ChaincodeStubInvoker) BalanceOf(ctx cckit_router.Context, in *BalanceOfRequest) (*BalanceOfResponse, error) {
   435  
   436  	var inMsg interface{} = in
   437  	if v, ok := inMsg.(interface{ Validate() error }); ok {
   438  		if err := v.Validate(); err != nil {
   439  			return nil, err
   440  		}
   441  	}
   442  
   443  	if res, err := c.Invoker.Query(ctx.Stub(), ERC20Chaincode_BalanceOf, []interface{}{in}, &BalanceOfResponse{}); err != nil {
   444  		return nil, err
   445  	} else {
   446  		return res.(*BalanceOfResponse), nil
   447  	}
   448  
   449  }
   450  
   451  func (c *ERC20ChaincodeStubInvoker) Transfer(ctx cckit_router.Context, in *TransferRequest) (*TransferResponse, error) {
   452  
   453  	return nil, cckit_gateway.ErrInvokeMethodNotAllowed
   454  
   455  }
   456  
   457  func (c *ERC20ChaincodeStubInvoker) Allowance(ctx cckit_router.Context, in *AllowanceRequest) (*AllowanceResponse, error) {
   458  
   459  	var inMsg interface{} = in
   460  	if v, ok := inMsg.(interface{ Validate() error }); ok {
   461  		if err := v.Validate(); err != nil {
   462  			return nil, err
   463  		}
   464  	}
   465  
   466  	if res, err := c.Invoker.Query(ctx.Stub(), ERC20Chaincode_Allowance, []interface{}{in}, &AllowanceResponse{}); err != nil {
   467  		return nil, err
   468  	} else {
   469  		return res.(*AllowanceResponse), nil
   470  	}
   471  
   472  }
   473  
   474  func (c *ERC20ChaincodeStubInvoker) Approve(ctx cckit_router.Context, in *ApproveRequest) (*ApproveResponse, error) {
   475  
   476  	return nil, cckit_gateway.ErrInvokeMethodNotAllowed
   477  
   478  }
   479  
   480  func (c *ERC20ChaincodeStubInvoker) TransferFrom(ctx cckit_router.Context, in *TransferFromRequest) (*TransferResponse, error) {
   481  
   482  	return nil, cckit_gateway.ErrInvokeMethodNotAllowed
   483  
   484  }