bool isNumber(const char *s) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
char * p = (char *)malloc(strlen(s) + 1);
strcpy(p, s);
p = trim(p);
if (strlen(p)==0) {
return false;
}
if (is_pure_num(p)) {
return true;
}
if (is_mark_num(p) && strlen(p+1) > 0) {
return true;
}
if (is_point(p)) {
return true;
}
if (is_ex(p)) {
return true;
}
return false;
}
operation::stack operation::to_pay_multisig_pattern(uint8_t signatures,
const std::vector<data_chunk>& points)
{
static constexpr size_t op_1 = static_cast<uint8_t>(opcode::op_1);
static constexpr size_t op_16 = static_cast<uint8_t>(opcode::op_16);
static constexpr size_t zero = op_1 - 1;
static constexpr size_t max = op_16 - zero;
const auto m = signatures;
const auto n = points.size();
if (m < 1 || m > n || n < 1 || n > max)
return operation::stack();
const auto op_m = static_cast<opcode>(m + zero);
const auto op_n = static_cast<opcode>(points.size() + zero);
operation::stack ops;
ops.push_back({ op_m, data_chunk() });
for (const auto point: points)
{
if (!is_point(point))
return operation::stack();
ops.push_back({ opcode::special, point });
}
ops.push_back({ op_n, data_chunk() });
ops.push_back({ opcode::checkmultisig, data_chunk() });
return ops;
}
bool operation::is_pay_public_key_pattern(const operation::stack& ops)
{
return ops.size() == 2
&& ops[0].code == opcode::special
&& is_point(ops[0].data)
&& ops[1].code == opcode::checksig;
}
bool operation::is_pay_multisig_pattern(const operation::stack& ops)
{
static constexpr size_t op_1 = static_cast<uint8_t>(opcode::op_1);
static constexpr size_t op_16 = static_cast<uint8_t>(opcode::op_16);
const auto op_count = ops.size();
if (op_count < 4 || ops[op_count - 1].code != opcode::checkmultisig)
return false;
const auto op_m = static_cast<uint8_t>(ops[0].code);
const auto op_n = static_cast<uint8_t>(ops[op_count - 2].code);
if (op_m < op_1 || op_m > op_n || op_n < op_1 || op_n > op_16)
return false;
const auto n = op_n - op_1;
const auto points = op_count - 3u;
if (n != points)
return false;
for (auto op = ops.begin() + 1; op != ops.end() - 2; ++op)
if (!is_point(op->data))
return false;
return true;
}
operation::stack operation::to_pay_public_key_pattern(data_slice point)
{
if (!is_point(point))
return operation::stack();
return operation::stack
{
operation{ opcode::special, to_chunk(point) },
operation{ opcode::checksig, data_chunk() }
};
}
bool is_ex(char *p) {
char * x = p;
while(*x != '\0' && *x != 'e') {
x++;
}
if (*x!='e') {
return false;
}
*x= '\0';
if (x==p)
return false;
bool ret = (is_pure_num(p) || (is_mark_num(p) && strlen(p+1)>0) || is_point(p)) && ((is_pure_num(x+1) && strlen(x+1)>0) || (is_mark_num(x+1) && strlen(x+2)>0));
*x= 'e';
return ret;
}
//======================================================================
bool sccan_point_pair_handler::
is_string_a_sccan_run_config(std::string line){
if(verbosity){
std::cout<<"sccan_point_pair_handler -> ";
std::cout<<"is_string_a_sccan_run_config() -> line: ";
std::cout<<line<<std::endl;
}
// use DEAs for the std::string control
// find
enum TokenT{
digit,
point,
underscore,
char_c,
char_f,
char_g,
char_s,
char_a,
char_n,
ERR
};
int GetState[][23] ={
//dig point under c f g s a n
{ 1, -1, -1, -1, -1, -1, -1, -1, -1 }, //0 d
{ 2, -1, -1, -1, -1, -1, -1, -1, -1 }, //1 d
{ 3, -1, -1, -1, -1, -1, -1, -1, -1 }, //2 d
{ 4, -1, -1, -1, -1, -1, -1, -1, -1 }, //3 d
{ 5, -1, -1, -1, -1, -1, -1, -1, -1 }, //4 d
{ 6, -1, -1, -1, -1, -1, -1, -1, -1 }, //5 d
{ 7, -1, -1, -1, -1, -1, -1, -1, -1 }, //6 d
{ 8, -1, -1, -1, -1, -1, -1, -1, -1 }, //7 d
{ -1, -1, 9, -1, -1, -1, -1, -1, -1 }, //8 _
{ 10, -1, -1, -1, -1, -1, -1, -1, -1 }, //9 d
{ 11, -1, -1, -1, -1, -1, -1, -1, -1 }, //10 d
{ 12, -1, -1, -1, -1, -1, -1, -1, -1 }, //11 d
{ 13, -1, -1, -1, -1, -1, -1, -1, -1 }, //12 d
{ -1, -1, 14, -1, -1, -1, -1, -1, -1 }, //13 _
{ -1, -1, -1, -1, -1, -1, 15, -1, -1 }, //14 s
{ -1, -1, -1, 16, -1, -1, -1, -1, -1 }, //15 c
{ -1, -1, -1, 17, -1, -1, -1, -1, -1 }, //16 c
{ -1, -1, -1, -1, -1, -1, -1, 18, -1 }, //17 a
{ -1, -1, -1, -1, -1, -1, -1, -1, 19 }, //18 n
{ -1, -1, 20, -1, -1, -1, -1, -1, -1 }, //19 _
{ 20, 21, -1, -1, -1, -1, -1, -1, -1 }, //20 d
{ -1, -1, -1, 22, -1, -1, -1, -1, -1 }, //21 .
{ -1, -1, -1, -1, 23, -1, -1, -1, -1 }, //22 c
{ -1, -1, -1, -1, -1, 24, -1, -1, -1 }, //23 f
//24 g
};
//for( int i=0; i<11;i++){std::cout<<"("<<i<<")"<<GetState[26][i]<<", ";}
//std::cout<<std::endl;
std::string ID;
std::string tilt_x;
std::string tilt_y;
std::string tilt_z;
std::string str_vec2D_x;
std::string str_vec2D_y;
int int_vec2D_count = 0;
int state = 0;
int char_number = 0;
//std::cout<<"str laenge: "<<line.size()<<std::endl;
while(state != -1 && char_number<line.size()){
TokenT token = ERR;
char s = line.at( char_number);
if(is_c(s)) token = char_c;
if(is_f(s)) token = char_f;
if(is_g(s)) token = char_g;
if(is_s(s)) token = char_s;
if(is_a(s)) token = char_a;
if(is_n(s)) token = char_n;
if(isdigit(s)) token = digit;
//std::cout<<char(s)<<"==digit"<<std::endl;}
if(is_point(s)) token = point;
if(is_underscore(s)) token = underscore;
//std::cout<<"check"<<char_number<<": ";
//std::cout<<char(s)<<" state: "<<state<<" token: "<<token<<std::endl;
state = (token == ERR) ? :GetState[state][token];
char_number ++;
}
if(state==24){return true;}else{return false;};
}
/**
Import an ECC key from a binary packet, using user supplied domain params rather than one of the NIST ones
@param in The packet to import
@param inlen The length of the packet
@param key [out] The destination of the import
@param dp pointer to user supplied params; must be the same as the params used when exporting
@return CRYPT_OK if successful, upon error all allocated memory will be freed
*/
int ecc_import_ex(const unsigned char *in, unsigned long inlen, ecc_key *key, const ltc_ecc_set_type *dp)
{
unsigned long key_size;
unsigned char flags[1];
int err;
LTC_ARGCHK(in != NULL);
LTC_ARGCHK(key != NULL);
LTC_ARGCHK(ltc_mp.name != NULL);
/* init key */
if (mp_init_multi(&key->pubkey.x, &key->pubkey.y, &key->pubkey.z, &key->k, NULL) != CRYPT_OK) {
return CRYPT_MEM;
}
/* find out what type of key it is */
if ((err = der_decode_sequence_multi(in, inlen,
LTC_ASN1_BIT_STRING, 1UL, &flags,
LTC_ASN1_EOL, 0UL, NULL)) != CRYPT_OK) {
goto done;
}
if (flags[0] == 1) {
/* private key */
key->type = PK_PRIVATE;
if ((err = der_decode_sequence_multi(in, inlen,
LTC_ASN1_BIT_STRING, 1UL, flags,
LTC_ASN1_SHORT_INTEGER, 1UL, &key_size,
LTC_ASN1_INTEGER, 1UL, key->pubkey.x,
LTC_ASN1_INTEGER, 1UL, key->pubkey.y,
LTC_ASN1_INTEGER, 1UL, key->k,
LTC_ASN1_EOL, 0UL, NULL)) != CRYPT_OK) {
goto done;
}
} else {
/* public key */
key->type = PK_PUBLIC;
if ((err = der_decode_sequence_multi(in, inlen,
LTC_ASN1_BIT_STRING, 1UL, flags,
LTC_ASN1_SHORT_INTEGER, 1UL, &key_size,
LTC_ASN1_INTEGER, 1UL, key->pubkey.x,
LTC_ASN1_INTEGER, 1UL, key->pubkey.y,
LTC_ASN1_EOL, 0UL, NULL)) != CRYPT_OK) {
goto done;
}
}
if (dp == NULL) {
/* find the idx */
for (key->idx = 0; ltc_ecc_sets[key->idx].size && (unsigned long)ltc_ecc_sets[key->idx].size != key_size; ++key->idx);
if (ltc_ecc_sets[key->idx].size == 0) {
err = CRYPT_INVALID_PACKET;
goto done;
}
key->dp = <c_ecc_sets[key->idx];
} else {
key->idx = -1;
key->dp = dp;
}
/* set z */
if ((err = mp_set(key->pubkey.z, 1)) != CRYPT_OK) { goto done; }
/* is it a point on the curve? */
if ((err = is_point(key)) != CRYPT_OK) {
goto done;
}
/* we're good */
return CRYPT_OK;
done:
mp_clear_multi(key->pubkey.x, key->pubkey.y, key->pubkey.z, key->k, NULL);
return err;
}
bool operation::is_sign_key_hash_pattern(const operation::stack& ops)
{
return ops.size() == 2 && is_push_only(ops) && is_point(ops.back().data);
}
