Giter Site home page Giter Site logo

wormholes-client's Introduction

Introduction

  • Install

go get github.com/wormholes-org/wormholes-client

  • Client

    • Create a client

      Initializing the wormholes client with Go is the basic steps required to interact with the blockchain. Import the wormholes-org/wormholes-client package and initialize it by calling the receiving blockchain service provider rawurl

      worm := client.NewClient(priKey, rawurl)

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "88aaf04596c2c9e71c94c1ec5c160d4326346511b28324d6f19efa9716cb66fd"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    _ = worm
}

  • Signature

    • Sign buyer

      SignBuyer(amount, nftAddress, exchanger, blockNumber, seller string) ([]byte, error)

      When conducting NFT transactions, sign buyer information

      Params

      • amount: The amount the buyer purchased the NFT, formatted as a hexadecimal string
      • nftAddress: The NFT address of the transaction. The format is a hexadecimal string. When this field is filled in, it means that the transaction has minted nft. When not filled, it means lazy transaction, and the nft has not been minted
      • exchanger : The exchange on which the transaction took place, formatted as a decimal string
      • blockNumber: Block height, which means that this transaction is valid before this height, the format is a hexadecimal string
      • seller: Seller's address, formatted as a hexadecimal string

      Return

      []byte - If the transaction is successful, return the signed byte array; if the signature fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    priKey   = "88aaf04596c2c9e71c94c1ec5c160d4326346511b28324d6f19efa9716cb66fd"
)

func main() {
    worm := client.NewClient(priKey, "")
       buyer, err := worm.Wallet.SignBuyer("0xde0b6b3a7640000", "0x0000000000000000000000000000000000000002", "0x8b07aff2327a3B7e2876D899caFac99f7AE16B10", "0x487", "")
    if err != nil {
        log.Fatalln("Signing failed")
    }

    fmt.Println("sign ", string(buyer))
    //{ "price":"0xde0b6b3a7640000", "nft_address":"0x0000000000000000000000000000000000000002", "exchanger":"0x8b07aff2327a3B7e2876D899caFac99f7AE16B10", "block_number":"0x487", "sig":"0x24355436e991443b8ed3fb83e8c2fa02f8e2bfc0f716c320f836ee7d756e3c712e7e2510b994d1cb7be85d6643233abc81c23929ce7c1c1effd93db261aac5211b" }
}

    • Sign seller

      When conducting NFT transactions, sign the seller information

      • nft cast

        SignSeller1(amount, nftAddress, exchanger, blockNumber string) ([]byte, error)

        Params

        • amount: The amount the buyer purchased the NFT, formatted as a hexadecimal string
        • nftAddress: The NFT address of the transaction, formatted as a hexadecimal string
        • exchanger: The exchange on which the transaction took place, formatted as a decimal string
        • blockNumber: Block height, which means that this transaction is valid before this height, the format is a hexadecimal string

        Return

        []byte - If the transaction is successful, return the signed byte array; if the signature fails, return nil

        error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

        Example

        package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    priKey   = "11e4259f98e6a18772be5e1b2e2c9e5b12b4a9fe8e3cfa0853df59fa0825e861"
)

func main() {
    worm := client.NewClient(priKey, "")
       seller1, err := worm.Wallet.SignSeller1("0x38D7EA4C68000", "0x0000000000000000000000000000000000000003", "0x8b07aff2327a3B7e2876D899caFac99f7AE16B10", "0x65d")
    if err != nil {
        log.Fatalln("Signing failed")
    }

    fmt.Println("sign ", string(seller1))
    //seller1: { "price":"0x38D7EA4C68000", "nft_address":"0x0000000000000000000000000000000000000003", "exchanger":"0x8b07aff2327a3B7e2876D899caFac99f7AE16B10", "block_number":"0x65d", "sig":"0x94e88fb5686551dfc3006c608423983a248df8502cbbcaeb2c3352f267a25e531d5fc745bea5f7f564b7399fb70d87026bbf9952f1403e9d4dae4aa14b091cff1c" }
}

      • nft uncast

        SignSeller2(amount, royalty, metaURL, exclusiveFlag, exchanger, blockNumber string) ([]byte, error)

        Params

        • amount: The amount of the NFT transaction, formatted as a hexadecimal string
        • royalty: royalty, hex string
        • metaURL: NFT metadata address
        • exclusiveFlag: "0": Inclusive, "1": Exclusive
        • exchanger: The exchange on which the transaction took place, formatted as a decimal string
        • blockNumber: Block height, which means that this transaction is valid before this height, the format is a hexadecimal string

        Return

        []byte - If the transaction is successful, return the signed byte array; if the signature fails, return nil

        error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

        Example

        package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    priKey   = "fc92219d8c663afde9708be321354b9b1c2e67c8680647f73c5bf64ce13cca66"
)

