claim/rpc/pegin_address.go

   1 package rpc
   2
   3 import (
   4         "encoding/hex"
   5
   6         "github.com/vapor/common"
   7         "github.com/vapor/consensus"
   8         "github.com/vapor/crypto"
   9         chainjson "github.com/vapor/encoding/json"
  10         "github.com/vapor/equity/pegin_contract"
  11         "github.com/vapor/protocol/vm/vmutil"
  12         "github.com/vapor/wallet"
  13 )
  14
  15 type fundingResp struct {
  16         MainchainAddress string             `json:"mainchain_address"`
  17         ControlProgram   chainjson.HexBytes `json:"control_program,omitempty"`
  18         ClaimScript      chainjson.HexBytes `json:"claim_script"`
  19 }
  20
  21 type BytomPeginRpc struct {
  22         ClaimArgs
  23         Wallet *wallet.Wallet
  24 }
  25
  26 type ClaimArgs struct {
  27         AccountID    string `json:"account_id"`
  28         AccountAlias string `json:"account_alias"`
  29 }
  30
  31 func (b *BytomPeginRpc) GetPeginAddress() (interface{}, error) {
  32
  33         accountID := b.AccountID
  34         if b.AccountAlias != "" {
  35                 account, err := b.Wallet.AccountMgr.FindByAlias(b.AccountAlias)
  36                 if err != nil {
  37                         return nil, err
  38                 }
  39
  40                 accountID = account.ID
  41         }
  42
  43         mainchainAddress, claimScript, err := b.CreatePeginAddress(accountID, false)
  44         if err != nil {
  45                 return nil, err
  46         }
  47
  48         return &fundingResp{
  49                 MainchainAddress: mainchainAddress,
  50                 ClaimScript:      claimScript,
  51         }, nil
  52 }
  53
  54 func (b *BytomPeginRpc) GetPeginContractAddress() (interface{}, error) {
  55         accountID := b.AccountID
  56         if b.AccountAlias != "" {
  57                 account, err := b.Wallet.AccountMgr.FindByAlias(b.AccountAlias)
  58                 if err != nil {
  59                         return nil, err
  60                 }
  61
  62                 accountID = account.ID
  63         }
  64
  65         mainchainAddress, controlProgram, claimScript, err := b.CreatePeginContractAddress(accountID, false)
  66         if err != nil {
  67                 return nil, err
  68         }
  69
  70         return &fundingResp{
  71                 MainchainAddress: mainchainAddress,
  72                 ControlProgram:   controlProgram,
  73                 ClaimScript:      claimScript,
  74         }, nil
  75 }
  76
  77 func (b *BytomPeginRpc) CreatePeginAddress(accountID string, change bool) (string, []byte, error) {
  78         // 通过配置获取
  79         claimCtrlProg, err := b.Wallet.AccountMgr.CreateAddress(b.AccountID, change)
  80         if err != nil {
  81                 return "", nil, err
  82         }
  83         claimScript := claimCtrlProg.ControlProgram
  84
  85         federationRedeemScript := vmutil.CalculateContract(consensus.ActiveNetParams.FedpegXPubs, claimScript)
  86
  87         scriptHash := crypto.Sha256(federationRedeemScript)
  88
  89         address, err := common.NewPeginAddressWitnessScriptHash(scriptHash, &consensus.ActiveNetParams)
  90         if err != nil {
  91                 return "", nil, err
  92         }
  93
  94         return address.EncodeAddress(), claimScript, nil
  95
  96 }
  97
  98 func (b *BytomPeginRpc) GetPeginControlPrograms(claimScript []byte) (string, []byte) {
  99         federationRedeemScript := vmutil.CalculateContract(consensus.ActiveNetParams.FedpegXPubs, claimScript)
 100         scriptHash := crypto.Sha256(federationRedeemScript)
 101
 102         address, err := common.NewPeginAddressWitnessScriptHash(scriptHash, &consensus.ActiveNetParams)
 103         if err != nil {
 104                 return "", nil
 105         }
 106
 107         redeemContract := address.ScriptAddress()
 108
 109         program := []byte{}
 110         program, err = vmutil.P2WSHProgram(redeemContract)
 111         if err != nil {
 112                 return "", nil
 113         }
 114
 115         return address.EncodeAddress(), program
 116 }
 117
 118 func (b *BytomPeginRpc) CreatePeginContractPrograms(accountID string, change bool) (string, []byte, error) {
 119         // 通过配置获取
 120         claimCtrlProg, err := b.Wallet.AccountMgr.CreateAddress(accountID, change)
 121         if err != nil {
 122                 return "", nil, err
 123         }
 124         claimScript := claimCtrlProg.ControlProgram
 125
 126         peginContractPrograms, err := pegin_contract.GetPeginContractPrograms(claimScript)
 127         if err != nil {
 128                 return "", nil, err
 129         }
 130         return hex.EncodeToString(peginContractPrograms), claimScript, nil
 131
 132 }
 133
 134 func (b *BytomPeginRpc) CreatePeginContractAddress(accountID string, change bool) (string, []byte, []byte, error) {
 135         // 通过配置获取
 136         claimCtrlProg, err := b.Wallet.AccountMgr.CreateAddress(accountID, change)
 137         if err != nil {
 138                 return "", nil, nil, err
 139         }
 140         claimScript := claimCtrlProg.ControlProgram
 141
 142         peginContractPrograms, err := pegin_contract.GetPeginContractPrograms(claimScript)
 143         if err != nil {
 144                 return "", nil, nil, err
 145         }
 146
 147         scriptHash := crypto.Sha256(peginContractPrograms)
 148
 149         address, err := common.NewPeginAddressWitnessScriptHash(scriptHash, &consensus.ActiveNetParams)
 150         if err != nil {
 151                 return "", nil, nil, err
 152         }
 153
 154         redeemContract := address.ScriptAddress()
 155
 156         program := []byte{}
 157         program, err = vmutil.P2WSHProgram(redeemContract)
 158         if err != nil {
 159                 return "", nil, nil, err
 160         }
 161
 162         return address.EncodeAddress(), program, claimScript, nil
 163
 164 }
 165
 166 func (b *BytomPeginRpc) GetPeginContractControlPrograms(claimScript []byte) (string, []byte) {
 167
 168         peginContractPrograms, err := pegin_contract.GetPeginContractPrograms(claimScript)
 169         if err != nil {
 170                 return "", nil
 171         }
 172         scriptHash := crypto.Sha256(peginContractPrograms)
 173
 174         address, err := common.NewPeginAddressWitnessScriptHash(scriptHash, &consensus.ActiveNetParams)
 175         if err != nil {
 176                 return "", nil
 177         }
 178
 179         redeemContract := address.ScriptAddress()
 180
 181         program := []byte{}
 182         program, err = vmutil.P2WSHProgram(redeemContract)
 183         if err != nil {
 184                 return "", nil
 185         }
 186
 187         return address.EncodeAddress(), program
 188 }