开发语言：go

Discord交流: Link

Twitter：@ananpt0

项目主页：

https://www.suins.io/

手动测试分析：

首先我们手动注册个域名，然后去Sui Explorer查看记录：

https://explorer.sui.io/

第一次调用了合约0xf6d55ad60e110c1faf2b54c1824df19481536fd5的 base_controller模块的make_commitment_and_commit函数，该函数我们看到有两个参数，第一个是个地址字符串，第二个是个整型数组。

我们继续分析这两个参数含义，点击base_controller去到合约详情页查看合约Bytecode,找到make_commitment_and_commit函数定义：

entry public make_commitment_and_commit(Arg0: &mut BaseController, Arg1: vector, Arg2: &mut TxContext)

第一个参数为BaseController的Object ID

第二个参数是个vector，暂时还不知道是怎么生成的，这个时候我们来调试下前端，看这个参数是怎么生成并传给钱包的。

在合约Bytecode中我们看下虚拟机字节码，看到make_commitment有调用keccak256函数，我们去前端js里面搜索下看看，通过搜索我们发现在main.xxx.js中我们找到一个keccak_256调用：

我们在这一行下断点，然后点击“Register name”按钮试试，成功断下，然后我们可以发现，keccack_256参数为一个Uint8Array,由申请域名字符串+钱包地址（去除0x后16进制数组）+15位字符串，此时15位字符串我们还不知道是怎么生成的，我们可以通过调用栈回溯来找到生成的地方：

点击A下面那个匿名函数：

我们可以发现这个15位字符串是用过y.We.internet.password()生成的15位随机字符串。

所以第一个Transaction两个参数为：BaseController的Object ID，keccak256后的结果int数组。

接下来我们看看第二个Transaction:

第一步还是查看Sui Explorer记录,找到Bytecode中register函数

entry public register(Arg0: &mut BaseController, Arg1: &mut BaseRegistrar, Arg2: &mut Registry, Arg3: &Configuration, Arg4: vector<u8>, Arg5: address, Arg6: u64, Arg7: vector<u8>, Arg8: Coin<SUI>, Arg9: &mut TxContext)

可以看出前4个参数分别为BaseController，BaseRegistrar（sui、move后缀的地址不一样），Registry，Configuration地址，第5个参数为注册的域名去除后缀，第6个参数为注册钱包地址，第7个参数为注册期限（一年的为365），第8个参数为15位随机字符串（第一个Transaction生成的15位随机字符串），最后一个为SUI Coin地址。

到此基本上我们已经完成了参数定义的分析，最后我们用代码来测试看看：

代码实现：

package main

import (
    "encoding/hex"
    "errors"
    "fmt"
    "github.com/coming-chat/go-sui/account"
    "github.com/coming-chat/go-sui/client"
    "github.com/coming-chat/go-sui/types"
    "golang.org/x/crypto/sha3"
    "golang.org/x/net/context"
    "math/rand"
    "net/url"
    "time"
)

const DevnetRpcUrl = "https://fullnode.devnet.sui.io"

var bytes []byte = []byte("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890_")
var (//地址通过https://explorer.sui.io查找替换
    PackageID         = "0xb43d7bd4394766de04ff82b8214aa8814de69a04"
    BaseController    = "0x50ac890157d0bfda1be5d2e2a0739e75a64281c7"
    SUIBaseRegistrar  = "0x4e2ce97c434f449785bbdce745d418c08d9f1a7f"//sui后缀
    MoveBaseRegistrar = "0xdcea9fe45615172f4d2c3c74a4ed76c565014fa"//move后缀
    Registry          = "0x79af4acd5d1d70fbb29b724b5060c67063cae83c"
    Configuration     = "0x1ea0f7ae66fb52e4b51dc89fe9b02e3767a9d15f"
)

func init() {
    rand.Seed(time.Now().UnixNano())
}

func RandStr(n int) string {
    result := make([]byte, n)
    for i := 0; i < n; i++ {
        result[i] = bytes[rand.Int31()%63]
    }
    return string(result)
}

func Hash(data ...[]byte) []int {
    hash := sha3.NewLegacyKeccak256()
    for _, d := range data {
        hash.Write(d)
    }
    hashBytes := hash.Sum(nil)
    intSlice := make([]int, len(hashBytes))
    for i, b := range hashBytes {
        intSlice[i] = int(b)
    }
    return intSlice
}

