bitcoin-ruby 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a8a85933bb6f2c36c0262cbfc0b254bfb5449e9d
-  data.tar.gz: a61c9750f801b78ccb01350d2f777560f73bdb9b
+  metadata.gz: db1b92d6514cc112f7141841b658fe16fc23cdad
+  data.tar.gz: 2a4a5e0e7215cc7739d8208322ac361ef1beb988
 SHA512:
-  metadata.gz: 7cb472579d3e819c18025e3fef9b2db6c36e3bdab701b6984482920ada6d07b736af0170512fc7598fd904d8c9104c311c64fa3f3bb87d77acc9310db49e1e71
-  data.tar.gz: 1d0f4d2c551a89433620e87ec391be57edbca0af200df5e9df6b80ab6cd73b8092f36b4030caa3b12671f920a03b2f7dad5189c473e594427f09520641f0db01
+  metadata.gz: 63c618a352af13e722f280e84ef6801ded898c65db7f346eb410fa417c310c89c643d74e66474a975281326bae0d9e4b70316a6c2fb4b4e9a8f54c8462ce241c
+  data.tar.gz: 421b29bcb069e3f6de8d3c8484aece5d6bd09a9f0695866f47baa6308e02ef6fa5b267a350aea9741aaea19b5395fce35456111e24f787ec6819498df199b02a

data/Gemfile

@@ -1,4 +1,4 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in bitcoin-ruby.gemspec
 gemspec

data/Gemfile.lock

@@ -1,20 +1,20 @@
 PATH
   remote: .
   specs:
-    bitcoin-ruby (0.0.7)
+    bitcoin-ruby (0.0.8)
 
 GEM
-  remote: http://rubygems.org/
+  remote: https://rubygems.org/
   specs:
     bacon (1.2.0)
-    eventmachine (1.0.7)
-    ffi (1.9.8)
+    eventmachine (1.0.8)
+    ffi (1.9.10)
     ffi-compiler (0.1.3)
       ffi (>= 1.0.0)
       rake
-    minitest (5.7.0)
+    minitest (5.8.2)
     rake (10.4.2)
-    scrypt (2.0.0)
+    scrypt (2.0.2)
       ffi-compiler (>= 0.0.2)
       rake
 
@@ -31,4 +31,4 @@ DEPENDENCIES
   scrypt
 
 BUNDLED WITH
-   1.10.2
+   1.10.6

data/README.rdoc

@@ -127,7 +127,7 @@ If you want to control the Bitcoin::Script yourself, you can do so
 You need to know the previous output you want to spend (tx hash and output index),
 as well as the private key for the address required to sign for it.
 
- # use testnet so you don't acidentially your whole money!
+ # use testnet so you don't accidentally blow your whole money!
  Bitcoin.network = :testnet3
  
  # make the DSL methods available in your scope

data/examples/simple_network_monitor_and_util.rb

@@ -9,6 +9,14 @@ class Bitcoin::Protocol::Parser; def log; stub=Object.new; def stub.method_missi
 module SimpleNode
   class Connection < EM::Connection
 
+    def on_ping(nonce)
+      send_data(Bitcoin::Protocol.pong_pkt(nonce)) if nonce
+    end
+
+    def on_reject(reject)
+      log.info { "reject #{reject}" }
+    end
+
     def on_tx(tx)
       log.info { "received transaction: #{tx.hash}" }
 

data/lib/bitcoin.rb

@@ -276,12 +276,23 @@ module Bitcoin
     end
 
     def sign_data(key, data)
-      sig = key.dsa_sign_asn1(data)
-      if Script.is_low_der_signature?(sig)
-        sig
-      else
-        Bitcoin::OpenSSL_EC.signature_to_low_s(sig)
-      end
+      sig = nil
+      loop {
+        sig = key.dsa_sign_asn1(data)
+        sig = if Script.is_low_der_signature?(sig)
+                sig
+              else
+                Bitcoin::OpenSSL_EC.signature_to_low_s(sig)
+              end
+
+        buf = sig + [Script::SIGHASH_TYPE[:all]].pack("C") # is_der_signature expects sig + sighash_type format
+        if Script.is_der_signature?(buf)
+          break
+        else
+          p ["Bitcoin#sign_data: invalid der signature generated, trying again.", data.unpack("H*")[0], sig.unpack("H*")[0]]
+        end
+      }
+      return sig
     end
 
     def verify_signature(hash, signature, public_key)
