Starknetid.go

go get github.com/metacube-games/starknetid.go

client, err := rpc.NewProvider(RPC_URL) // github.com/NethermindEth/starknet.go/rpc
if err != nil {
  panic(err)
}

provider, err := provider.NewProvider(client, constants.SN_MAIN, nil)
if err != nil {
  panic(err)
}

package main
 
import (
  "context"
  "fmt"
 
  "github.com/NethermindEth/starknet.go/rpc"
  "github.com/metacube-games/starknetid.go/constants"
  "github.com/metacube-games/starknetid.go/provider"
)
 
func main() {
  // Step 1: Create a new RPC provider client
  client, err := rpc.NewProvider(RPC_URL)
  if err != nil {
    panic(err)
  }
 
  // Step 2: Create a new Starknet.id provider
  provider, err := provider.NewProvider(client, constants.SN_MAIN, nil)
  if err != nil {
    panic(err)
  }
 
  // Step 3: Get the address for a given .stark domain
  address, err := provider.GetAddressFromStarkName(context.Background(), "example.stark")
  if err != nil {
    panic(err)
  }
 
  fmt.Printf("Address: %s\n", address)
}

package main
 
import (
  "context"
  "fmt"
 
  "github.com/NethermindEth/starknet.go/rpc"
  "github.com/metacube-games/starknetid.go/constants"
  "github.com/metacube-games/starknetid.go/provider"
)
 
func main() {
  // Step 1: Create a new RPC provider client
  client, err := rpc.NewProvider(RPC_URL)
  if err != nil {
    panic(err)
  }
 
  // Step 2: Create a new Starknet.id provider
  provider, err := provider.NewProvider(client, constants.SN_MAIN, nil)
  if err != nil {
    panic(err)
  }
 
  // Step 3: Get the .stark domain for a given address
  domain, err := provider.GetStarkName(context.Background(), "0x1234567890abcdef")
  if err != nil {
    panic(err)
  }
 
  fmt.Printf(".stark domain: %s\n", domain)
}

package main
 
import (
  "context"
  "fmt"
 
  "github.com/NethermindEth/starknet.go/rpc"
  "github.com/metacube-games/starknetid.go/constants"
  "github.com/metacube-games/starknetid.go/provider"
)
 
func main() {
  // Step 1: Create a new RPC provider client
  client, err := rpc.NewProvider(RPC_URL)
  if err != nil {
    panic(err)
  }
 
  // Step 2: Create a new Starknet.id provider
  provider, err := provider.NewProvider(client, constants.SN_MAIN, nil)
  if err != nil {
    panic(err)
  }
 
  // Step 3: Get the Starknet ID for a given .stark domain
  starknetId, err := provider.GetStarknetId(context.Background(), "example.stark")
  if err != nil {
    panic(err)
  }
 
  fmt.Printf("Starknet ID: %s\n", starknetId)
}

package main
 
import (
  "context"
  "fmt"
 
  "github.com/NethermindEth/starknet.go/rpc"
  "github.com/metacube-games/starknetid.go/constants"
  "github.com/metacube-games/starknetid.go/provider"
)
 
func main() {
  // Step 1: Create a new RPC provider client
  client, err := rpc.NewProvider(RPC_URL)
  if err != nil {
    panic(err)
  }
 
  // Step 2: Create a new Starknet.id provider
  provider, err := provider.NewProvider(client, constants.SN_MAIN, nil)
  if err != nil {
    panic(err)
  }
 
  // Step 3: Get the user data for a given Starknet ID, domain or address
  userData, err := provider.GetUserData(context.Background(), "example.stark", "name")
  if err != nil {
    panic(err)
  }
 
  fmt.Printf("User data: %s\n", userData.String())
}

package main
 
import (
  "context"
  "fmt"
 
  "github.com/NethermindEth/starknet.go/rpc"
  "github.com/metacube-games/starknetid.go/constants"
  "github.com/metacube-games/starknetid.go/provider"
)
 