func main() {
    worm := client.NewClient(priKey, "")
       seller2, err := worm1.Wallet.SignSeller2("0x38D7EA4C68000", "0xa", "/ipfs/qqqqqqqqqq", "0", exchangeAddress, "0x7be")
    if err != nil {
        log.Fatalln("Signing failed")
    }

    fmt.Println("sign ", string(seller2))
    //seller2: {"price":"0x38D7EA4C68000","royalty":"0xa","meta_url":"/ipfs/qqqqqqqqqq","exclusive_flag":"0","exchanger":"0x83c43f6F7bB4d8E429b21FF303a16b4c99A59b05","block_number":"0x7be","sig":"0x84c0c293298557e38fa5064a6fb3b9e6930fa46b234fcd0a923cd677369f5aad3f014a164b21077f713e25b4e986673f614f6ce824561fbda2b4e67e018fac6f1b"}

    • Sign Exchange

      SignExchanger(exchangerOwner, to, blockNumber string) ([]byte, error)

      When conducting NFT transactions, sign the exchange information

      Params

      • exchangerOwner: Authorize exchange, formatted as a hexadecimal string
      • to: Authorized exchange, formatted as a hexadecimal string
      • blockNumber: Block height, which means that this transaction is valid before this height, the format is a hexadecimal string

      Return

      []byte - If the transaction is successful, return the signed byte array; if the signature fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    priKey   = "ea86b620d97c256434fabbc46a3350cadd42019d7a5953914a8fc1e1093f214c"
)

