secp256k1zkp 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 951b1330ba2ce304878210145ac200583994dad6
+  data.tar.gz: ac91e14b4c07918be085d3d32f0df83cafae6f7e
+SHA512:
+  metadata.gz: b150ff39fd63b32f55f324fc99abf20d336e961a7a2348dc5cf26527726a52a18dc7cb006eead9fae9533eb94c9d2f302532e2bc6e474a64424814e04010cff5
+  data.tar.gz: 5b58160792d93e8b46b998e25e0de1773e73ee90c137f742c4ef76cf88ba7bc629e38e1aa0d6fbb6926b900477d02c439fb2dd279be96f8923768ae3afd51857

data/README.md

@@ -0,0 +1 @@
+# secp256k1zkp

data/Rakefile

@@ -0,0 +1,5 @@
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new "secp256k1zkp" do |ext|
+  ext.lib_dir = "lib/secp256k1zkp"
+end

data/ext/secp256k1zkp/extconf.rb

@@ -0,0 +1,85 @@
+#encoding:utf-8
+
+require 'mini_portile2'
+require 'mkmf'
+require 'zip'
+
+class Secp256k1Recipe < MiniPortile
+
+  LIBSECP256K1_ZIP_URL = 'https://github.com/syalon/secp256k1-zkp/archive/bd067945ead3b514fba884abd0de95fc4b5db9ae.zip'
+  LIBSECP256K1_SHA256 = '379f7920d382d2b54bc5c092bb6c39b03c7f74508369cac5464cb9cbd8459dc0'
+
+  def initialize
+    super('libsecp256k1', '0.0.0')
+    @tarball = File.join(Dir.pwd, "/ports/archives/libsecp256k1.zip")
+    @files = ["file://#{@tarball}"]
+    self.configure_options += [
+      "--disable-benchmark",
+      "--disable-exhaustive-tests",
+      "--disable-tests",
+      "--disable-debug",
+      "--enable-experimental",
+      "--with-pic=yes"
+    ]
+  end
+
+  def configure
+    if RUBY_PLATFORM =~ /mingw|mswin/
+      execute('autogen', %w[sh ./autogen.sh])
+    else
+      execute('autogen', %w[./autogen.sh])
+    end
+    super
+  end
+
+  def download
+    download_file_http(LIBSECP256K1_ZIP_URL, @tarball)
+    verify_file(local_path: @tarball, sha256: LIBSECP256K1_SHA256) if LIBSECP256K1_SHA256
+  end
+
+  def downloaded?
+    File.exist?(@tarball)
+  end
+
+  def extract_zip_file(file, destination)
+    FileUtils.mkdir_p(destination)
+
+    Zip::File.open(file) do |zip_file|
+      zip_file.each do |f|
+        fpath = File.join(destination, f.name)
+        zip_file.extract(f, fpath) unless File.exist?(fpath)
+      end
+    end
+  end
+
+  def extract
+    files_hashs.each do |file|
+      extract_zip_file(file[:local_path], tmp_path)
+    end
+  end
+end
+
+recipe = Secp256k1Recipe.new
+recipe.cook
+recipe.activate
+
+append_cflags(
+  [
+    "-I#{recipe.path}/include",
+    "-fPIC",
+    "-Wno-undef",
+    "-Wall"
+  ]
+)
+
+append_ldflags(
+  [
+    "-Wl,--no-as-needed"
+  ]
+)
+
+$LIBPATH = ["#{recipe.path}/lib"] | $LIBPATH
+have_library("secp256k1")
+have_library("gmp")
+have_header('secp256k1')
+create_makefile('secp256k1zkp')

data/ext/secp256k1zkp/secp256k1zkp.c