func main() {
  // Step 1: Create a new RPC provider client
  client, err := rpc.NewProvider(RPC_URL)
  if (err != nil) {
    panic(err)
  }
 
  // Step 2: Create a new Starknet.id provider
  provider, err := provider.NewProvider(client, constants.SN_MAIN, nil)
  if (err != nil) {
    panic(err)
  }
 
  // Step 3: Get the extended user data for a given Starknet ID, domain or address
  extendedUserData, err := provider.GetExtendedUserData(context.Background(), "example.stark", "name", 10)
  if (err != nil) {
    panic(err)
  }
 
  fmt.Printf("Extended user data: %v\n", extendedUserData)
}

package main
 
import (
  "context"
  "fmt"
 
  "github.com/NethermindEth/starknet.go/rpc"
  "github.com/metacube-games/starknetid.go/constants"
  "github.com/metacube-games/starknetid.go/provider"
)
 
func main() {
  // Step 1: Create a new RPC provider client
  client, err := rpc.NewProvider(RPC_URL)
  if err != nil {
    panic(err)
  }
 
  // Step 2: Create a new Starknet.id provider
  provider, err := provider.NewProvider(client, constants.SN_MAIN, nil)
  if err != nil {
    panic(err)
  }
 
  // Step 3: Get the unbounded user data for a given Starknet ID, domain or address
  unboundedUserData, err := provider.GetUnboundedUserData(context.Background(), "example.stark", "name")
  if err != nil {
    panic(err)
  }
 
  fmt.Printf("Unbounded user data: %v\n", unboundedUserData)
}

package main
 
import (
  "context"
  "fmt"
 
  "github.com/NethermindEth/starknet.go/rpc"
  "github.com/metacube-games/starknetid.go/constants"
  "github.com/metacube-games/starknetid.go/provider"
  "github.com/NethermindEth/juno/core/felt"
)
 
func main() {
  // Step 1: Create a new RPC provider client
  client, err := rpc.NewProvider(RPC_URL)
  if err != nil {
    panic(err)
  }
 
  // Step 2: Create a new Starknet.id provider
  provider, err := provider.NewProvider(client, constants.SN_MAIN, nil)
  if err != nil {
    panic(err)
  }
 
  // Optional: Verifier contract address
  var verifierAddress *string
  verifierAddress = nil  // or use a specific address: verifierAddress = "0x1234567890abcdef"
 
  // Step 3: Get the verifier data for a given Starknet ID, domain or address
  verifierData, err := provider.GetVerifierData(context.Background(), "example.stark", "name", verifierAddress)
  if err != nil {
    panic(err)
  }
 
  fmt.Printf("Verifier data: %s\n", verifierData.String())
}

package main
 
import (
  "context"
  "fmt"
 
  "github.com/NethermindEth/starknet.go/rpc"
  "github.com/metacube-games/starknetid.go/constants"
  "github.com/metacube-games/starknetid.go/provider"
  "github.com/NethermindEth/juno/core/felt"
)
 
func main() {
  // Step 1: Create a new RPC provider client
  client, err := rpc.NewProvider(RPC_URL)
  if err != nil {
    panic(err)
  }
 
  // Step 2: Create a new Starknet.id provider
  provider, err := provider.NewProvider(client, constants.SN_MAIN, nil)
  if err != nil {
    panic(err)
  }
 
  // Optional: Verifier contract address
  var verifierAddress *string
  verifierAddress = nil  // or use a specific address: verifierAddress = "0x1234567890abcdef"
 
  // Step 3: Get the extended verifier data for a given Starknet ID, domain or address
  extendedVerifierData, err := provider.GetExtendedVerifierData(context.Background(), "example.stark", "name", 10, verifierAddress)
  if err != nil {
    panic(err)
  }
 
  fmt.Printf("Extended verifier data: %v\n", extendedVerifierData)
}

package main
 
import (
  "context"
  "fmt"
 
  "github.com/NethermindEth/starknet.go/rpc"
  "github.com/metacube-games/starknetid.go/constants"
  "github.com/metacube-games/starknetid.go/provider"
  "github.com/NethermindEth/juno/core/felt"
)
 