func MakeCommitment(domain, address, solt string) []int {
    tmp := make([]byte, 0)
    tmp = append(tmp, []byte(domain)...)
    addr, _ := hex.DecodeString(address)
    tmp = append(tmp, addr...)
    tmp = append(tmp, []byte(solt)...)
    return Hash(tmp)
}

func MakeCommitmentAndCommit(client *client.Client, ctx context.Context, signer types.Address, commitment []int, gas *types.ObjectId, gasBudget uint64) (*types.TransactionBytes, error) {
    packageId, _ := types.NewAddressFromHex(PackageID)
    args := []any{
        BaseController, commitment,
    }
    return client.MoveCall(ctx, signer, *packageId, "base_controller", "make_commitment_and_commit", args, gas, gasBudget)
}

func MakeCommit(mnemonic, domain string) (*types.Base64Data, string, error) {

    acc, _ := account.NewAccountWithMnemonic(mnemonic)
    signer, _ := types.NewAddressFromHex(acc.Address)
    addr := acc.Address[2:]//去除0x
    randStr := RandStr(15)
    hash := MakeCommitment(domain, addr, randStr)
    suiClient, err := client.Dial(DevnetRpcUrl)
    if err != nil {
        return nil, "", err
    }
    gasBudget := uint64(100000)
    txnBytes, err := MakeCommitmentAndCommit(suiClient, context.Background(), *signer, hash, nil, gasBudget)
    if err != nil {
        return nil, "", err
    }
    signedTxn := txnBytes.SignWith(acc.PrivateKey)
    txnResponse, err := suiClient.ExecuteTransaction(context.Background(), *signedTxn, types.TxnRequestTypeWaitForLocalExecution)
    if err != nil {
        return nil, "", err
    }
    return txnResponse.EffectsCert.Effects.Effects.TransactionDigest, randStr, nil
}

func Register(client *client.Client, ctx context.Context, signer types.Address, register, domain, address string, day int, randStr string, coinID string, gas *types.ObjectId, gasBudget uint64) (*types.TransactionBytes, error) {
    packageId, _ := types.NewAddressFromHex(PackageID)
    args := []any{
        BaseController, register, Registry, Configuration, domain, address, day, randStr, coinID,
    }
    return client.MoveCall(ctx, signer, *packageId, "base_controller", "register", args, gas, gasBudget)
}

func DoRegister(mnemonic, domain, suffix, randStr string) (*types.Base64Data, error) {

    acc, _ := account.NewAccountWithMnemonic(mnemonic)
    signer, _ := types.NewAddressFromHex(acc.Address)

    suiClient, err := client.Dial(DevnetRpcUrl)
    if err != nil {
        return nil, err
    }
    gasBudget := uint64(1000000)
    reg := ""
    if suffix == "sui" {
        reg = SUIBaseRegistrar
    } else if suffix == "move" {
        reg = MoveBaseRegistrar
    } else {
        return nil, errors.New("err suffix")
    }
    txnBytes, err := Register(suiClient, context.Background(), *signer, reg, domain, acc.Address, 365, randStr, "COIN_OBJECT_ID", nil, gasBudget)//COIN_OBJECT_ID替换为你钱包中SUI Coin对象ID
    if err != nil {
        return nil, err
    }
    signedTxn := txnBytes.SignWith(acc.PrivateKey)
    txnResponse, err := suiClient.ExecuteTransaction(context.Background(), *signedTxn, types.TxnRequestTypeWaitForLocalExecution)
    if err != nil {
        return nil, err
    }
    return txnResponse.EffectsCert.Effects.Effects.TransactionDigest, nil
}

func main() {
    domain := ""//你要注册的域名名称
    suffix := "sui"//sui或者move后缀
    fmt.Printf("[+][suins]注册域名：%s.%s\n", domain, suffix)
    mnemonic := ""//钱包助记词
    if tid, randStr, err := MakeCommit(mnemonic, domain+"."+suffix); err != nil {
        fmt.Println("[+]", err)
    } else {
        fmt.Printf("[+]make_commitment_and_commit done! Check https://explorer.sui.io/transactions/%s\n", url.QueryEscape(tid.String()))
        if rid, err := DoRegister(mnemonic, domain, suffix, randStr); err != nil {
            fmt.Println("[+]", err)
        } else {
            fmt.Printf("[+]register done! Check https://explorer.sui.io/transactions/%s\n", url.QueryEscape(rid.String()))
        }
    }
}

