Olá!

Trago uma sugestão para melhora da performace: uso de um hashtable

Atualmente, para fazer a verificação se foi encontrado uma privateKey de uma wallet é dado pelo seguinte código:

func worker(wallets *Wallets, privKeyChan <-chan *big.Int, resultChan chan<- *big.Int, wg *sync.WaitGroup) {
	defer wg.Done()
	for privKeyInt := range privKeyChan {
		address := btc_utils.CreatePublicHash160(privKeyInt)
		if Contains(wallets.Addresses, address) {
			select {
			case resultChan <- privKeyInt:
				return
			default:
				return
			}
		}
	}
}

especificamente, a função Contains em

if Contains(wallets.Addresses, address) {
	select {
	case resultChan <- privKeyInt:
		return
	default:
		return
	}
}

Essa função, é implementada da seguinte forma:

func Contains(slice [][]byte, item []byte) bool {
	for _, a := range slice {
		if bytes.Equal(a, item) {
			return true
		}
	}
	return false
}

A Complexidade de Tempo é linear, O(n) onde n, nesse caso é quantidade de wallets.Addresses. Por isso, nota-se uma melhora quando nesse vídeo deixa-se somente um endereço.

Uma forma de otimizar essa busca é usando Tabelas de Dispersão(Hash Table) que tem como característica principal a busca em tempo constante, O(1). Dado uma rápida lida da definição e da implementação dessa estrutura, é fácil ver como utilizar. Mas, vai aqui um resumo:

• Cria-se um função de hash para mapear o address em uma key;
• Preenche-se a tabela hash com os valores(hash gerado e address);
• Faz-se a busca pela chave. Se essa chave existir, então o address também existe.

Um estrutura built in do go que facilitará essa implementação é o map

Observação: Também é plemente possível, dado o uso do map, que a função de hash seja da seguinte forma address -> address pulando a necessidade de definição de uma função mais complexa.

Espero que tenha conseguido explicar bem a ideia.

Até.

Na primeira vez que eu rodei, eu percebi que a carteira estava diferente da carteira 4, mas tentei reproduzir abrindo logo de primeira mas não esta indo.

Segue :

boa noite, fui fazer uns testes na v0.3, usando os primeiros puzzles para testar como estava a atualização que agora salva as carteiras encontradas, e encotrei um "possível" BUG.

Acredito que esteja acontecendo algum erro no envio dos trabalhos para cada processador.
Fiz um teste gerando os puzzles de 1 a 5 com 1 CPU e 4 CPU e deu resultados diferentes.

Com 1 CPU ele encontra corretamente mas com 4 cpu ele se atrapalha e apresenta divergencia nas wallet 2 e 3.

acredito que pode ser por conta do intervalo muito curto para 4 cpus, ou pode ser por estarem no limite do RANGE, e os trabalhos estão sendo passados com um byte a mais ou a menos do range.

*** nessa imagem eu gerei as carteiras na mesma ordem de 1 a 5.

O código limita rodar a no máximo 50 cores, no entanto para máquinas mais parrudas, não é possível extrair todo o poder de processamento.

CPUs detectados: 56
Quantos CPUs gostaria de usar?: 56
Numero invalido.

gostei muito desse sistema e gostaria de deixar algumas idéias para melhoria e aumento de performance do sistema.

1-ao selecionar um range, é importante buscar apenas a carteira referente a esse range.
[em meus testes, ao escolher o range 66 e deixar apenas a carteira referente a ele em "wallets.json", aumentou em 4x a quantidade de chaves por segundo, pois não tem sentido ficar em loop de todas as carteiras já que sabemos que existe apenas uma em cada range]

