cic-custodial/internal/tasker/task/transfer.go

130 lines
3.1 KiB
Go
Raw Normal View History

2022-11-30 10:51:24 +01:00
package task
import (
"context"
"encoding/json"
"fmt"
"math"
"math/big"
"strconv"
"github.com/bsm/redislock"
celo "github.com/grassrootseconomics/cic-celo-sdk"
"github.com/grassrootseconomics/cic-custodial/internal/keystore"
"github.com/grassrootseconomics/cic-custodial/internal/nonce"
"github.com/grassrootseconomics/cic-custodial/internal/tasker"
"github.com/grassrootseconomics/w3-celo-patch"
"github.com/hibiken/asynq"
)
type TransferPayload struct {
From string `json:"from"`
To string `json:"to"`
VoucherAddress string `json:"voucherAddress"`
Amount string `json:"amount"`
}
func TransferToken(
celoProvider *celo.Provider,
nonceProvider nonce.Noncestore,
keystoreProvider keystore.Keystore,
lockProvider *redislock.Client,
system *tasker.SystemContainer,
taskerClient *tasker.TaskerClient,
) func(context.Context, *asynq.Task) error {
return func(ctx context.Context, t *asynq.Task) error {
var p TransferPayload
if err := json.Unmarshal(t.Payload(), &p); err != nil {
return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
}
lock, err := lockProvider.Obtain(ctx, system.LockPrefix+p.From, system.LockTimeout, nil)
if err != nil {
return err
}
defer lock.Release(ctx)
nonce, err := nonceProvider.Acquire(ctx, p.From)
if err != nil {
return err
}
key, err := keystoreProvider.LoadPrivateKey(ctx, p.From)
if err != nil {
return err
}
abi, err := w3.NewFunc("transfer(address,uint256)", "bool")
if err != nil {
return err
}
input, err := abi.EncodeArgs(p.To, parseTransferValue(p.Amount, system.TokenDecimals))
if err != nil {
return fmt.Errorf("ABI encode failed %v: %w", err, asynq.SkipRetry)
}
builtTx, err := celoProvider.SignContractExecutionTx(
key,
celo.ContractExecutionTxOpts{
ContractAddress: system.GiftableToken,
InputData: input,
GasPrice: celo.FixedMinGas,
GasLimit: system.TokenTransferGasLimit,
Nonce: nonce,
},
)
if err != nil {
if err := nonceProvider.Return(ctx, p.From); err != nil {
return err
}
return fmt.Errorf("nonce.Return failed: %v: %w", err, asynq.SkipRetry)
}
disptachJobPayload, err := json.Marshal(TxPayload{
Tx: builtTx,
})
if err != nil {
return fmt.Errorf("json.Marshal failed: %v: %w", err, asynq.SkipRetry)
}
_, err = taskerClient.CreateTask(
tasker.TxDispatchTask,
tasker.HighPriority,
&tasker.Task{
Payload: disptachJobPayload,
},
)
if err != nil {
return err
}
gasRefillPayload, err := json.Marshal(SystemPayload{
PublicKey: p.From,
})
if err != nil {
return fmt.Errorf("json.Marshal failed: %v: %w", err, asynq.SkipRetry)
}
_, err = taskerClient.CreateTask(
tasker.RefillGasTask,
tasker.DefaultPriority,
&tasker.Task{
Payload: gasRefillPayload,
},
)
if err != nil {
return err
}
return nil
}
}
func parseTransferValue(value string, tokenDecimals int) *big.Int {
floatValue, _ := strconv.ParseFloat(value, 64)
return big.NewInt(int64(floatValue * math.Pow10(tokenDecimals)))
}