@@ -0,0 +1,739 @@
+/**
+ *  secp256k1zkp.c
+ */
+
+#include <ruby.h>
+#include <secp256k1.h>
+
+/*
+ *  宏 - 类型检测
+ */
+#define Check_AnyType(obj, klass)                                   \
+  if (rb_obj_class(obj) != klass)                                   \
+  {                                                                 \
+    rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)", \
+             rb_obj_classname(obj), rb_class2name(klass));          \
+  }
+
+/**
+ *  Secp256k1Zkp
+ *    - Context
+ *    - PublicKey
+ *    - PrivateKey
+ */
+static VALUE rb_mSecp256k1 = Qnil;
+static VALUE rb_cSecp256k1Context = Qnil;
+static VALUE rb_cSecp256k1PublicKey = Qnil;
+static VALUE rb_cSecp256k1PrivateKey = Qnil;
+
+/**
+ *  全局上下文
+ */
+static secp256k1_context_t *_g_secp256k1_context_ptr = 0;
+
+/**
+ *  部分数据类型定义
+ */
+typedef struct
+{
+  secp256k1_context_t *ctx; // Context used by libsecp256k1 library
+  int flags;
+} rb_struct_context;
+
+/**
+ *  各种数据结构字节数定义
+ */
+#define kByteSizePrivateKeyData 32
+#define kByteSizePublicKeyPoint 65
+#define kByteSizeCompressedPublicKeyData 33
+#define kByteSizeCompactSignature 65
+#define kByteSizeBlindFactor 32
+#define kByteSizeCommitment 33
+#define kByteSizeSha256 32
+
+typedef struct
+{
+  unsigned char data[kByteSizePrivateKeyData];
+} rb_struct_private_key;
+
+//  the full non-compressed version of the ECC point
+typedef struct
+{
+  unsigned char data[kByteSizePublicKeyPoint];
+} rb_struct_pubkey_point;
+
+typedef struct
+{
+  unsigned char data[kByteSizeCompressedPublicKeyData];
+} rb_struct_pubkey_compressed;
+
+typedef struct
+{
+  unsigned char data[kByteSizeCompactSignature];
+} rb_struct_compact_signature;
+
+typedef struct
+{
+  unsigned char data[kByteSizeBlindFactor];
+} rb_struct_blind_factor_type;
+
+typedef struct
+{
+  unsigned char data[kByteSizeCommitment];
+} rb_struct_commitment_type;
+
+/**
+ *  Secp256k1Zkp::Context
+ */
+static void Context_free(void *data)
+{
+  rb_struct_context *context = (rb_struct_context *)data;
+  secp256k1_context_destroy(context->ctx);
+  context->flags = 0;
+  xfree(context);
+}
+
+static const rb_data_type_t rb_type_context = {
+    "Context",
+    {0, Context_free, 0},
+    0,
+    0,
+    RUBY_TYPED_FREE_IMMEDIATELY};
+
+static VALUE dm_context_alloc(VALUE klass)
+{
+  rb_struct_context *context = ALLOC(rb_struct_context);
+  MEMZERO(context, rb_struct_context, 1);
+
+  return TypedData_Wrap_Struct(klass, &rb_type_context, context);
+}
+
+/**
+ *  Secp256k1Zkp::PublicKey
+ */
+static void PublicKey_free(void *data)
+{
+  xfree((rb_struct_pubkey_compressed *)data);
+}
+
+static const rb_data_type_t rb_type_public_key = {
+    "PublicKey",
+    {0, PublicKey_free, 0},
+    0,
+    0,
+    RUBY_TYPED_FREE_IMMEDIATELY};
+
+static VALUE dm_public_key_alloc(VALUE klass)
+{
+  rb_struct_pubkey_compressed *public_key = ALLOC(rb_struct_pubkey_compressed);
+  MEMZERO(public_key, rb_struct_pubkey_compressed, 1);
+
+  return TypedData_Wrap_Struct(klass, &rb_type_public_key, public_key);
+}
+
+/**
+ *  Secp256k1Zkp::PrivateKey
+ */
+static void PrivateKey_free(void *data)
+{
+  xfree((rb_struct_private_key *)data);
+}
+
+static const rb_data_type_t rb_type_private_key = {
+    "PrivateKey",
+    {0, PrivateKey_free, 0},
+    0,
+    0,
+    RUBY_TYPED_FREE_IMMEDIATELY};
+
+static VALUE dm_private_key_alloc(VALUE klass)
+{
+  rb_struct_private_key *private_key = ALLOC(rb_struct_private_key);
+  MEMZERO(private_key, rb_struct_private_key, 1);
+
+  return TypedData_Wrap_Struct(klass, &rb_type_private_key, private_key);
+}
+
+/**
+ * Secp256k1Zkp::Context.new(flags)
+ *
+ * 创建Secp256k1上下文对象。
+ *
+ * @param flags [Fixnum] 上下文标记。
+ * @return [Context] 
+ */
+static VALUE dm_context_initialize(VALUE self, VALUE flags)
+{
+  rb_struct_context *context;
+  int i_flags;
+
+  Check_Type(flags, T_FIXNUM);
+  i_flags = FIX2INT(flags);
+
+  TypedData_Get_Struct(self, rb_struct_context, &rb_type_context, context);
+
+  context->ctx = secp256k1_context_create(i_flags);
+  context->flags = i_flags;
+
+  return self;
+}
+
+/**
+ * Secp256k1Zkp::Context#is_valid_public_keydata?(public_keydata)
+ *
+ * 是否是有效的公钥判断。
+ *
+ * @param public_keydata [String] 压缩公钥字符串。
+ * @return [Boolean] 
+ */
+static VALUE dm_context_verify_public_keydata(VALUE self, VALUE public_keydata)
+{
+  rb_struct_context *context;
+  TypedData_Get_Struct(self, rb_struct_context, &rb_type_context, context);
+
+  if (RB_TYPE_P(public_keydata, T_STRING) && secp256k1_ec_pubkey_verify(context->ctx, (const unsigned char *)RSTRING_PTR(public_keydata), (int)RSTRING_LEN(public_keydata)))
+  {
+    return Qtrue;
+  }
+
+  return Qfalse;
+}
+
+/**
+ * Secp256k1Zkp::Context#is_valid_private_keydata?(private_keydata)
+ *
+ * 是否是有效的私钥判断。
+ *
+ * @param private_keydata [String] 私钥字符串。
+ * @return [Boolean] 
+ */
+static VALUE dm_context_verify_private_keydata(VALUE self, VALUE private_keydata)
+{
+  rb_struct_context *context;
+  TypedData_Get_Struct(self, rb_struct_context, &rb_type_context, context);
+
+  if (RB_TYPE_P(private_keydata, T_STRING) &&
+      RSTRING_LEN(private_keydata) == kByteSizePrivateKeyData &&
+      secp256k1_ec_seckey_verify(context->ctx, (const unsigned char *)RSTRING_PTR(private_keydata)))
+  {
+    return Qtrue;
+  }
+
+  return Qfalse;
+}
+
+/**
+ * Secp256k1Zkp::Context#clone #dup
+ *
+ * 克隆Secp256k1上下文对象。
+ *
+ * @return [Context] 
+ */
+static VALUE dm_context_clone(VALUE self)
+{
+  rb_struct_context *context;
+  rb_struct_context *context_new;
+  VALUE new_instance;
+
+  TypedData_Get_Struct(self, rb_struct_context, &rb_type_context, context);
+
+  new_instance = dm_context_alloc(rb_cSecp256k1Context);
+  TypedData_Get_Struct(new_instance, rb_struct_context, &rb_type_context, context_new);
+  context_new->ctx = secp256k1_context_clone(context->ctx);
+  context_new->flags = context->flags;
+
+  return new_instance;
+}
+
+static int extended_nonce_function(unsigned char *nonce32, const unsigned char *msg32,
+                                   const unsigned char *key32, unsigned int attempt,
+                                   const void *data)
+{
+  unsigned int *extra = (unsigned int *)data;
+  (*extra)++;
+  return secp256k1_nonce_function_default(nonce32, msg32, key32, *extra, 0);
+};
+
+static int is_canonical(const rb_struct_compact_signature *sign)
+{
+  const unsigned char *c = sign->data;
+  if (!(c[1] & 0x80) && !(c[1] == 0 && !(c[2] & 0x80)) && !(c[33] & 0x80) && !(c[33] == 0 && !(c[34] & 0x80)))
+  {
+    return 1;
+  }
+  return 0;
+}
+
+/**
+ * Secp256k1Zkp::Context#sign_compact(message_digest, private_key)
+ *
+ * 生成紧凑格式的 ECDSA 签名（recId + 64字节）。
+ *
+ * @param message_digest [String] 待签名的消息摘要（SHA256摘要、32字节）。
+ * @param private_key [Secp256k1Zkp::PrivateKey] 私钥。
+ * @return [String] 
+ */
+static VALUE dm_context_sign_compact(VALUE self, VALUE message_digest, VALUE private_key)
+{
+  rb_struct_context *context;
+  rb_struct_private_key *sp_private_key;
+  const unsigned char *digest32;
+  int require_canonical;
+  int recid;
+  unsigned int counter;
+  rb_struct_compact_signature signature = {
+      0,
+  };
+
+  SafeStringValue(message_digest);
+  if (RSTRING_LEN(message_digest) != kByteSizeSha256)
+  {
+    rb_raise(rb_eRuntimeError, "invalid message digest32.");
+  }
+  Check_AnyType(private_key, rb_cSecp256k1PrivateKey);
+
+  TypedData_Get_Struct(self, rb_struct_context, &rb_type_context, context);
+
+  //  check flags
+  if (!(context->flags & SECP256K1_CONTEXT_SIGN))
+  {
+    rb_raise(rb_eRuntimeError, "invalid secp256k1 context, missing `SECP256K1_CONTEXT_SIGN` flag.");
+  }
+
+  TypedData_Get_Struct(private_key, rb_struct_private_key, &rb_type_private_key, sp_private_key);
+
+  //  初始化部分参数
+  digest32 = (const unsigned char *)RSTRING_PTR(message_digest);
+  require_canonical = 0; //  0 or 1
+  counter = 0;
+
+  //  循环计算签名，直到找到合适的 canonical 签名。
+  do
+  {
+    if (!secp256k1_ecdsa_sign_compact(context->ctx, digest32,
+                                      &signature.data[1],
+                                      sp_private_key->data,
+                                      extended_nonce_function,
+                                      &counter, &recid))
+    {
+      return Qnil;
+    }
+  } while (require_canonical && !is_canonical(&signature));
+  signature.data[0] = 27 + 4 + recid;
+
+  return rb_str_new((const char *)&signature.data[0], sizeof(signature.data));
+}
+
+/**
+ * Secp256k1Zkp::Context#pedersen_commit(blind_factor, value)
+ *
+ * 生成佩德森承诺。
+ *
+ * @param blind_factor [String] 盲化因子。
+ * @param value [Integer] 承诺的数值。
+ * @return [String] 
+ */
+static VALUE dm_context_pedersen_commit(VALUE self, VALUE blind_factor, VALUE value)
+{
+  rb_struct_context *context;
+  rb_struct_commitment_type commitment = {
+      0,
+  };
+
+  SafeStringValue(blind_factor);
+  if (RSTRING_LEN(blind_factor) != kByteSizeBlindFactor)
+  {
+    rb_raise(rb_eRuntimeError, "invalid blind_factor.");
+  }
+
+  TypedData_Get_Struct(self, rb_struct_context, &rb_type_context, context);
+
+  //  check flags
+  if (!(context->flags & SECP256K1_CONTEXT_SIGN))
+  {
+    rb_raise(rb_eRuntimeError, "invalid secp256k1 context, missing `SECP256K1_CONTEXT_SIGN` flag.");
+  }
+  if (!(context->flags & SECP256K1_CONTEXT_COMMIT))
+  {
+    rb_raise(rb_eRuntimeError, "invalid secp256k1 context, missing `SECP256K1_CONTEXT_COMMIT` flag.");
+  }
+
+  if (!secp256k1_pedersen_commit(context->ctx, commitment.data, (unsigned char *)RSTRING_PTR(blind_factor), (uint64_t)NUM2ULL(value)))
+  {
+    return Qnil;
+  }
+
+  return rb_str_new((const char *)&commitment.data[0], sizeof(commitment.data));
+}
+
+/**
+ * Secp256k1Zkp::Context#pedersen_blind_sum(blinds_in, non_neg)
+ *
+ * 盲化因子求和。
+ *
+ * @param blinds_in [Array] 盲化因子数组。
+ * @param non_neg [Integer] 正因子数量。
+ * @return [String] 
+ */
+static VALUE dm_context_pedersen_blind_sum(VALUE self, VALUE blinds_in, VALUE non_neg)
+{
+  rb_struct_context *context;
+  long blinds_in_size;
+  rb_struct_blind_factor_type result = {
+      0,
+  };
+
+  Check_Type(blinds_in, T_ARRAY);
+
+  TypedData_Get_Struct(self, rb_struct_context, &rb_type_context, context);
+
+  blinds_in_size = RARRAY_LEN(blinds_in);
+  if (blinds_in_size <= 0)
+  {
+    return Qnil;
+  }
+  const unsigned char *blinds[blinds_in_size];
+  for (long i = 0; i < blinds_in_size; ++i)
+  {
+    VALUE blind_factor = rb_ary_entry(blinds_in, i);
+    SafeStringValue(blind_factor);
+    blinds[i] = (const unsigned char *)RSTRING_PTR(blind_factor);
+  }
+
+  if (!secp256k1_pedersen_blind_sum(context->ctx, result.data, blinds, (int)blinds_in_size, (uint32_t)NUM2UINT(non_neg)))
+  {
+    return Qnil;
+  }
+
+  return rb_str_new((const char *)&result.data[0], sizeof(result.data));
+}
+
+/**
+ * Secp256k1Zkp::Context#range_proof_sign(min_value, commit, commit_blind, nonce, base10_exp, min_bits, actual_value)
+ *
+ * 生成范围证明。
+ *
+ * @param * 参考 secp256k1_rangeproof_sign 参数。
+ * @return [String] 
+ */
+static VALUE dm_context_range_proof_sign(VALUE self, VALUE min_value, VALUE commit, VALUE commit_blind, VALUE nonce, VALUE base10_exp, VALUE min_bits, VALUE actual_value)
+{
+  rb_struct_context *context;
+  unsigned char proof[5134];
+  int proof_len;
+
+  SafeStringValue(commit);
+  SafeStringValue(commit_blind);
+  SafeStringValue(nonce);
+
+  TypedData_Get_Struct(self, rb_struct_context, &rb_type_context, context);
+
+  //  check flags
+  if (!(context->flags & SECP256K1_CONTEXT_SIGN))
+  {
+    rb_raise(rb_eRuntimeError, "invalid secp256k1 context, missing `SECP256K1_CONTEXT_SIGN` flag.");
+  }
+  if (!(context->flags & SECP256K1_CONTEXT_COMMIT))
+  {
+    rb_raise(rb_eRuntimeError, "invalid secp256k1 context, missing `SECP256K1_CONTEXT_COMMIT` flag.");
+  }
+  if (!(context->flags & SECP256K1_CONTEXT_RANGEPROOF))
+  {
+    rb_raise(rb_eRuntimeError, "invalid secp256k1 context, missing `SECP256K1_CONTEXT_RANGEPROOF` flag.");
+  }
+
+  proof_len = sizeof(proof);
+
+  if (!secp256k1_rangeproof_sign(context->ctx, proof, &proof_len, (uint64_t)NUM2ULL(min_value),
+                                 (const unsigned char *)RSTRING_PTR(commit), (const unsigned char *)RSTRING_PTR(commit_blind), (const unsigned char *)RSTRING_PTR(nonce),
+                                 (int8_t)FIX2INT(base10_exp), (uint8_t)FIX2INT(min_bits), (uint64_t)NUM2ULL(actual_value)))
+  {
+    return Qnil;
+  }
+
+  return rb_str_new((const char *)proof, proof_len);
+}
+
+/**
+ * Secp256k1Zkp::PublicKey.new(public_keydata)
+ *
+ * 创建公钥对象。
+ *
+ * @param public_keydata [String] 压缩公钥字符串。
+ * @return [Secp256k1Zkp::PublicKey] 
+ */
+static VALUE dm_public_key_initialize(VALUE self, VALUE public_keydata)
+{
+  rb_struct_pubkey_compressed *public_key;
+  TypedData_Get_Struct(self, rb_struct_pubkey_compressed, &rb_type_public_key, public_key);
+
+  SafeStringValue(public_keydata);
+  if (!secp256k1_ec_pubkey_verify(_g_secp256k1_context_ptr, (const unsigned char *)RSTRING_PTR(public_keydata), (int)RSTRING_LEN(public_keydata)))
+  {
+    rb_raise(rb_eRuntimeError, "invalid public key data.");
+  }
+
+  memcpy(public_key->data, RSTRING_PTR(public_keydata), sizeof(public_key->data));
+
+  return self;
+}
+
+/**
+ * Secp256k1Zkp::PublicKey#bytes
+ *
+ * 获取公钥数据。
+ *
+ * @return [String] 
+ */
+static VALUE dm_public_key_bytes(VALUE self)
+{
+  rb_struct_pubkey_compressed *public_key;
+  VALUE data = rb_iv_get(self, "data");
+  if (NIL_P(data))
+  {
+    TypedData_Get_Struct(self, rb_struct_pubkey_compressed, &rb_type_public_key, public_key);
+    data = rb_str_freeze(rb_str_new((const char *)public_key->data, sizeof(public_key->data)));
+    rb_iv_set(self, "data", data);
+  }
+  return data;
+}
+
+static VALUE public_key_tweak(VALUE self, VALUE tweak, int (*tweak_func)(const secp256k1_context_t *ctx, unsigned char *pubkey, int pubkeylen, const unsigned char *tweak))
+{
+  rb_struct_pubkey_compressed *public_key;
+  rb_struct_pubkey_compressed *new_public_key;
+  VALUE new_instance;
+
+  SafeStringValue(tweak);
+  if (RSTRING_LEN(tweak) != kByteSizePrivateKeyData)
+  {
+    rb_raise(rb_eRuntimeError, "invalid private key data.");
+  }
+
+  TypedData_Get_Struct(self, rb_struct_pubkey_compressed, &rb_type_public_key, public_key);
+
+  new_instance = dm_public_key_alloc(rb_cSecp256k1PublicKey);
+  TypedData_Get_Struct(new_instance, rb_struct_pubkey_compressed, &rb_type_public_key, new_public_key);
+  memcpy(new_public_key->data, public_key->data, sizeof(public_key->data));
+
+  if (!tweak_func(_g_secp256k1_context_ptr, new_public_key->data, sizeof(new_public_key->data), (const unsigned char *)RSTRING_PTR(tweak)))
+  {
+    rb_raise(rb_eRuntimeError, "tweak error.");
+  }
+
+  return new_instance;
+}
+
+/**
+ * Secp256k1Zkp::PublicKey#tweak_add(tweak)
+ * Secp256k1Zkp::PublicKey#+(tweak)
+ *
+ * 公钥加法，返回新的公钥。
+ *
+ * @param tweak [String] 参数。
+ * @return [Secp256k1Zkp::PublicKey] 
+ */
+static VALUE dm_public_key_tweak_add(VALUE self, VALUE tweak)
+{
+  return public_key_tweak(self, tweak, secp256k1_ec_pubkey_tweak_add);
+}
+
+/**
+ * Secp256k1Zkp::PublicKey#tweak_mul(tweak)
+ * Secp256k1Zkp::PublicKey#*(tweak)
+ *
+ * 公钥乘法，返回新的公钥。
+ *
+ * @param tweak [String] 参数。
+ * @return [Secp256k1Zkp::PublicKey] 
+ */
+static VALUE dm_public_key_tweak_mul(VALUE self, VALUE tweak)
+{
+  return public_key_tweak(self, tweak, secp256k1_ec_pubkey_tweak_mul);
+}
+
+/**
+ * Secp256k1Zkp::PrivateKey.new(private_keydata)
+ *
+ * 创建私钥对象。
+ *
+ * @param private_keydata [String] 私钥字符串。
+ * @return [Secp256k1Zkp::PrivateKey] 
+ */
+static VALUE dm_private_key_initialize(VALUE self, VALUE private_keydata)
+{
+  rb_struct_private_key *private_key;
+  TypedData_Get_Struct(self, rb_struct_private_key, &rb_type_private_key, private_key);
+
+  SafeStringValue(private_keydata);
+  if (RSTRING_LEN(private_keydata) != sizeof(private_key->data) ||
+      !secp256k1_ec_seckey_verify(_g_secp256k1_context_ptr, (const unsigned char *)RSTRING_PTR(private_keydata)))
+  {
+    rb_raise(rb_eRuntimeError, "invalid private key data.");
+  }
+
+  memcpy(private_key->data, RSTRING_PTR(private_keydata), sizeof(private_key->data));
+
+  return self;
+}
+
+/**
+ * Secp256k1Zkp::PrivateKey#bytes
+ *
+ * 获取私钥数据。
+ *
+ * @return [String] 
+ */
+static VALUE dm_private_key_bytes(VALUE self)
+{
+  rb_struct_private_key *private_key;
+  VALUE data = rb_iv_get(self, "data");
+  if (NIL_P(data))
+  {
+    TypedData_Get_Struct(self, rb_struct_private_key, &rb_type_private_key, private_key);
+    data = rb_str_freeze(rb_str_new((const char *)private_key->data, sizeof(private_key->data)));
+    rb_iv_set(self, "data", data);
+  }
+  return data;
+}
+
+static VALUE private_key_tweak(VALUE self, VALUE tweak, int (*tweak_func)(const secp256k1_context_t *ctx, unsigned char *seckey, const unsigned char *tweak))
+{
+  rb_struct_private_key *private_key;
+  rb_struct_private_key *new_private_key;
+  VALUE v_private_key;
+
+  SafeStringValue(tweak);
+  if (RSTRING_LEN(tweak) != kByteSizePrivateKeyData)
+  {
+    rb_raise(rb_eRuntimeError, "invalid private key data.");
+  }
+
+  TypedData_Get_Struct(self, rb_struct_private_key, &rb_type_private_key, private_key);
+
+  v_private_key = dm_private_key_alloc(rb_cSecp256k1PrivateKey);
+  TypedData_Get_Struct(v_private_key, rb_struct_private_key, &rb_type_private_key, new_private_key);
+  memcpy(new_private_key->data, private_key->data, sizeof(private_key->data));
+
+  if (!tweak_func(_g_secp256k1_context_ptr, new_private_key->data, (const unsigned char *)RSTRING_PTR(tweak)))
+  {
+    rb_raise(rb_eRuntimeError, "tweak error.");
+  }
+
+  return v_private_key;
+}
+
+/**
+ * Secp256k1Zkp::PrivateKey#tweak_add(tweak)
+ * Secp256k1Zkp::PrivateKey#+(tweak)
+ *
+ * 私钥加法，返回新的私钥。
+ *
+ * @param tweak [String] 参数。
+ * @return [Secp256k1Zkp::PrivateKey] 
+ */
+static VALUE dm_private_key_tweak_add(VALUE self, VALUE tweak)
+{
+  return private_key_tweak(self, tweak, secp256k1_ec_privkey_tweak_add);
+}
+
+/**
+ * Secp256k1Zkp::PrivateKey#tweak_mul(tweak)
+ * Secp256k1Zkp::PrivateKey#*(tweak)
+ *
+ * 私钥乘法，返回新的私钥。
+ *
+ * @param tweak [String] 参数。
+ * @return [Secp256k1Zkp::PrivateKey] 
+ */
+static VALUE dm_private_key_tweak_mul(VALUE self, VALUE tweak)
+{
+  return private_key_tweak(self, tweak, secp256k1_ec_privkey_tweak_mul);
+}
+
+/**
+ * Secp256k1Zkp::PrivateKey#to_public_key
+ *
+ * 根据私钥创建对应公钥。
+ *
+ * @return [Secp256k1Zkp::PublicKey] 
+ */
+static VALUE dm_private_key_to_public_key(VALUE self)
+{
+  rb_struct_private_key *private_key;
+  rb_struct_pubkey_compressed *output_public_key;
+  VALUE v_public_key;
+  int pubkey_len;
+
+  TypedData_Get_Struct(self, rb_struct_private_key, &rb_type_private_key, private_key);
+
+  v_public_key = dm_public_key_alloc(rb_cSecp256k1PublicKey);
+  TypedData_Get_Struct(v_public_key, rb_struct_pubkey_compressed, &rb_type_public_key, output_public_key);
+
+  pubkey_len = sizeof(output_public_key->data);
+  if (!secp256k1_ec_pubkey_create(_g_secp256k1_context_ptr, output_public_key->data, &pubkey_len, private_key->data, 1))
+  {
+    rb_raise(rb_eRuntimeError, "generate public key error.");
+  }
+
+  return v_public_key;
+}
+
+/**
+ *  扩展初始化（类似 main 函数入口）
+ */
+void Init_secp256k1zkp()
+{
+  if (!_g_secp256k1_context_ptr)
+  {
+    _g_secp256k1_context_ptr = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN);
+  }
+
+  //  Secp256k1Zkp
+  rb_mSecp256k1 = rb_define_module("Secp256k1Zkp");
+
+  rb_define_const(rb_mSecp256k1, "SECP256K1_CONTEXT_VERIFY", INT2FIX(SECP256K1_CONTEXT_VERIFY));
+  rb_define_const(rb_mSecp256k1, "SECP256K1_CONTEXT_SIGN", INT2FIX(SECP256K1_CONTEXT_SIGN));
+  rb_define_const(rb_mSecp256k1, "SECP256K1_CONTEXT_COMMIT", INT2FIX(SECP256K1_CONTEXT_COMMIT));
+  rb_define_const(rb_mSecp256k1, "SECP256K1_CONTEXT_RANGEPROOF", INT2FIX(SECP256K1_CONTEXT_RANGEPROOF));
+
+  //  Secp256k1Zkp::Context
+  rb_cSecp256k1Context = rb_define_class_under(rb_mSecp256k1, "Context", rb_cObject);
+
+  rb_undef_alloc_func(rb_cSecp256k1Context);
+  rb_define_alloc_func(rb_cSecp256k1Context, dm_context_alloc);
+  rb_define_method(rb_cSecp256k1Context, "initialize", dm_context_initialize, 1);
+  rb_define_method(rb_cSecp256k1Context, "is_valid_public_keydata?", dm_context_verify_public_keydata, 1);
+  rb_define_method(rb_cSecp256k1Context, "is_valid_private_keydata?", dm_context_verify_private_keydata, 1);
+  rb_define_method(rb_cSecp256k1Context, "clone", dm_context_clone, 0);
+  rb_define_method(rb_cSecp256k1Context, "dup", dm_context_clone, 0);
+  rb_define_method(rb_cSecp256k1Context, "sign_compact", dm_context_sign_compact, 2);
+  rb_define_method(rb_cSecp256k1Context, "pedersen_commit", dm_context_pedersen_commit, 2);
+  rb_define_method(rb_cSecp256k1Context, "pedersen_blind_sum", dm_context_pedersen_blind_sum, 2);
+  rb_define_method(rb_cSecp256k1Context, "range_proof_sign", dm_context_range_proof_sign, 7);
+
+  //  Secp256k1Zkp::PublicKey
+  rb_cSecp256k1PublicKey = rb_define_class_under(rb_mSecp256k1, "PublicKey", rb_cObject);
+
+  rb_undef_alloc_func(rb_cSecp256k1PublicKey);
+  rb_define_alloc_func(rb_cSecp256k1PublicKey, dm_public_key_alloc);
+  rb_define_method(rb_cSecp256k1PublicKey, "initialize", dm_public_key_initialize, 1);
+  rb_define_method(rb_cSecp256k1PublicKey, "bytes", dm_public_key_bytes, 0);
+  rb_define_method(rb_cSecp256k1PublicKey, "tweak_add", dm_public_key_tweak_add, 1);
+  rb_define_method(rb_cSecp256k1PublicKey, "tweak_mul", dm_public_key_tweak_mul, 1);
+  rb_define_alias(rb_cSecp256k1PublicKey, "+", "tweak_add");
+  rb_define_alias(rb_cSecp256k1PublicKey, "*", "tweak_mul");
+
+  //  Secp256k1Zkp::PrivateKey
+  rb_cSecp256k1PrivateKey = rb_define_class_under(rb_mSecp256k1, "PrivateKey", rb_cObject);
+
+  rb_undef_alloc_func(rb_cSecp256k1PrivateKey);
+  rb_define_alloc_func(rb_cSecp256k1PrivateKey, dm_private_key_alloc);
+  rb_define_method(rb_cSecp256k1PrivateKey, "initialize", dm_private_key_initialize, 1);
+  rb_define_method(rb_cSecp256k1PrivateKey, "bytes", dm_private_key_bytes, 0);
+  rb_define_method(rb_cSecp256k1PrivateKey, "tweak_add", dm_private_key_tweak_add, 1);
+  rb_define_method(rb_cSecp256k1PrivateKey, "tweak_mul", dm_private_key_tweak_mul, 1);
+  rb_define_alias(rb_cSecp256k1PrivateKey, "+", "tweak_add");
+  rb_define_alias(rb_cSecp256k1PrivateKey, "*", "tweak_mul");
+  rb_define_method(rb_cSecp256k1PrivateKey, "to_public_key", dm_private_key_to_public_key, 0);
+}