开发语言: go

Discord交流: Link

Twitter：@ananpt0

package main

import (
    "fmt"
    "github.com/coming-chat/go-sui/account"
    "github.com/coming-chat/go-sui/client"
    "github.com/coming-chat/go-sui/types"
    "golang.org/x/net/context"
    "net/url"
)

const DevnetRpcUrl = "https://fullnode.devnet.sui.io"

var (
    //https://explorer.sui.io/ 查找最新的CapyRegistry和PackageID
    CapyRegistry = "0xeed1d9254e7cdc52e14e48031e9da4f85080f52d"
    Module       = "capy"
    PackageID    = "0x5caccea44ca885b4be2497434c1db7a5ed86b16b"
)

func BreedAndKeep(client *client.Client, ctx context.Context, signer types.Address, capyLeft, capyRight string, gas *types.ObjectId, gasBudget uint64) (*types.TransactionBytes, error) {
    packageId, _ := types.NewAddressFromHex(PackageID)
    args := []any{
        CapyRegistry, capyLeft, capyRight,
    }
    return client.MoveCall(ctx, signer, *packageId, Module, "breed_and_keep", args, gas, gasBudget)
}

func Breed(mnemonic, capyLeft, capyRight string) (*types.Base64Data, error) {
    fmt.Printf("[+]Capy Breed: %s + %s\n", capyLeft, capyRight)

    acc, _ := account.NewAccountWithMnemonic(mnemonic)
    signer, _ := types.NewAddressFromHex(acc.Address)
    suiClient, err := client.Dial(DevnetRpcUrl)
    if err != nil {
        return nil, err
    }

    gasBudget := uint64(100000)
    txnBytes, err := BreedAndKeep(suiClient, context.Background(), *signer, capyLeft, capyRight, nil, gasBudget)
    if err != nil {
        return nil, err
    }
    signedTxn := txnBytes.SignWith(acc.PrivateKey)
    txnResponse, err := suiClient.ExecuteTransaction(context.Background(), *signedTxn, types.TxnRequestTypeWaitForLocalExecution)
    if err != nil {
        return nil, err
    }
    oID := txnResponse.EffectsCert.Effects.Effects.Created[0].Reference.ObjectId.String()
    fmt.Println("[+]New Capy ID: ", oID)
    return txnResponse.EffectsCert.Effects.Effects.TransactionDigest, nil
}

func main() {
    //助记词
    mnemonic := ""

    //左侧capy ID
    capyLeft := ""

    //右侧capy ID
    capyRight := ""

    if tid, err := Breed(mnemonic, capyLeft, capyRight); err != nil {
        fmt.Println("[+]", err)
    } else {
        fmt.Printf("[+]Check https://explorer.sui.io/transactions/%s\n", url.QueryEscape(tid.String()))
    }
}

开发语言：go

Discord交流: Link

Twitter：@ananpt0

package main

import (
    "context"
    "fmt"
    "github.com/coming-chat/go-sui/account"
    "github.com/coming-chat/go-sui/client"
    "github.com/coming-chat/go-sui/types"
    "net/url"
    "time"
)

const DevnetRpcUrl = "https://fullnode.devnet.sui.io"

func Mint(mnemonic, name string) (*types.Base64Data, error) {
    fmt.Println("[+]TYPE: Call Mint NFT")
    acc, _ := account.NewAccountWithMnemonic(mnemonic)
    fmt.Printf("[+]Wallet: %s\n", acc.Address)
    suiClient, err := client.Dial(DevnetRpcUrl)
    if err != nil {
        return nil, err
    }
    signer, err := types.NewAddressFromHex(acc.Address)
    if err != nil {
        return nil, err
    }
    gasBudget := uint64(10000)

    var (
        timeNow = time.Now().Format("06-01-02 15:04")
        nftName = "NFT at " + timeNow
        nftDesc = "This is a NFT created by " + name
        nftUrl  = "https://go.dev/images/logos/twitter.svg"
    )

    txnBytes, err := suiClient.MintDevnetNFT(context.Background(), *signer, nftName, nftDesc, nftUrl, nil, gasBudget)
    if err != nil {
        return nil, err
    }
    // sign & send
    signedTxn := txnBytes.SignWith(acc.PrivateKey)
    response, err := suiClient.ExecuteTransaction(context.Background(), *signedTxn, types.TxnRequestTypeWaitForLocalExecution)
    if err != nil {
        return nil, err
    }
    fmt.Println("[+]TRANSACTION ID: ", response.EffectsCert.Effects.Effects.TransactionDigest)
    return response.EffectsCert.Effects.Effects.TransactionDigest, nil
}

