[here]

Hello!
I wrote a small tool to convert Bitcoin addresses to Bitcoin Gold ones.

Just enter your Bitcoin address to see the corresponding BTG one, along with a block explorer link to quickly check the balance.
It also works vice-versa, you can convert BTG addresses to BTC too!

SegWit and multisig addresses are supported experimentally.

It's hosted on GitHub Pages here.
Source code: https://github.com/SopaXorzTaker/gold-address
Uses the bs58check library, by bitcoinjs (MIT).

I feel like spreading some FUD - First Urgent Disclosure!
It came to my knowledge that directory.io is not a joke and they indeed compromised all the private keys!!!

Proof:
http://directory.io/856083576414584832184365027012002209974486074049742179003044245104477177639

Hello!
I've noticed that user BitkeysOrganization runs a site, bitkeys.org, which offers various tools for working with Bitcoin.
They make it look like that the tools were developed by themselves and don't hesitate to openly ask for donations.
In fact, the tools offered on their site are stolen and stripped of copyrights:

https://bitkeys.org/bulkchecker - http://www.homebitcoin.com/easybalance/easybalance.html
https://bitkeys.org/bitkeys - https://bitaddress.org
https://bitkeys.org/BIP39Mnemonic - https://iancoleman.github.io/bip39/
https://bitkeys.org/transaction - https://coinb.in

It's okay to republish open-source code, but replacing the copyrights and inserting your own donation address isn't.
When I posted in their original thread, they quickly removed it and made a new one.

Additionally, there might be backdoors inserted by them to snoop on users' private keys.

As the title says, I wrote an efficient P2SH vanity address generator which can make any script have a vanity address by altering a nonce field that must be added first.
I can generate any script address, such as a multisig one, or something even more sophisticated.
I offer this service only to raise interest in vanity P2SH addresses, so don't expect anything extraordinary.

The way this works is provably safe - you supply a script with a nonce field, which is simply some space to locate the nonce value in it (8 bytes).
For example, you can generate any multisig script you want, replace one public key with 04 <65 zero bytes>, which would serve as the nonce, and send it to me.
I generate you a vanity address, which corresponds to the script you sent me, but with the nonce field altered.
That way, if you want to make a 2-of-3 vanity multisig script, you make a 2-of-4 one, with an all-zero public key in one place.

This basically implements this idea: https://bitcointalk.org/index.php?topic=255245.0.

I'll generate you a max. 5-6 character address for 0.015 BTC.
Remember, again, that this is just a way to raise interest, so don't expect this to be a viable service.

I'll release the program (open source, very very alpha, Linux only) if three people ask me to generate an address for them.

Hello!
I am quite experienced in bare Python programming and general use of Linux.
If you need help with something written in Python, such as fixing your code, getting that program to run or something in this scope, feel free
 to post there or write me a PM.

I also can help compiling source code (if it doesn't succeed for some reason or you don't know what to do).
Please note that my level of experience is hobby-intermediate, so I might not be able to help with especially hard stuff, but if you just need something
 general described above, I'll be glad to help you for some BTC, or even for free if your request is particularly easy.

Hey guys!
I have developed a proof-of-concept P2SH vanity address generator!
This program is an implementation of this idea: https://bitcointalk.org/index.php?topic=255245.0.
It's written in Python, thus is very slow, but that's a good proof of concept.

You'll need Python 2.7 and pybitcointools installed.

Code:

#!/usr/bin/env python2
import time
import multiprocessing

from pybitcointools import *

def uint256(x):
    hexdigits = hex(x)[2:].replace("L", "")
    hexdigits = "0"*(64-len(hexdigits)) + hexdigits
    binary = hexdigits.decode("hex")
    return binary

def make_script(pubkey1, pubkey2):
    script = [1, pubkey1, pubkey2, 2, 174]
    return serialize_script(script)

def p2sh(script):
    return hex_to_b58check(hash160(script), 5)

def _worker_thread(thread_number, total_threads, starting_k, pattern, quit):
    print "Worker %d started" % thread_number
    k = starting_k + thread_number
    total = k 

    while not quit.is_set():
        start = time.time()
        pubkey2 = "\x02" + uint256(k)
        k += total_threads

        redeem_script = make_script(pubkey1, pubkey2)
        p2sh_addr = p2sh(redeem_script)

        if p2sh_addr[1:].startswith(pattern):
            print "Found!"
            print "P2SH address: " + p2sh_addr
            print "Redeem script: " + redeem_script.encode("hex")
            quit.set()

        elapsed = time.time() - start

        num_checked = k - starting_k
        if num_checked % 16384 == thread_number:
            print "Worker %d: %d addrs per second, %d checked" % (thread_number, 1.0 / elapsed, num_checked)

privkey = random_key()
pubkey1 = encode_pubkey(privtopub(privkey), "bin_compressed")

pattern = raw_input("Vanity pattern: ")

quit = multiprocessing.Event()
total_processes = multiprocessing.cpu_count()

starting_k = int(encode_pubkey(privtopub(privkey), "hex_compressed")[2:], 16) + 1

for worker_num in range(total_processes):
    print "Starting worker %d" % worker_num
    process = multiprocessing.Process(target=_worker_thread, args=(worker_num, total_processes, starting_k, pattern, quit))
    process.start()

quit.wait()

print("Spend private key: %s" % encode_privkey(privkey, "wif"))

Code:

Vanity pattern: P14
Starting worker 0
Starting worker 1
Starting worker 2
Starting worker 3
Worker 0 started
Worker 2 started
Worker 1 started
Worker 3 started
Found!
P2SH address: 3P14KiomBxh3S4QCzztj86E7wi8SQnn314
Redeem script: 512102296c1c6e3acac2d7698a36eb70a5c196cfcc7546c277ff29054281a8be4dd4282102296c1c6e3acac2d7698a36eb70a5c196cfcc7546c277ff29054281a8be4e9d1252ae
Spend private key: 5JFYKkqeku1ytA7p5PSMgRm8Xq3EQGQKsr7nyUUZXns5gvfyV5U

It works by having a dummy public key which is altered to make the script hash contain a specific prefix.
Security: the public key chosen for the nonce public key (intended to be unspendable and unknown) is an incremented value of the actual spending public key. I'd like to hear on the security of that.
It's very easy to add multisig support to this, I'd like to hear on it if needed.
Again, this program is not yet intended for real-world use, so please don't risk funds with it.
I'd like to hear from testers if it works properly (I've done some checks myself and it seems to work fine).

If you find it useful, please consider a donation to the address in my signature, thank you!