func main() {
    worm := client.NewClient(priKey, "")
       exchangeAuth, err := worm2.Wallet.SignExchanger(exchangeAddress, exchangeAddress1, "0x26")
    if err != nil {
        log.Fatalln("Signing failed")
    }

    fmt.Println("sign ", string(exchangeAuth))
    //exchangerAuth:	{"exchanger_owner":"0x83c43f6F7bB4d8E429b21FF303a16b4c99A59b05","to":"0xB685EB3226d5F0D549607D2cC18672b756fd090c","block_number":"0x26","sig":"0x8c1706b407f50ed5cec8a392eac5f66f0338e9cf4eb71a465dc264ac7e315d2068f6061dfec02ee6b6f7f1150d1594c829436c36bc49c806ee5f5b4ad04e43631c"}

  • NFT interface

    • NormalTransaction

      NormalTransaction(to string, value int64, data string) (string, error)

      Params

      • to: transaction recipient
      • value: transaction value*
      • data: transaction data

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.NormalTransaction("0xe61e5Bbe724B8F449B5C7BB4a09F99A057253eB4", 10, "")
    fmt.Println(rs) //0x8fa2d4b70013407012d002fa395939cb0d322553e4848aaae78d4fad638bef55
}

    • Mint

      Mint(royalty uint32, metaURL string, exchanger string) (string, error)

      Implement NFT minting, create an NFT on the wormholes chain

      Params

      • royalty: Royalty, formatted as an integer
      • metaURL: NFT metadata address, formatted as string*
      • exchanger: The exchange when the NFT is minted, the format is a string. When this field is filled, the exchange will exclusively own the NFT. If it is not filled in, no exchange will exclusively own the NFT

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.Mint(10,"/ipfs/ddfd90be9408b4","0xe61e5Bbe724B8F449B5C7BB4a09F99A057253eB4")
    fmt.Println(rs) //0x8fa2d4b70013407012d002fa395939cb0d322553e4848aaae78d4fad638bef55
}

    • Transfer

      Transfer(nftAddress, to string) (string, error)

      Change the ownership of the NFT, and the changed owner owns the NFT

      Params

      • nftAddress: NFT address, the format is a decimal string, when it is SNFT, the length can be less than 42 (including 0x), representing the synthesized SNFT
      • to: new owner address

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.Transfer("0x0000000000000000000000000000000000000001", "0x814920c33b1a037F91a16B126282155c6F92A10F")
    fmt.Println(rs) //0x5e8dd659b0ceb95ab53ce32d37daa8688accab601ce58c75e706f08bb47617f4
}

    • Author

      Author(nftAddress, to string) (string, error)

      NFT is authorized to an exchange, so that the exchange has the right to sell NFT

      Params

      • nftAddress: NFT address, the format is a decimal string, when it is SNFT, the length can be less than 42 (including 0x), representing the synthesized SNFT
      • to: authorized person*

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
     "github.com/wormholes-org/wormholes-client/client"
     "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
    worm := client.NewClient(priKey, endpoint)

    rs, _ := worm.NFT.Author("0x0000000000000000000000000000000000000001","0x814920c33b1a037F91a16B126282155c6F92A10F")
    fmt.Println(rs) //0x2657d46f0c4ef16cadbc6842896c1b50f41333d6a247ee43e5085da5d7e3feff
}

    • AuthorRevoke

      AuthorRevoke(nftAddress, to string) (string, error)

      Authorize NFT to an exchange, so that the exchange has the right to sell NFT

      Prams

      • nftAddress: NFT address, the format is a decimal string, when it is SNFT, the length can be less than 42 (including 0x), representing the synthesized SNFT
      • to: The address of the deauthorizer

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.AuthorRevoke("0x0000000000000000000000000000000000000001", "0x814920c33b1a037F91a16B126282155c6F92A10F")
    fmt.Println(rs) //0xe043dc7d8505d01f6cd949b7a7cc4ed685a9e1b640195801c3c6265b7d11efee
}

    • AccountAuthor

      AccountAuthor(to string) (string, error)

      Authorize all NFTs under the account to an exchange, so that the exchange has the right to sell all NFTs

      Params

      • to: Licensee's address

      Return

      string - If the transaction is successful, return the signed byte array; if the signature fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.AccountAuthor("0x814920c33b1a037F91a16B126282155c6F92A10F")
    fmt.Println(rs) //0x6b42237b9dad13211d89f1e6c66cf947bb371f407a4621ffcf7fd73e385f6fea
}

    • AccountAuthorRevoke

      AccountAuthorRevoke(to string) (string, error)

      Cancel all authorized NFTs

      Params

      • to: The address of the deauthorizer

      Return

      string - If the transaction is successful, return the signed byte array; if the signature fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.AccountAuthorRevoke("0x814920c33b1a037F91a16B126282155c6F92A10F")
    fmt.Println(rs) //0x1dee05dff7ea39874ed8401c91288ae627b56ae1df6dc4c26a856fafab0447c5
}

    • SNFTToERB

      SNFTToERB(nftAddress string) (string, error)

      Exchange a certain SNFT fragment mined by the account into ERB

      Params

      • nftAddress: The converted snft address, in the format of a decimal string, the length can be less than 42 (including 0x), representing the synthesized SNFT

      Return

      string - If the transaction is successful, return the signed byte array; if the signature fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
   "github.com/wormholes-org/wormholes-client/client"
   "fmt"
)