2-exibir na tela junto com a informação de total de chaves checadas, o último HEX que foi testado.
[dessa forma se eu precisar interropmper a busca, eu edito o "ranges.json" e coloco esse hex como inicial para continuar de onde parou.

3-o limite MAXIMO do range da carteira não está funcionando, pois caso vc não tenha uma carteira válida/encontrada dentro do range especificado, ele continua buscando carteiras infinitamente.
[seria legal fazer com que ao terminar de buscar o range ele pare de rodar]

4-e implementar uma forma de definir o numero de CPUs a ser utilizado, se marcado com "0" utiliza todas, demais numeros é a quantidade a ser utilizada.

e parabéns por fazer esse código em GO, nunca tinha fuçado em nada em GO, e achei bem interessante.

Rafael

Olá a todos,

Criei uma versão deste projeto, inspirado no btcgo. Fiz um fork e, ao longo do tempo, adaptei-o para um estilo que me agrada mais. Gostaria de convidá-los a ver minha versão e, quem sabe, implementar algo que não está presente na versão atual do btcgo.

Implementei um sistema que chamei de "collision", que evita que dois endereços sejam verificados repetidamente. Sei que o projeto atual já possui algo semelhante, mas com perda de performance, pois é verificado a cada interação. Meu sistema faz a verificação uma única vez, tornando-o mais eficiente.

Outra mudança que fiz foi na interação com o usuário. No meu projeto, a interação é mínima: o usuário define os parâmetros e a execução inicia sem necessidade de inputs adicionais durante a execução. Entendo que esse não era o propósito original do projeto, mas facilita quando se precisa iniciar rapidamente.

Também implementei um sistema de presets, facilitando ainda mais o uso. Por exemplo, para executar a carteira 66 com um preset, basta usar GoKeyHunt.exe -preset wallet-66. Ainda é possível alterar as configurações do preset conforme necessário.

Essas e outras mudanças gostaria de compartilhar com vocês. Fiquem à vontade para utilizar qualquer parte do meu código, como o pacote "collision" ou qualquer outro.

Obrigado pela atenção!

Espero que isso ajude!

Na gravação da ultimaKey, seria mais eficiente criar uma estrutura em memoria e gravar/ler em json, em vez de ler o ficheiro para memoria, procurar a linha, alterar e gravar a cada 5 segundos.

Algo do tipo :

// Cria uma copia do ficheiro em memoria
type controlFileDataStruct struct {
  Chave string json:"chave"
  DataHora string json:"datahora"
}
var controlFileData = make(map[string]controlFileDataStruct)

// Save File
func saveUltimaKeyWallet(filename string, carteira string, chave string) error {
 // Actualiza dados
 if _, ok := controlFileData[carteira]; ok {
 xTmp := controlFileData[carteira]
 xTmp.Chave = chave
 xTmp.DataHora = time.Now().Format("2006-01-02 15:04:05")
 controlFileData[carteira] = xTmp
 } else {
 controlFileData[carteira] = controlFileDataStuct{
   Chave: chave,
   DataHora: time.Now().Format("2006-01-02 15:04:05"),
 }
 }
 // salva no arquivo com as modificações
 xData, err := json.Marshal(controlFileData)
 if err == nil {
 err = os.WriteFile(filename, xData, 0644)
 if err == nil {
   return nil
 }
 }
 return err
}

// Load File
func LoadUltimaKeyWallet(filename string, carteira string) (string, error) {
 // Busca todo o conteúdo atual do arquivo
 data, err := os.ReadFile(filename)
 if err != nil {
   return "", err
 }
 err = json.Unmarshal(data, &controlFileData)
 if err == nil {
 // Verifica se existe a carteira
 if _, ok := controlFileData[carteira]; ok {
   return controlFileData[carteira].Chave, nil
 }
 }
 return "", fmt.Errorf("carteira %s não encontrada", carteira)
}

Oi ppl,
Que acham de se criar uma nova versão com um servidor de blocos?
Ou seja, Um servidor que pode correr local ou online onde uma nova versão do btcgo se liga e vai processando blocos do range que ainda não tenham sido verificados.

https://github.com/RhaPT/btcgo

Caso queiram posso fazer o pull request