@@ -310,9 +321,13 @@ module Bitcoin
     end
 
     def bitcoin_signed_message_hash(message)
-      # TODO: this will fail horribly on messages with len > 255. It's a cheap implementation of Bitcoin's CDataStream.
-      data = "\x18Bitcoin Signed Message:\n" + [message.bytesize].pack("C") + message
-      Digest::SHA256.digest(Digest::SHA256.digest(data))
+      message = message.dup.force_encoding('binary')
+
+      magic = "Bitcoin Signed Message:\n"
+      buf = Protocol.pack_var_int(magic.bytesize) + magic
+      buf << Protocol.pack_var_int(message.bytesize) + message
+
+      Digest::SHA256.digest(Digest::SHA256.digest(buf))
     end
 
     def sign_message(private_key_hex, public_key_hex, message)
@@ -552,11 +567,13 @@ module Bitcoin
       free_tx_bytes: 1_000,
       dust: CENT,
       per_dust_fee: false,
+      bip34_height: 227931,
       dns_seeds: [
         "seed.bitcoin.sipa.be",
         "dnsseed.bluematt.me",
         "dnsseed.bitcoin.dashjr.org",
         "bitseed.xf2.org",
+        "dnsseed.webbtc.com",
       ],
       genesis_hash: "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f",
       proof_of_work_limit: 0x1d00ffff,
@@ -566,6 +583,7 @@ module Bitcoin
         'mining.bitcoin.cz',
         'blockchain.info',
         'blockexplorer.com',