const (
endpoint = "http://192.168.4.237:8574"
priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.SNFTToERB("0x8000000000000000000000000000000000000004")
    fmt.Println(rs) //0x77ff920a3a649378e4c7a58644bece643e379113b2bc99257b894a29e220e157
}

    • TokenPledge

      TokenPledge() (string, error)

      When a user wants to become a miner, he needs to do an ERB pledge transaction first to become a miner with the pledge

      Return

      string - If the transaction is successful, return the signed byte array; if the signature fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.TokenPledge()
    fmt.Println(rs) //0x6ceb02802455ab959964866410f37a2f0fcd78e7e64e87d6c9d8102de7f9974b
}

    • TokenRevokesPledge

      TokenRevokesPledge() (string, error)

      When the user does not want to be a miner, or no longer wants to pledge so much ERB, he can do ERB to revoke the pledge

      Return

      string - If the transaction is successful, return the signed byte array; if the signature fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.TokenRevokesPledge()
    fmt.Println(rs) //0xcbd19c386d8b5944d4a88017680239651edefc527e4ba2c8762ab0df2333a7ca
}

    • Open

        Open(feeRate uint32, name, url string) (string, error)

      When a user wants to open an exchange, an exchange can be created

      Params

      • feeRate The exchange rate, the format is an integer type
      • name Exchange name, formatted as a string
      • *url Exchange server address, the format is a string

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.Open(10,"wormholes","www.kang123456.com")
    fmt.Println(rs) //0xcccd6c9499224e7d216f3bd230447900550b07345841eebd2e62b613f7bd924f
}

    • Close

       close() (string, error)

      The transaction is used to close the exchange

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.Close()
    fmt.Println(rs) //0x7d5b3653b67d298e7cce82b92fa720224e93941315528ef19a36c4daf1efe929
}

    • InsertNFTBlock

      InsertNFTBlock(dir, startIndex string, number uint64, royalty uint32, creator string) (string, error)

      This transaction is used to inject NFT fragments that can be mined by miners. Only official accounts can do this transaction

      Params

      • dir The path address where the SNFT is located, the format is a string
      • startIndex The start number of the SNFT fragment, formatted as a hexadecimal string
      • number The number of injected SNFT fragments, formatted as a decimal string
      • royalty Royalty, formatted as an integer
      • creator Creator, format is a hex string

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.InsertNFTBlock("wormholes2", "0x640001", 6553600, 20, "0xEaE404DCa7c22A15A59f63002Df54BBb8D90c5FB")
    fmt.Println(rs) //0x61cd018d6e70af47c6204fea18db5b33fdecc92162cca66b0089783733809e84
}

    • TransactionNFT

      TransactionNFT(buyer []byte, to string) (string, error)

      This transaction is used to buy and sell NFTs that have been minted. The transaction originator can be an exchange or a seller

      Params

      • buyer: Buyer
      • to Buyer address, format is a hexadecimal string

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "88aaf04596c2c9e71c94c1ec5c160d4326346511b28324d6f19efa9716cb66fd"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.TransactionNFT(buyer,"0x5051B76579BC966A9480dd6E72B39A4C89c1154C")
    fmt.Println(rs) //0xc9c4e6652ba411a0435d2e3187f019329b084734f19ae6699ee7f1fa9a92123b
}

    • BuyerInitiatingTransaction

      BuyerInitiatingTransaction(seller1 []byte) (string, error)

      This transaction is used to buy and sell NFTs that have been minted, and the transaction originator is the buyer

      Params

      • seller1: Seller
      • to Seller's address, formatted as a hexadecimal string

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.BuyerInitiatingTransaction(seller1, "0x814920c33b1a037F91a16B126282155c6F92A10F")
    fmt.Println(rs) //0xfb9cf0100340c9bf965fc0f8ef44bb8a75af58175deab0dcff3979a97a8ebefa
}

    • FoundryTradeBuyer

       FoundryTradeBuyer(seller2 []byte) (string, error)

      For buying and selling unminted NFTs, the transaction originator is the buyer

      Params

      • seller2: Seller
      • to: Seller address

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.FoundryTradeBuyer(seller2, "0x814920c33b1a037F91a16B126282155c6F92A10F")
    fmt.Println(rs) //0x4634d6bbc36b9444914a259c2acf0410af0b99122baef30d7a8701a496bc3b6c
}

    • FoundryExchange

       FoundryExchange(buyer, seller2 []byte, to string) (string, error)

      For buying and selling unminted NFTs, the transaction originator is the exchange, or the seller

      Params

      • buyer: Buyer
      • seller2: Seller
      • to: Buyer address

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "88aaf04596c2c9e71c94c1ec5c160d4326346511b28324d6f19efa9716cb66fd"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.FoundryTradeBuyer(buyer,seller2 "0x5051B76579BC966A9480dd6E72B39A4C89c1154C")
    fmt.Println(rs) //0x70853466fdf5dc4476fab34b79f9be2e66f0448789937094de0b0aa5f3345e8c
}

    • NftExchangeMatch

       NftExchangeMatch(buyer, exchangerAuth []byte, to string) (string, error)

      It is used to buy and sell NFTs that have been minted. The transaction originator is the exchange. This transaction is used when exchange A authorizes another exchange B, and exchange B initiates the transaction.

      Params

      • buyer Buyer
      • exchangerAuth: Authorized Exchange A
      • to buyer, the format is a hexadecimal string

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "abdab4bd87d3ea117b5512d6ce28522f7b9421511d8bb08bb20277dde6fb8320"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.NftExchangeMatch(buyer,exchangAuth,"0x5051B76579BC966A9480dd6E72B39A4C89c1154C")
    fmt.Println(rs) //0xf11e024297b89e6dfd02bc2da4680cea353ea6956c3ea9084afa40d58477932f
}

    • FoundryExchangeInitiated

       FoundryExchangeInitiated(buyer, seller2, exchangerAuthor []byte, to string) (string, error)

      It is used to buy and sell unminted NFTs. The transaction originator is the exchange. The transaction is used when exchange A authorizes another exchange B, and exchange B initiates the transaction.

      Params

      • buyer Buyer
      • Seller2 Seller
      • exchangerAuth: Authorized Exchange A
      • to Buyer, the format is a hexadecimal string

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "abdab4bd87d3ea117b5512d6ce28522f7b9421511d8bb08bb20277dde6fb8320"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.NftExchangeMatch(buyer,seller2,exchangAuth,  "0x5051B76579BC966A9480dd6E72B39A4C89c1154C")
    fmt.Println(rs) //0xc9cc570057faf1edd83f48833520f9d546e4972083ee705152b5f35630f1588d
}

    • FtDoesNotAuthorizeExchanges

       FtDoesNotAuthorizeExchanges(buyer, seller1 []byte, to string) (string, error)

      Used to buy and sell NFTs that have been minted, the transaction originator is the exchange, and the transaction is used when the NFT is not authorized to the exchange

      Params

      • buyer Buyer
      • seller1: Seller
      • to Buyer address, format is a hexadecimal string

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "11e4259f98e6a18772be5e1b2e2c9e5b12b4a9fe8e3cfa0853df59fa0825e861"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.FtDoesNotAuthorizeExchanges(buyer,seller1,"0x5051B76579BC966A9480dd6E72B39A4C89c1154C")
    fmt.Println(rs) //0x95615a6c7a164537257492c112a9fcd99907315893706a1b104456d9e3aa8af6
}

    • AdditionalPledgeAmount

       AdditionalPledgeAmount(value int64) (string, error)

      The amount used by the exchange to increase the pledged ERB

      Params

      • Values: additional amount

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
    worm := client.NewClient(priKey, endpoint)
    rs, _ := worm.AdditionalPledgeAmount(100)
    fmt.Println(rs) //0x25f2ed8cf5f1041be9e71d483a32b01fd3f7820ec59e0c060830214c53fea5f9
}

    • RevokesPledgeAmount

       RevokesPledgeAmount(value int64) (string, error)

      The amount used by the exchange to increase the pledged ERB

      Params

      • Values: reduced amount

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
    "github.com/wormholes-org/wormholes-client/client"
    "fmt"
)