func main() {
    //助记词
    mnemonic := "fork vocal captain early crisp that shuffle magic dune crop ask ribbon view industry scorpion orphan prize stone eye hover first frown fantasy first"
    name := "sui"
    if tid, err := Mint(mnemonic, name); err != nil {
        fmt.Println("[+]", err)
    } else {
        fmt.Printf("[+]Mint check https://explorer.devnet.sui.io/transactions/%s\n", url.QueryEscape(tid.String()))
    }
}

开发语言：go

Discord交流: Link

Twitter：@ananpt0

package main

import (
    "errors"
    "fmt"
    "github.com/go-resty/resty/v2"
    "strings"
)

type GasReq struct {
    FixedAmountRequest FixedAmount `json:"FixedAmountRequest"`
}

type FixedAmount struct {
    Recipient string `json:"recipient"`
}

var FaucetURL = "https://faucet.devnet.sui.io/gas"

func Faucet(address string, proxy string) error {
    fmt.Println("[+]Request DevNet SUI Tokens")
    req := FixedAmount{
        Recipient: address,
    }
    gas := GasReq{FixedAmountRequest: req}
    httpClient := resty.New()
    if len(proxy) > 0 {
        httpClient.SetProxy(proxy)
    }
    resp, err := httpClient.R().
        SetBody(gas).
        Post(FaucetURL)
    if err != nil {
        fmt.Println(err)
        return err
    }
    b := resp.Body()

    if strings.Contains(string(b), "error code: 1015") {
        return errors.New("fail")
    }
    return nil
}

func main() {
    //钱包地址：0x
    walletAddress := ""
    //http代理服务器地址 示例:http://127.0.0.1:8001
    proxy := ""
    if err := Faucet(walletAddress, proxy); err == nil {
        fmt.Printf("[+] 5 test Sui objects are heading to your wallet,check https://explorer.devnet.sui.io/addresses/%s\n", walletAddress)
    } else {
        //失败后可以更换Http代理
        fmt.Println("Request limit reached, please try again later or change proxy.")
    }
}

脚本语言：go

版本：go1.19

Discord交流: Link

Twitter：@ananpt0

package main

import (
    "encoding/json"
    "fmt"
    "github.com/coming-chat/go-sui/account"
    "github.com/tyler-smith/go-bip39"
    "io/ioutil"
)

type SuiWallet struct {
    Address  string `json:"address"`
    Mnemonic string `json:"mnemonic"`
    Private  string `json:"private"`
    Public   string `json:"public"`
}

func Create(num int) {
    fmt.Printf("[+]Create Wallet :%d \n", num)
    wallets := make([]SuiWallet, 0)
    for i := 0; i < num; i++ {
        fmt.Printf("[+]Wallet : %d \n", i+1)
        entropy, _ := bip39.NewEntropy(256)
        mnemonic, _ := bip39.NewMnemonic(entropy)
        fmt.Println("[+]Mnemonic : ", mnemonic)
        acc, _ := account.NewAccountWithMnemonic(mnemonic)
        fmt.Printf("[+]privateKey = %x\n", acc.PrivateKey[:32])
        fmt.Printf("[+] publicKey = %x\n", acc.PublicKey)
        fmt.Printf("[+]   address = %v\n", acc.Address)
        wallet := SuiWallet{}
        wallet.Mnemonic = mnemonic
        wallet.Address = acc.Address
        wallet.Private = fmt.Sprintf("%x", acc.PrivateKey[:32])
        wallet.Public = fmt.Sprintf("%x", acc.PublicKey)
        wallets = append(wallets, wallet)
    }
        //保存到本地json文件
    walletsJson, _ := json.Marshal(wallets)
    ioutil.WriteFile("wallet.json", walletsJson, 0666)
}

func main() {
   //创建100个钱包地址
   Create(100)
}