data/lib/secp256k1zkp.rb

@@ -0,0 +1,11 @@
+#encoding:utf-8
+
+module Secp256k1Zkp
+end
+
+require 'secp256k1zkp/secp256k1zkp'
+require 'secp256k1zkp/version'
+require 'secp256k1zkp/utils'
+require 'secp256k1zkp/context'
+require 'secp256k1zkp/public_key'
+require 'secp256k1zkp/private_key'

data/lib/secp256k1zkp/context.rb

@@ -0,0 +1,15 @@
+#encoding:utf-8
+
+module Secp256k1Zkp
+
+  SECP256K1_CONTEXT_ALL = SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_COMMIT | SECP256K1_CONTEXT_RANGEPROOF
+
+  class Context
+
+    def self.default
+      return new(SECP256K1_CONTEXT_ALL)
+    end
+
+  end
+
+end

data/lib/secp256k1zkp/private_key.rb

@@ -0,0 +1,30 @@
+#encoding:utf-8
+
+require 'securerandom'
+
+module Secp256k1Zkp
+
+  class PrivateKey
+
+    def self.random
+      # # => REMARK：私钥有效范围。[1, secp256k1 curve order)。REMARK：大部分 lib 范围是 [1, secp256k1 curve order] 的闭区间，c库范围为开区间。
+      # sec = SecureRandom.random_number(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - 1) + 1
+      # new(hex_decode("%064x" % sec))
+      new(SecureRandom.random_bytes(32))
+    end
+
+    def shared_secret(public_key)
+      return public_key * self.bytes
+    end
+
+    def hex_encode(data)
+      return data.unpack("H*").first.downcase
+    end
+
+    def hex_decode(data)
+      return [data].pack("H*")
+    end
+
+  end
+
+end