const (
    endpoint = "http://192.168.4.237:8574"
    priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
    worm := client.NewNFT(priKey, endpoint)
    rs, _ := worm.RevokesPledgeAmount(100)
    fmt.Println(rs) //0xd2c7f943f0f5364b0928c518e7b6de7491c0e8efb6abf912a17e6860f70ebec1
}

    • VoteOfficialNFT

      VoteOfficialNFT(dir, startIndex string, number uint64, royalty uint32, creator string) (string, error)

      This transaction is used to inject NFT fragments that can be mined by miners. Only official accounts can do this transaction

      Params

      • dir The path address where the SNFT is located, the format is a string
      • startIndex The start number of the SNFT fragment, formatted as a hexadecimal string
      • number The number of injected SNFT fragments, formatted as a decimal string
      • royalty Royalty, formatted as an integer
      • creator Creator, format is a hex string

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
  "github.com/wormholes-org/wormholes-client/client"
  "fmt"
)

const (
  endpoint = "http://192.168.4.237:8574"
  priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
  worm := client.NewClient(priKey, endpoint)
  rs, _ := worm.VoteOfficialNFT("wormholes2", "0x640001", 6553600, 20, "0xEaE404DCa7c22A15A59f63002Df54BBb8D90c5FB")
  fmt.Println(rs) //0x61cd018d6e70af47c6204fea18db5b33fdecc92162cca66b0089783733809e84
}

    • VoteOfficialNFTByApprovedExchanger

      VoteOfficialNFTByApprovedExchanger(dir, startIndex string, number uint64, royalty uint32, creator string, exchangerAuth []byte) (string, error)

      This transaction is used to inject NFT fragments that can be mined by miners. Only official accounts can do this transaction

      Params

      • dir The path address where the SNFT is located, the format is a string
      • startIndex The start number of the SNFT fragment, formatted as a hexadecimal string
      • number The number of injected SNFT fragments, formatted as a decimal string
      • royalty Royalty, formatted as an integer
      • creator Creator, format is a hex string
      • exchangerAuth exchangerAuth

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
     "github.com/wormholes-org/wormholes-client/client"
     "fmt"
)