+        'webbtc.com',
       ],
       checkpoints: {
          11111 => "0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d",
@@ -593,6 +611,7 @@ module Bitcoin
       extended_privkey_version: "04358394",
       extended_pubkey_version: "043587cf",
       default_port: 18333,
+      bip34_height: 21111,
       dns_seeds: [ ],
       genesis_hash: "00000007199508e34a9ff81e6ec0c477a4cccff2a4767a8eee39c11db367b008",
       proof_of_work_limit: 0x1d07fff8,
@@ -604,7 +623,8 @@ module Bitcoin
   NETWORKS[:regtest] = NETWORKS[:testnet].merge({
       default_port: 18444,
       genesis_hash: "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206",
-      proof_of_work_limit: (1 << 255) - 1,
+      proof_of_work_limit: 0x207fffff,
+      bip34_height: 0,
     })
 
   NETWORKS[:testnet3] = NETWORKS[:testnet].merge({
@@ -617,7 +637,9 @@ module Bitcoin
         "testnet-seed.bitcoin.schildbach.de",
         "testnet-seed.bitcoin.petertodd.org",
         "testnet-seed.bluematt.me",
+        "dnsseed.test.webbtc.com",
       ],
+      known_nodes: ["test.webbtc.com"],
       checkpoints: {
         # 542 contains invalid transaction
         542 => "0000000083c1f82cf72c6724f7a317325806384b06408bce7a4327f418dfd5ad",
@@ -811,11 +833,14 @@ module Bitcoin
       protocol_version: 35000,
       min_tx_fee: 50_000,
       per_dust_fee: true,
-      dns_seeds: [],
+      dns_seeds: [
+        "nmc.seed.quisquis.de",
+        "dnsseed.namecoin.webbtc.com",
+      ],
       genesis_hash: "000000000062b72c5e2ceb45fbc8587e807c155b0da735e6483dfba2f0a9c770",
       known_nodes: [
         "bitcoin.tunl.in",
-        "webbtc.com",
+        "namecoin.webbtc.com",
         "178.32.31.41",
         "78.47.86.43",
         "69.164.206.88",
@@ -833,11 +858,26 @@ module Bitcoin
   NETWORKS[:namecoin_testnet] = NETWORKS[:namecoin].merge({
       magic_head: "\xFA\xBF\xB5\xFE",
       default_port: 18334,
-      genesis_hash: "00000001f8ab0d14bceaeb50d163b0bef15aecf62b87bd5f5c864d37f201db97",
-      known_nodes: ["178.32.31.41"],
-      checkpoints: {
-        0 => "000000000062b72c5e2ceb45fbc8587e807c155b0da735e6483dfba2f0a9c770",
-      }
+      genesis_hash: "00000007199508e34a9ff81e6ec0c477a4cccff2a4767a8eee39c11db367b008",
+      dns_seeds: [
+        "dnsseed.test.namecoin.webbtc.com",
+      ],
+      known_nodes: [
+        "test.namecoin.webbtc.com",
+        "nmctest.net",
+        "192.99.247.234"],
+      checkpoints: { }
+    })
+
+  NETWORKS[:namecoin_regtest] = NETWORKS[:namecoin_testnet].merge({
+      magic_head: "\xFA\xBF\xB5\xDA",
+      default_port: 18445,
+      genesis_hash: "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206",
+      dns_seeds: [], known_nodes: [],
+      proof_of_work_limit: 0x207fffff,
+      checkpoints: { },
+      address_versions: { pubkey_hash: "6f", script_hash: "c4" },
+      privkey_version: "ef",
     })
 
 end

data/lib/bitcoin/builder.rb

@@ -14,7 +14,6 @@ module Bitcoin
       yield c
       c.block(target)
     end
-    alias :blk :build_block
 
     # build a Bitcoin::Protocol::Tx.
     # see TxBuilder for details.
@@ -23,7 +22,6 @@ module Bitcoin
       yield c
       c.tx opts
     end
-    alias :tx :build_tx
 
     # build a Bitcoin::Script.
     # see ScriptBuilder for details.
@@ -95,7 +93,7 @@ module Bitcoin
         @block.bits = Bitcoin.encode_compact_bits(target)
         t = Time.now
         @block.recalc_block_hash
-        until @block.hash < target
+        until @block.hash.to_i(16) < target.to_i(16)
           @block.nonce += 1
           @block.recalc_block_hash
           if @block.nonce == 100000
@@ -156,9 +154,11 @@ module Bitcoin
       end
 
       # add an output to the transaction (see TxOutBuilder).
-      def output
+      def output value = nil, recipient = nil, type = :address
         c = TxOutBuilder.new
-        yield c
+        c.value(value)  if value
+        c.to(recipient, type)  if recipient
+        yield c  if block_given?
         @outs << c
       end
 
@@ -173,18 +173,20 @@ module Bitcoin
       # case to specify a tx fee that should be left unclaimed by the
       # change output.
       def tx opts = {}
+        return @tx  if @tx.hash
+
         if opts[:change_address] && !opts[:input_value]
           raise "Must give 'input_value' when auto-generating change output!"
         end
         @ins.each {|i| @tx.add_in(i.txin) }
         @outs.each {|o| @tx.add_out(o.txout) }
-
         if opts[:change_address]
-          output_value = @tx.out.map(&:value).inject(:+)
+          output_value = @tx.out.map(&:value).inject(:+) || 0
           change_value = opts[:input_value] - output_value
           if opts[:leave_fee]
-            if change_value >= @tx.minimum_block_fee
-              change_value -= @tx.minimum_block_fee
+            fee = @tx.minimum_block_fee + (opts[:extra_fee] || 0)
+            if change_value >= fee
+              change_value -= fee
             else
               change_value = 0
             end
@@ -219,7 +221,7 @@ module Bitcoin
       def sig_hash_and_all_keys_exist?(inc, sig_script)
         return false unless @sig_hash && inc.has_keys?
         script = Bitcoin::Script.new(sig_script)
-        return true if script.is_hash160? || script.is_pubkey?
+        return true if script.is_hash160? || script.is_pubkey? || (Bitcoin.namecoin? && script.is_namecoin?)
         if script.is_multisig?
           return inc.has_multiple_keys? && inc.key.size >= script.get_signatures_required
         end
@@ -426,6 +428,9 @@ module Bitcoin
 
     # Create a Bitcoin::Protocol::TxOut used by TxBuilder#output.
     #
+    #  t.output 12345, address
+    #  t.output 12345, p2sh_address, :script_hash
+    #
     #  t.output {|o| o.value 12345; o.to address }
     #
     #  t.output do |o|

data/lib/bitcoin/ffi/bitcoinconsensus.rb

@@ -2,8 +2,9 @@
 
 require 'ffi'
 
-# Wraps bitcoinconsensus.so (https://github.com/bitcoin/bitcoin)
-# commit: 90c71548c795787b008bc337cb9332f75d1bccdb
+# binding for src/.libs/bitcoinconsensus.so (https://github.com/bitcoin/bitcoin)
+# tag: v0.11.0
+# commit: d26f951802c762de04fb68e1a112d611929920ba
 
 module Bitcoin
   module BitcoinConsensus

data/lib/bitcoin/ffi/secp256k1.rb

@@ -1,7 +1,8 @@
 # encoding: ascii-8bit
 
-# Wraps libsecp256k1 (https://github.com/bitcoin/secp256k1)
-# commit: 50cc6ab0625efda6dddf1dc86c1e2671f069b0d8
+# bindings for secp256k1 inside bitcoin (https://github.com/bitcoin/bitcoin/tree/v0.11.0/src/secp256k1)
+# tag: v0.11.0
+# commit: d26f951802c762de04fb68e1a112d611929920ba
 
 require 'ffi'
 
@@ -16,128 +17,189 @@ module Bitcoin
       class_eval <<-RUBY
         ffi_lib [ %[#{file}] ]
 
-        attach_function :secp256k1_start, [:int], :void
-        attach_function :secp256k1_stop, [], :void
-        attach_function :secp256k1_ec_seckey_verify, [:pointer], :int
-        attach_function :secp256k1_ec_pubkey_verify, [:pointer, :int], :int
-        attach_function :secp256k1_ec_pubkey_create, [:pointer, :pointer, :pointer, :int], :int
+        ##
+        # source: https://github.com/bitcoin/bitcoin/blob/v0.11.0/src/secp256k1/include/secp256k1.h
+        ##
 
-        # int secp256k1_ecdsa_sign(const unsigned char *msg32, unsigned char *sig, int *siglen, const unsigned char *seckey, secp256k1_nonce_function_t noncefp, const void *ndata)
-        attach_function :secp256k1_ecdsa_sign, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int
+        # secp256k1_context_t* secp256k1_context_create(int flags)
+        attach_function :secp256k1_context_create, [:int], :pointer
 
-        # int secp256k1_ecdsa_verify(const unsigned char *msg32, const unsigned char *sig, int siglen, const unsigned char *pubkey, int pubkeylen)
-        attach_function :secp256k1_ecdsa_verify, [:pointer, :pointer, :int, :pointer, :int], :int
+        # secp256k1_context_t* secp256k1_context_clone(const secp256k1_context_t* ctx)
+        attach_function :secp256k1_context_clone, [:pointer], :pointer
 
-        # int secp256k1_ecdsa_sign_compact(const unsigned char *msg32, unsigned char *sig64, const unsigned char *seckey, secp256k1_nonce_function_t noncefp, const void *ndata, int *recid)
-        attach_function :secp256k1_ecdsa_sign_compact, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int
+        # void secp256k1_context_destroy(secp256k1_context_t* ctx)
+        attach_function :secp256k1_context_destroy, [:pointer], :void
 
-        # int secp256k1_ecdsa_recover_compact(const unsigned char *msg32, const unsigned char *sig64, unsigned char *pubkey, int *pubkeylen, int compressed, int recid)
-        attach_function :secp256k1_ecdsa_recover_compact, [:pointer, :pointer, :pointer, :pointer, :int, :int], :int
+        # int secp256k1_ecdsa_verify(const secp256k1_context_t* ctx, const unsigned char *msg32, const unsigned char *sig, int siglen, const unsigned char *pubkey, int pubkeylen)
+        attach_function :secp256k1_ecdsa_verify, [:pointer, :pointer, :pointer, :int, :pointer, :int], :int
+
+        # int secp256k1_ecdsa_sign(const secp256k1_context_t* ctx, const unsigned char *msg32, unsigned char *sig, int *siglen, const unsigned char *seckey, secp256k1_nonce_function_t noncefp, const void *ndata)
+        attach_function :secp256k1_ecdsa_sign, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int
+
+        # int secp256k1_ecdsa_sign_compact(const secp256k1_context_t* ctx, const unsigned char *msg32, unsigned char *sig64, const unsigned char *seckey, secp256k1_nonce_function_t noncefp, const void *ndata, int *recid)
+        attach_function :secp256k1_ecdsa_sign_compact, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int
+
+        # int secp256k1_ecdsa_recover_compact(const secp256k1_context_t* ctx, const unsigned char *msg32, const unsigned char *sig64, unsigned char *pubkey, int *pubkeylen, int compressed, int recid)
+        attach_function :secp256k1_ecdsa_recover_compact, [:pointer, :pointer, :pointer, :pointer, :pointer, :int, :int], :int
+
+        # int secp256k1_ec_seckey_verify(const secp256k1_context_t* ctx, const unsigned char *seckey)
+        attach_function :secp256k1_ec_seckey_verify, [:pointer, :pointer], :int
+
+        # int secp256k1_ec_pubkey_verify(const secp256k1_context_t* ctx, const unsigned char *pubkey, int pubkeylen)
+        attach_function :secp256k1_ec_pubkey_verify, [:pointer, :pointer, :int], :int
+
+        # int secp256k1_ec_pubkey_create(const secp256k1_context_t* ctx, unsigned char *pubkey, int *pubkeylen, const unsigned char *seckey, int compressed)
+        attach_function :secp256k1_ec_pubkey_create, [:pointer, :pointer, :pointer, :pointer, :int], :int
+
+        # int secp256k1_ec_pubkey_decompress(const secp256k1_context_t* ctx, unsigned char *pubkey, int *pubkeylen)
+        attach_function :secp256k1_ec_pubkey_decompress, [:pointer, :pointer, :pointer], :int
+
+        # int secp256k1_ec_privkey_export(const secp256k1_context_t* ctx, const unsigned char *seckey, unsigned char *privkey, int *privkeylen, int compressed)
+        attach_function :secp256k1_ec_privkey_export, [:pointer, :pointer, :pointer, :pointer, :int], :int
+
+        # int secp256k1_ec_privkey_import(const secp256k1_context_t* ctx, unsigned char *seckey, const unsigned char *privkey, int privkeylen)
+        attach_function :secp256k1_ec_privkey_import, [:pointer, :pointer, :pointer, :pointer], :int
+
+        # int secp256k1_ec_privkey_tweak_add(const secp256k1_context_t* ctx, unsigned char *seckey, const unsigned char *tweak)
+        attach_function :secp256k1_ec_privkey_tweak_add, [:pointer, :pointer, :pointer], :int
+
+        # int secp256k1_ec_pubkey_tweak_add(const secp256k1_context_t* ctx, unsigned char *pubkey, int pubkeylen, const unsigned char *tweak)
+        attach_function :secp256k1_ec_pubkey_tweak_add, [:pointer, :pointer, :int, :pointer], :int
+
+        # int secp256k1_ec_privkey_tweak_mul(const secp256k1_context_t* ctx, unsigned char *seckey, const unsigned char *tweak)
+        attach_function :secp256k1_ec_privkey_tweak_mul, [:pointer, :pointer, :pointer], :int
+
+        # int secp256k1_ec_pubkey_tweak_mul(const secp256k1_context_t* ctx, unsigned char *pubkey, int pubkeylen, const unsigned char *tweak)
+        attach_function :secp256k1_ec_pubkey_tweak_mul, [:pointer, :pointer, :int, :pointer], :int
+
+        # int secp256k1_context_randomize(secp256k1_context_t* ctx, const unsigned char *seed32)
+        attach_function :secp256k1_context_randomize, [:pointer, :pointer], :int
       RUBY
     end
 
     def self.init
-      return if @secp256k1_started
-
-      lib_path = [ ENV['SECP256K1_LIB_PATH'], 'vendor/secp256k1/.libs/libsecp256k1.so' ].find{|f| File.exists?(f.to_s) }
-      lib_path = 'libsecp256k1.so' unless lib_path
+      return if @loaded
+      lib_path = [ ENV['SECP256K1_LIB_PATH'], 'vendor/bitcoin/src/secp256k1/.libs/libsecp256k1.so' ].find{|f| File.exists?(f.to_s) }
       ffi_load_functions(lib_path)
-
-      secp256k1_start(SECP256K1_START_VERIFY | SECP256K1_START_SIGN)
-      @secp256k1_started = true
+      @loaded = true
     end
 
-    def self.generate_key_pair(compressed=true)
+    def self.with_context(flags=nil, seed=nil)
       init
-
-      while true do
-        priv_key = SecureRandom.random_bytes(32)
-        priv_key_buf = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, priv_key)
-        break if secp256k1_ec_seckey_verify(priv_key_buf)
+      flags = flags || (SECP256K1_START_VERIFY | SECP256K1_START_SIGN )
+      context = secp256k1_context_create(flags)
+
+      ret, tries, max = 0, 0, 20
+      while ret != 1
+        raise "secp256k1_context_randomize failed." if tries >= max
+        tries += 1
+        ret = secp256k1_context_randomize(context, FFI::MemoryPointer.from_string(seed || SecureRandom.random_bytes(32)))
       end
 
-      pub_key_buf = FFI::MemoryPointer.new(:uchar, 65)
-      pub_key_size = FFI::MemoryPointer.new(:int)
-      result = secp256k1_ec_pubkey_create(pub_key_buf, pub_key_size, priv_key_buf, compressed ? 1 : 0)
-      raise "error creating pubkey" unless result
-
-      [ priv_key, pub_key_buf.read_string(pub_key_size.read_int) ]
+      yield(context) if block_given?
+    ensure
+      secp256k1_context_destroy(context)
     end
 
-    def self.sign(data, priv_key)
-      init
+    def self.generate_key_pair(compressed=true)
+      with_context do |context|
+
+        ret, tries, max = 0, 0, 20
+        while ret != 1
+          raise "secp256k1_ec_seckey_verify in generate_key_pair failed." if tries >= max
+          tries += 1
 
-      msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
-      seckey = FFI::MemoryPointer.new(:uchar, priv_key.bytesize).put_bytes(0, priv_key)
-      raise "priv_key invalid" unless secp256k1_ec_seckey_verify(seckey)
+          priv_key = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, SecureRandom.random_bytes(32))
+          ret = secp256k1_ec_seckey_verify(context, priv_key)
+        end
 
-      sig, siglen = FFI::MemoryPointer.new(:uchar, 72), FFI::MemoryPointer.new(:int).write_int(72)
+        pub_key, pub_key_length = FFI::MemoryPointer.new(:uchar, 65), FFI::MemoryPointer.new(:int)
+        result = secp256k1_ec_pubkey_create(context, pub_key, pub_key_length, priv_key, compressed ? 1 : 0)
+        raise "error creating pubkey" unless result
 
-      while true do
-        break if secp256k1_ecdsa_sign(msg32, sig, siglen, seckey, nil, nil)
+        [ priv_key.read_string(32), pub_key.read_string(pub_key_length.read_int) ]
       end
+    end
 
-      sig.read_string(siglen.read_int)
+    def self.generate_key(compressed=true)
+      priv, pub = generate_key_pair(compressed)
+      Bitcoin::Key.new(priv.unpack("H*")[0], pub.unpack("H*")[0])
     end
 
-    def self.verify(data, signature, pub_key)
-      init
+    def self.sign(data, priv_key)
+      with_context do |context|
+        msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
+        seckey = FFI::MemoryPointer.new(:uchar, priv_key.bytesize).put_bytes(0, priv_key)
+        raise "priv_key invalid" unless secp256k1_ec_seckey_verify(context, seckey)
 
-      data_buf = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
-      sig_buf  = FFI::MemoryPointer.new(:uchar, signature.bytesize).put_bytes(0, signature)
-      pub_buf  = FFI::MemoryPointer.new(:uchar, pub_key.bytesize).put_bytes(0, pub_key)
+        sig, siglen = FFI::MemoryPointer.new(:uchar, 72), FFI::MemoryPointer.new(:int).write_int(72)
 
-      result = secp256k1_ecdsa_verify(data_buf, sig_buf, sig_buf.size, pub_buf, pub_buf.size)
+        while true do
+          break if secp256k1_ecdsa_sign(context, msg32, sig, siglen, seckey, nil, nil)
+        end
 
-      case result
-      when  0; false
-      when  1; true
-      when -1; raise "error invalid pubkey"
-      when -2; raise "error invalid signature"
-      else   ; raise "error invalid result"
+        sig.read_string(siglen.read_int)
+      end
+    end
+
+    def self.verify(data, signature, pub_key)
+      with_context do |context|
+        data_buf = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
+        sig_buf  = FFI::MemoryPointer.new(:uchar, signature.bytesize).put_bytes(0, signature)
+        pub_buf  = FFI::MemoryPointer.new(:uchar, pub_key.bytesize).put_bytes(0, pub_key)
+
+        result = secp256k1_ecdsa_verify(context, data_buf, sig_buf, sig_buf.size, pub_buf, pub_buf.size)
+
+        case result
+        when  0; false
+        when  1; true
+        when -1; raise "error invalid pubkey"
+        when -2; raise "error invalid signature"
+        else   ; raise "error invalid result"
+        end
       end
     end
 
     def self.sign_compact(message, priv_key, compressed=true)
-      init
+      with_context do |context|
+        msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, message)
+        sig64 = FFI::MemoryPointer.new(:uchar, 64)
+        rec_id = FFI::MemoryPointer.new(:int)
 
-      msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, message)
-      sig64 = FFI::MemoryPointer.new(:uchar, 64)
-      rec_id = FFI::MemoryPointer.new(:int)
+        seckey = FFI::MemoryPointer.new(:uchar, priv_key.bytesize).put_bytes(0, priv_key)
+        raise "priv_key invalid" unless secp256k1_ec_seckey_verify(context, seckey)
 
-      seckey = FFI::MemoryPointer.new(:uchar, priv_key.bytesize).put_bytes(0, priv_key)
-      raise "priv_key invalid" unless secp256k1_ec_seckey_verify(seckey)
+        while true do
+          break if secp256k1_ecdsa_sign_compact(context, msg32, sig64, seckey, nil, nil, rec_id)
+        end
 
-      while true do
-        break if secp256k1_ecdsa_sign_compact(msg32, sig64, seckey, nil, nil, rec_id)
+        header = [27 + rec_id.read_int + (compressed ? 4 : 0)].pack("C")
+        [ header, sig64.read_string(64) ].join
       end
-
-      header = [27 + rec_id.read_int + (compressed ? 4 : 0)].pack("C")
-      [ header, sig64.read_string(64) ].join
     end
 
     def self.recover_compact(message, signature)
-      init
+      with_context do |context|
+        return nil if signature.bytesize != 65
 
-      return nil if signature.bytesize != 65
+        version = signature.unpack('C')[0]
+        return nil if version < 27 || version > 34
 
-      version = signature.unpack('C')[0]
-      return nil if version < 27 || version > 34
+        compressed = version >= 31 ? true : false
+        version -= 4 if compressed
 
-      compressed = version >= 31 ? true : false
-      version -= 4 if compressed
+        recid = version - 27
+        msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, message)
+        sig64 = FFI::MemoryPointer.new(:uchar, 64).put_bytes(0, signature[1..-1])
+        pubkey = FFI::MemoryPointer.new(:uchar, pub_key_len = compressed ? 33 : 65)
+        pubkeylen = FFI::MemoryPointer.new(:int).write_int(pub_key_len)
 
-      recid = version - 27
-      msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, message)
-      sig64 = FFI::MemoryPointer.new(:uchar, 64).put_bytes(0, signature[1..-1])
-      pubkey = FFI::MemoryPointer.new(:uchar, pub_key_len = compressed ? 33 : 65)
-      pubkeylen = FFI::MemoryPointer.new(:int).write_int(pub_key_len)
+        result = secp256k1_ecdsa_recover_compact(context, msg32, sig64, pubkey, pubkeylen, (compressed ? 1 : 0), recid)
 
-      result = secp256k1_ecdsa_recover_compact(msg32, sig64, pubkey, pubkeylen, (compressed ? 1 : 0), recid)
+        return nil unless result
 
-      return nil unless result
-
-      pubkey.read_bytes(pubkeylen.read_int)
+        pubkey.read_bytes(pubkeylen.read_int)
+      end
     end
 
   end