data/lib/secp256k1zkp/public_key.rb

@@ -0,0 +1,13 @@
+#encoding:utf-8
+
+module Secp256k1Zkp
+
+  class PublicKey
+
+    def shared_secret(private_key)
+      return self * private_key.bytes
+    end
+
+  end
+
+end

data/lib/secp256k1zkp/utils.rb

@@ -0,0 +1,20 @@
+#encoding:utf-8
+
+require 'digest'
+
+module Secp256k1Zkp
+
+  module Utils
+  
+    module_function
+    
+    #------------------------------------------------------------------------
+    # ● 计算sha1
+    #------------------------------------------------------------------------
+    def sha1(str)
+      return Digest::SHA1.hexdigest(str)
+    end
+
+  end
+  
+end

data/lib/secp256k1zkp/version.rb

@@ -0,0 +1,7 @@
+#encoding:utf-8
+
+module Secp256k1Zkp
+
+  VERSION = '0.9.0'.freeze
+
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: secp256k1zkp
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- jokenshi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-06-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mini_portile2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: 
+email: developer@jokenshi.com
+executables: []
+extensions:
+- ext/secp256k1zkp/extconf.rb
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- ext/secp256k1zkp/extconf.rb
+- ext/secp256k1zkp/secp256k1zkp.c
+- lib/secp256k1zkp.rb
+- lib/secp256k1zkp/context.rb
+- lib/secp256k1zkp/private_key.rb
+- lib/secp256k1zkp/public_key.rb
+- lib/secp256k1zkp/utils.rb
+- lib/secp256k1zkp/version.rb
+homepage: https://github.com/jokenshi/ruby-secp256zkp.git
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- ext
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14.3
+signing_key: 
+specification_version: 4
+summary: native extension gem for secp256k1-zkp.
+test_files: []