const (
     endpoint = "http://192.168.4.237:8574"
     priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
     worm := client.NewClient(priKey, endpoint)
     rs, _ := worm.VoteOfficialNFTByApprovedExchanger("wormholes2", "0x640001", 6553600, 20, "0xab7624f47fd7dadb6b8e255d06a2f10af55990fe", exchangeAuth)
     fmt.Println(rs)
}

    • UnforzenAccount

      UnforzenAccount() (string, error)

      This transaction is used to unforzen account

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
   "github.com/wormholes-org/wormholes-client/client"
   "fmt"
)

const (
   endpoint = "http://192.168.4.237:8574"
   priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
   worm := client.NewClient(priKey, endpoint)
   rs, _ := worm.UnforzenAccount()
   fmt.Println(rs)
}

    • AccountDelegate

      AccountDelegate(proxyAddress string) (string, error)

      This transaction is used to change rewards

      Params

      • proxyAddress proxy address for delegation

      Return

      string - If the transaction is successful, return the hash of the transaction; if the transaction fails, return nil

      error - If the transaction is successful, return nil; if the transaction fails, return the corresponding error

      Example

      package main
import (
 "github.com/wormholes-org/wormholes-client/client"
 "fmt"
)

const (
 endpoint = "http://192.168.4.237:8574"
 priKey   = "b2ebd0889351eb22dc73c3a02c63e783794a9de3f578d6d07bb370cc112d2ec7"
)

func main() {
 worm := client.NewClient(priKey, endpoint)
 rs, _ := worm.AccountDelegate("0x814920c33b1a037F91a16B126282155c6F92A10F")
 fmt.Println(rs)
}

wormholes-client's People

Contributors

dzeqkon avatar wormholeslab avatar

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.