func main() {
  // Step 1: Create a new RPC provider client
  client, err := rpc.NewProvider(RPC_URL)
  if err != nil {
    panic(err)
  }
 
  // Step 2: Create a new Starknet.id provider
  provider, err := provider.NewProvider(client, constants.SN_MAIN, nil)
  if err != nil {
    panic(err)
  }
 
  // Optional: Verifier contract address
  var verifierAddress *string
  verifierAddress = nil  // or use a specific address: verifierAddress = "0x1234567890abcdef"
 
  // Step 3: Get the unbounded verifier data for a given Starknet ID, domain or address
  unboundedVerifierData, err := provider.GetUnboundedVerifierData(context.Background(), "example.stark", "kyc", verifierAddress)
  if err != nil {
    panic(err)
  }
 
  fmt.Printf("Unbounded verifier data: %v\n", unboundedVerifierData)
}

package main
 
import (
  "context"
  "fmt"
 
  "github.com/NethermindEth/starknet.go/rpc"
  "github.com/metacube-games/starknetid.go/constants"
  "github.com/metacube-games/starknetid.go/provider"
  "github.com/NethermindEth/juno/core/felt"
)
 
func main() {
  // Step 1: Create a new RPC provider client
  client, err := rpc.NewProvider(RPC_URL)
  if err != nil {
    panic(err)
  }
 
  // Step 2: Create a new Starknet.id provider
  provider, err := provider.NewProvider(client, constants.SN_MAIN, nil)
  if err != nil {
    panic(err)
  }
 
  // Optional: Verifier contract address
  var verifierAddress *string
  verifierAddress = nil  // or use a specific address: verifierAddress = "0x1234567890abcdef"
 
  // Step 3: Get the profile picture verifier data for a given Starknet ID, domain or address
  pfpVerifierData, err := provider.GetPfpVerifierData(context.Background(), "example.stark", verifierAddress)
  if err != nil {
    panic(err)
  }
 
  fmt.Printf("Profile picture verifier data: %v\n", pfpVerifierData)
}

package main
 
import (
  "fmt"
  "github.com/metacube-games/starknetid.go/utils"
  "github.com/metacube-games/starknetid.go/constants"
)
 
func main() {
  // Get the identity contract address for the mainnet
  contractAddress, err := utils.GetIdentityContract(constants.SN_MAIN)
  if err != nil {
    panic(err)
  }
 
  fmt.Printf("Identity contract address: %s\n", contractAddress)
}

package main
 
import (
  "fmt"
  "github.com/metacube-games/starknetid.go/utils"
  "github.com/metacube-games/starknetid.go/constants"
)
 
func main() {
  // Get the naming contract address for the mainnet
  contractAddress, err := utils.GetNamingContract(constants.SN_MAIN)
  if err != nil {
    panic(err)
  }
 
  fmt.Printf("Naming contract address: %s\n", contractAddress)
}

package main
 
import (
  "fmt"
  "github.com/metacube-games/starknetid.go/utils"
  "github.com/metacube-games/starknetid.go/constants"
)
 
func main() {
  // Get the verifier contract address for the mainnet
  contractAddress, err := utils.GetVerifierContract(constants.SN_MAIN)
  if err != nil {
    panic(err)
  }
 
  fmt.Printf("Verifier contract address: %s\n", contractAddress)
}

package main
 
import (
  "fmt"
  "github.com/metacube-games/starknetid.go/utils"
  "github.com/metacube-games/starknetid.go/constants"
)
 
func main() {
  // Get the profile picture verifier contract address for the mainnet
  contractAddress, err := utils.GetPfpVerifierContract(constants.SN_MAIN)
  if err != nil {
    panic(err)
  }
 
  fmt.Printf("Profile picture verifier contract address: %s\n", contractAddress)
}

package main
 
import (
  "fmt"
  "github.com/metacube-games/starknetid.go/utils"
  "github.com/metacube-games/starknetid.go/constants"
)
 
func main() {
  // Get the proof of personhood verifier contract address for the mainnet
  contractAddress, err := utils.GetPopVerifierContract(constants.SN_MAIN)
  if err != nil {
    panic(err)
  }
 
  fmt.Printf("Proof of personhood verifier contract address: %s\n", contractAddress)
}

package main
 
import (
  "fmt"
  "github.com/metacube-games/starknetid.go/utils"
  "github.com/metacube-games/starknetid.go/constants"
)
 
func main() {
  // Get the multicall contract address for the mainnet
  contractAddress, err := utils.GetMulticallContract(constants.SN_MAIN)
  if err != nil {
    panic(err)
  }
 
  fmt.Printf("Multicall contract address: %s\n", contractAddress)
}

package main
 
import (
  "fmt"
  "github.com/metacube-games/starknetid.go/utils"
  "github.com/metacube-games/starknetid.go/constants"
)
 
func main() {
  // Get the utils multicall contract address for the mainnet
  contractAddress, err := utils.GetUtilsMulticallContract(constants.SN_MAIN)
  if err != nil {
    panic(err)
  }
 
  fmt.Printf("Utils multicall contract address: %s\n", contractAddress)
}

package main
 
import (
  "fmt"
  "github.com/metacube-games/starknetid.go/utils"
  "github.com/metacube-games/starknetid.go/constants"
)
 
func main() {
  // Get the blobbert contract address for the mainnet
  contractAddress, err := utils.GetBlobbertContract(constants.SN_MAIN)
  if err != nil {
    panic(err)
  }
 
  fmt.Printf("Blobbert contract address: %s\n", contractAddress)
}

package main
 
import (
  "fmt"
  "github.com/metacube-games/starknetid.go/utils"
)
 
func main() {
  // Check if a domain is a valid .stark domain
  isStarkDomain := utils.IsStarkDomain("example.stark")
  fmt.Printf("Is 'example.stark' a valid .stark domain? %v\n", isStarkDomain)
}

package main
 
import (
  "fmt"
  "github.com/metacube-games/starknetid.go/utils"
)
 
func main() {
  // Check if a domain is a valid .stark root domain
  isStarkRootDomain := utils.IsStarkRootDomain("example.stark")
  fmt.Printf("Is 'example.stark' a valid .stark root domain? %v\n", isStarkRootDomain)
}

package main
 
import (
  "fmt"
  "github.com/metacube-games/starknetid.go/utils"
)
 
func main() {
  // Check if a domain is a subdomain
  isSubdomain := utils.IsSubdomain("sub.example.stark")
  fmt.Printf("Is 'sub.example.stark' a subdomain? %v\n", isSubdomain)
}

package main
 
import (
  "fmt"
  "github.com/metacube-games/starknetid.go/utils"
)
 
func main() {
  // Check if a domain is a Braavos subdomain
  isBraavosSubdomain := utils.IsBraavosSubdomain("example.braavos.stark")
  fmt.Printf("Is 'example.braavos.stark' a Braavos subdomain? %v\n", isBraavosSubdomain)
}

package main
 
import (
  "fmt"
  "github.com/metacube-games/starknetid.go/utils"
)
 
func main() {
  // Check if a domain is an xplorer subdomain
  isXplorerSubdomain := utils.IsXplorerSubdomain("example.xplorer.stark")
  fmt.Printf("Is 'example.xplorer.stark' an xplorer subdomain? %v\n", isXplorerSubdomain)
}

package main
 
import (
  "fmt"
  "github.com/metacube-games/starknetid.go/utils"
  "github.com/NethermindEth/juno/core/felt"
)
 
func main() {
  // Encode a domain into a list of felt
  encodedDomain, err := utils.EncodeDomain("abc.def.stark")
  if err != nil {
    panic(err)
  }
 
  fmt.Printf("Encoded domain: %v\n", encodedDomain)
}

package main
 
import (
  "fmt"
  "github.com/metacube-games/starknetid.go/utils"
  "github.com/NethermindEth/juno/core/felt"
)
 
func main() {
  // Decode a list of felt into a domain
  encoded := []*felt.Felt{
    ...,
  }
  decodedDomain := utils.DecodeDomain(encoded)
  fmt.Printf("Decoded domain: %s\n", decodedDomain)
}