// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: params.proto

// This CPP symbol can be defined to use imports that match up to the framework
// imports needed when using CocoaPods.
#if !defined(GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS)
 #define GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS 0
#endif

#if GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS
 #import <Protobuf/GPBProtocolBuffers_RuntimeSupport.h>
#else
 #import "GPBProtocolBuffers_RuntimeSupport.h"
#endif

#import <stdatomic.h>

#import "Params.pbobjc.h"
// @@protoc_insertion_point(imports)

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
#pragma clang diagnostic ignored "-Wdirect-ivar-access"
#pragma clang diagnostic ignored "-Wdollar-in-identifier-extension"

#pragma mark - Objective C Class declarations
// Forward declarations of Objective C classes that we can use as
// static values in struct initializers.
// We don't use [Foo class] because it is not a static value.
GPBObjCClassDeclaration(AccountResponse);
GPBObjCClassDeclaration(ExternalAddressExtra);
GPBObjCClassDeclaration(ExternalAddressExtra_ExternalAddress);
GPBObjCClassDeclaration(GPBAny);
GPBObjCClassDeclaration(KeystoreCommonDeriveParam);
GPBObjCClassDeclaration(KeystoreCommonDeriveParam_Derivation);

#pragma mark - ParamsRoot

@implementation ParamsRoot

// No extensions in the file and none of the imports (direct or indirect)
// defined extensions, so no need to generate +extensionRegistry.

@end

#pragma mark - ParamsRoot_FileDescriptor

static GPBFileDescriptor *ParamsRoot_FileDescriptor(void) {
  // This is called by +initialize so there is no need to worry
  // about thread safety of the singleton.
  static GPBFileDescriptor *descriptor = NULL;
  if (!descriptor) {
    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
    descriptor = [[GPBFileDescriptor alloc] initWithPackage:@"api"
                                                     syntax:GPBFileSyntaxProto3];
  }
  return descriptor;
}

#pragma mark - Enum KeyType

GPBEnumDescriptor *KeyType_EnumDescriptor(void) {
  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  if (!descriptor) {
    static const char *valueNames =
        "Mnemonic\000PrivateKey\000";
    static const int32_t values[] = {
        KeyType_Mnemonic,
        KeyType_PrivateKey,
    };
    GPBEnumDescriptor *worker =
        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(KeyType)
                                       valueNames:valueNames
                                           values:values
                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
                                     enumVerifier:KeyType_IsValidValue];
    GPBEnumDescriptor *expected = nil;
    atomic_compare_exchange_strong(&descriptor, &expected, worker);
  }
  return descriptor;
}

BOOL KeyType_IsValidValue(int32_t value__) {
  switch (value__) {
    case KeyType_Mnemonic:
    case KeyType_PrivateKey:
      return YES;
    default:
      return NO;
  }
}

#pragma mark - HdStoreCreateParam

@implementation HdStoreCreateParam

@dynamic password;
@dynamic passwordHint;
@dynamic name;

typedef struct HdStoreCreateParam__storage_ {
  uint32_t _has_storage_[1];
  NSString *password;
  NSString *passwordHint;
  NSString *name;
} HdStoreCreateParam__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "password",
        .dataTypeSpecific.clazz = Nil,
        .number = HdStoreCreateParam_FieldNumber_Password,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(HdStoreCreateParam__storage_, password),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "passwordHint",
        .dataTypeSpecific.clazz = Nil,
        .number = HdStoreCreateParam_FieldNumber_PasswordHint,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(HdStoreCreateParam__storage_, passwordHint),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "name",
        .dataTypeSpecific.clazz = Nil,
        .number = HdStoreCreateParam_FieldNumber_Name,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(HdStoreCreateParam__storage_, name),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[HdStoreCreateParam class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(HdStoreCreateParam__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\002\014\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - WalletResult

@implementation WalletResult

@dynamic id_p;
@dynamic name;
@dynamic source;
@dynamic accountsArray, accountsArray_Count;
@dynamic createdAt;

typedef struct WalletResult__storage_ {
  uint32_t _has_storage_[1];
  NSString *id_p;
  NSString *name;
  NSString *source;
  NSMutableArray *accountsArray;
  int64_t createdAt;
} WalletResult__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = WalletResult_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(WalletResult__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "name",
        .dataTypeSpecific.clazz = Nil,
        .number = WalletResult_FieldNumber_Name,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(WalletResult__storage_, name),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "source",
        .dataTypeSpecific.clazz = Nil,
        .number = WalletResult_FieldNumber_Source,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(WalletResult__storage_, source),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "accountsArray",
        .dataTypeSpecific.clazz = GPBObjCClass(AccountResponse),
        .number = WalletResult_FieldNumber_AccountsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(WalletResult__storage_, accountsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
      {
        .name = "createdAt",
        .dataTypeSpecific.clazz = Nil,
        .number = WalletResult_FieldNumber_CreatedAt,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(WalletResult__storage_, createdAt),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeInt64,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[WalletResult class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(WalletResult__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\005\t\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - HdStoreImportParam

@implementation HdStoreImportParam

@dynamic mnemonic;
@dynamic password;
@dynamic source;
@dynamic name;
@dynamic passwordHint;
@dynamic overwrite;

typedef struct HdStoreImportParam__storage_ {
  uint32_t _has_storage_[1];
  NSString *mnemonic;
  NSString *password;
  NSString *source;
  NSString *name;
  NSString *passwordHint;
} HdStoreImportParam__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "mnemonic",
        .dataTypeSpecific.clazz = Nil,
        .number = HdStoreImportParam_FieldNumber_Mnemonic,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(HdStoreImportParam__storage_, mnemonic),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "password",
        .dataTypeSpecific.clazz = Nil,
        .number = HdStoreImportParam_FieldNumber_Password,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(HdStoreImportParam__storage_, password),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "source",
        .dataTypeSpecific.clazz = Nil,
        .number = HdStoreImportParam_FieldNumber_Source,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(HdStoreImportParam__storage_, source),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "name",
        .dataTypeSpecific.clazz = Nil,
        .number = HdStoreImportParam_FieldNumber_Name,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(HdStoreImportParam__storage_, name),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "passwordHint",
        .dataTypeSpecific.clazz = Nil,
        .number = HdStoreImportParam_FieldNumber_PasswordHint,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(HdStoreImportParam__storage_, passwordHint),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "overwrite",
        .dataTypeSpecific.clazz = Nil,
        .number = HdStoreImportParam_FieldNumber_Overwrite,
        .hasIndex = 5,
        .offset = 6,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[HdStoreImportParam class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(HdStoreImportParam__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\005\014\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KeystoreCommonDeriveParam

@implementation KeystoreCommonDeriveParam

@dynamic id_p;
@dynamic password;
@dynamic derivationsArray, derivationsArray_Count;

typedef struct KeystoreCommonDeriveParam__storage_ {
  uint32_t _has_storage_[1];
  NSString *id_p;
  NSString *password;
  NSMutableArray *derivationsArray;
} KeystoreCommonDeriveParam__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KeystoreCommonDeriveParam_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KeystoreCommonDeriveParam__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "password",
        .dataTypeSpecific.clazz = Nil,
        .number = KeystoreCommonDeriveParam_FieldNumber_Password,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KeystoreCommonDeriveParam__storage_, password),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "derivationsArray",
        .dataTypeSpecific.clazz = GPBObjCClass(KeystoreCommonDeriveParam_Derivation),
        .number = KeystoreCommonDeriveParam_FieldNumber_DerivationsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(KeystoreCommonDeriveParam__storage_, derivationsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[KeystoreCommonDeriveParam class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KeystoreCommonDeriveParam__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KeystoreCommonDeriveParam_Derivation

@implementation KeystoreCommonDeriveParam_Derivation

@dynamic chainType;
@dynamic path;
@dynamic network;
@dynamic segWit;
@dynamic chainId;

typedef struct KeystoreCommonDeriveParam_Derivation__storage_ {
  uint32_t _has_storage_[1];
  NSString *chainType;
  NSString *path;
  NSString *network;
  NSString *segWit;
  NSString *chainId;
} KeystoreCommonDeriveParam_Derivation__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "chainType",
        .dataTypeSpecific.clazz = Nil,
        .number = KeystoreCommonDeriveParam_Derivation_FieldNumber_ChainType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KeystoreCommonDeriveParam_Derivation__storage_, chainType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "path",
        .dataTypeSpecific.clazz = Nil,
        .number = KeystoreCommonDeriveParam_Derivation_FieldNumber_Path,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KeystoreCommonDeriveParam_Derivation__storage_, path),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "network",
        .dataTypeSpecific.clazz = Nil,
        .number = KeystoreCommonDeriveParam_Derivation_FieldNumber_Network,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KeystoreCommonDeriveParam_Derivation__storage_, network),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "segWit",
        .dataTypeSpecific.clazz = Nil,
        .number = KeystoreCommonDeriveParam_Derivation_FieldNumber_SegWit,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(KeystoreCommonDeriveParam_Derivation__storage_, segWit),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "chainId",
        .dataTypeSpecific.clazz = Nil,
        .number = KeystoreCommonDeriveParam_Derivation_FieldNumber_ChainId,
        .hasIndex = 4,
        .offset = (uint32_t)offsetof(KeystoreCommonDeriveParam_Derivation__storage_, chainId),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[KeystoreCommonDeriveParam_Derivation class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KeystoreCommonDeriveParam_Derivation__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\003\001\t\000\004\006\000\005\007\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    [localDescriptor setupContainingMessageClass:GPBObjCClass(KeystoreCommonDeriveParam)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - AccountResponse

@implementation AccountResponse

@dynamic chainType;
@dynamic address;
@dynamic path;
@dynamic extendedXpubKey;

typedef struct AccountResponse__storage_ {
  uint32_t _has_storage_[1];
  NSString *chainType;
  NSString *address;
  NSString *path;
  NSString *extendedXpubKey;
} AccountResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "chainType",
        .dataTypeSpecific.clazz = Nil,
        .number = AccountResponse_FieldNumber_ChainType,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(AccountResponse__storage_, chainType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "address",
        .dataTypeSpecific.clazz = Nil,
        .number = AccountResponse_FieldNumber_Address,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(AccountResponse__storage_, address),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "path",
        .dataTypeSpecific.clazz = Nil,
        .number = AccountResponse_FieldNumber_Path,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(AccountResponse__storage_, path),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "extendedXpubKey",
        .dataTypeSpecific.clazz = Nil,
        .number = AccountResponse_FieldNumber_ExtendedXpubKey,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(AccountResponse__storage_, extendedXpubKey),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[AccountResponse class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(AccountResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\002\001\t\000\004\017\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - AccountsResponse

@implementation AccountsResponse

@dynamic accountsArray, accountsArray_Count;

typedef struct AccountsResponse__storage_ {
  uint32_t _has_storage_[1];
  NSMutableArray *accountsArray;
} AccountsResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "accountsArray",
        .dataTypeSpecific.clazz = GPBObjCClass(AccountResponse),
        .number = AccountsResponse_FieldNumber_AccountsArray,
        .hasIndex = GPBNoHasBit,
        .offset = (uint32_t)offsetof(AccountsResponse__storage_, accountsArray),
        .flags = GPBFieldRepeated,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[AccountsResponse class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(AccountsResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KeystoreCommonExportResult

@implementation KeystoreCommonExportResult

@dynamic id_p;
@dynamic type;
@dynamic value;

typedef struct KeystoreCommonExportResult__storage_ {
  uint32_t _has_storage_[1];
  KeyType type;
  NSString *id_p;
  NSString *value;
} KeystoreCommonExportResult__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KeystoreCommonExportResult_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KeystoreCommonExportResult__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "type",
        .dataTypeSpecific.enumDescFunc = KeyType_EnumDescriptor,
        .number = KeystoreCommonExportResult_FieldNumber_Type,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KeystoreCommonExportResult__storage_, type),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "value",
        .dataTypeSpecific.clazz = Nil,
        .number = KeystoreCommonExportResult_FieldNumber_Value,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KeystoreCommonExportResult__storage_, value),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[KeystoreCommonExportResult class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KeystoreCommonExportResult__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KeystoreCommonExportResult_Type_RawValue(KeystoreCommonExportResult *message) {
  GPBDescriptor *descriptor = [KeystoreCommonExportResult descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KeystoreCommonExportResult_FieldNumber_Type];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKeystoreCommonExportResult_Type_RawValue(KeystoreCommonExportResult *message, int32_t value) {
  GPBDescriptor *descriptor = [KeystoreCommonExportResult descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KeystoreCommonExportResult_FieldNumber_Type];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - PrivateKeyStoreImportParam

@implementation PrivateKeyStoreImportParam

@dynamic privateKey;
@dynamic password;
@dynamic overwrite;

typedef struct PrivateKeyStoreImportParam__storage_ {
  uint32_t _has_storage_[1];
  NSString *privateKey;
  NSString *password;
} PrivateKeyStoreImportParam__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "privateKey",
        .dataTypeSpecific.clazz = Nil,
        .number = PrivateKeyStoreImportParam_FieldNumber_PrivateKey,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(PrivateKeyStoreImportParam__storage_, privateKey),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "password",
        .dataTypeSpecific.clazz = Nil,
        .number = PrivateKeyStoreImportParam_FieldNumber_Password,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(PrivateKeyStoreImportParam__storage_, password),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "overwrite",
        .dataTypeSpecific.clazz = Nil,
        .number = PrivateKeyStoreImportParam_FieldNumber_Overwrite,
        .hasIndex = 2,
        .offset = 3,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[PrivateKeyStoreImportParam class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(PrivateKeyStoreImportParam__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\001\n\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - PrivateKeyStoreExportParam

@implementation PrivateKeyStoreExportParam

@dynamic id_p;
@dynamic password;
@dynamic chainType;
@dynamic network;

typedef struct PrivateKeyStoreExportParam__storage_ {
  uint32_t _has_storage_[1];
  NSString *id_p;
  NSString *password;
  NSString *chainType;
  NSString *network;
} PrivateKeyStoreExportParam__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = PrivateKeyStoreExportParam_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(PrivateKeyStoreExportParam__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "password",
        .dataTypeSpecific.clazz = Nil,
        .number = PrivateKeyStoreExportParam_FieldNumber_Password,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(PrivateKeyStoreExportParam__storage_, password),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "chainType",
        .dataTypeSpecific.clazz = Nil,
        .number = PrivateKeyStoreExportParam_FieldNumber_ChainType,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(PrivateKeyStoreExportParam__storage_, chainType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "network",
        .dataTypeSpecific.clazz = Nil,
        .number = PrivateKeyStoreExportParam_FieldNumber_Network,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(PrivateKeyStoreExportParam__storage_, network),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[PrivateKeyStoreExportParam class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(PrivateKeyStoreExportParam__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\003\t\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KeystoreCommonExistsParam

@implementation KeystoreCommonExistsParam

@dynamic type;
@dynamic value;

typedef struct KeystoreCommonExistsParam__storage_ {
  uint32_t _has_storage_[1];
  KeyType type;
  NSString *value;
} KeystoreCommonExistsParam__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "type",
        .dataTypeSpecific.enumDescFunc = KeyType_EnumDescriptor,
        .number = KeystoreCommonExistsParam_FieldNumber_Type,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KeystoreCommonExistsParam__storage_, type),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeEnum,
      },
      {
        .name = "value",
        .dataTypeSpecific.clazz = Nil,
        .number = KeystoreCommonExistsParam_FieldNumber_Value,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(KeystoreCommonExistsParam__storage_, value),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[KeystoreCommonExistsParam class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KeystoreCommonExistsParam__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

int32_t KeystoreCommonExistsParam_Type_RawValue(KeystoreCommonExistsParam *message) {
  GPBDescriptor *descriptor = [KeystoreCommonExistsParam descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KeystoreCommonExistsParam_FieldNumber_Type];
  return GPBGetMessageRawEnumField(message, field);
}

void SetKeystoreCommonExistsParam_Type_RawValue(KeystoreCommonExistsParam *message, int32_t value) {
  GPBDescriptor *descriptor = [KeystoreCommonExistsParam descriptor];
  GPBFieldDescriptor *field = [descriptor fieldWithNumber:KeystoreCommonExistsParam_FieldNumber_Type];
  GPBSetMessageRawEnumField(message, field, value);
}

#pragma mark - KeystoreCommonExistsResult

@implementation KeystoreCommonExistsResult

@dynamic isExists;
@dynamic id_p;

typedef struct KeystoreCommonExistsResult__storage_ {
  uint32_t _has_storage_[1];
  NSString *id_p;
} KeystoreCommonExistsResult__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "isExists",
        .dataTypeSpecific.clazz = Nil,
        .number = KeystoreCommonExistsResult_FieldNumber_IsExists,
        .hasIndex = 0,
        .offset = 1,  // Stored in _has_storage_ to save space.
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeBool,
      },
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KeystoreCommonExistsResult_FieldNumber_Id_p,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(KeystoreCommonExistsResult__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[KeystoreCommonExistsResult class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KeystoreCommonExistsResult__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\001\010\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - KeystoreCommonAccountsParam

@implementation KeystoreCommonAccountsParam

@dynamic id_p;

typedef struct KeystoreCommonAccountsParam__storage_ {
  uint32_t _has_storage_[1];
  NSString *id_p;
} KeystoreCommonAccountsParam__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = KeystoreCommonAccountsParam_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(KeystoreCommonAccountsParam__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[KeystoreCommonAccountsParam class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(KeystoreCommonAccountsParam__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - SignParam

@implementation SignParam

@dynamic keyOneOfCase;
@dynamic id_p;
@dynamic password;
@dynamic derivedKey;
@dynamic chainType;
@dynamic address;
@dynamic hasInput, input;

typedef struct SignParam__storage_ {
  uint32_t _has_storage_[2];
  NSString *id_p;
  NSString *password;
  NSString *derivedKey;
  NSString *chainType;
  NSString *address;
  GPBAny *input;
} SignParam__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = SignParam_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(SignParam__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "password",
        .dataTypeSpecific.clazz = Nil,
        .number = SignParam_FieldNumber_Password,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(SignParam__storage_, password),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeString,
      },
      {
        .name = "derivedKey",
        .dataTypeSpecific.clazz = Nil,
        .number = SignParam_FieldNumber_DerivedKey,
        .hasIndex = -1,
        .offset = (uint32_t)offsetof(SignParam__storage_, derivedKey),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "chainType",
        .dataTypeSpecific.clazz = Nil,
        .number = SignParam_FieldNumber_ChainType,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(SignParam__storage_, chainType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "address",
        .dataTypeSpecific.clazz = Nil,
        .number = SignParam_FieldNumber_Address,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(SignParam__storage_, address),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "input",
        .dataTypeSpecific.clazz = GPBObjCClass(GPBAny),
        .number = SignParam_FieldNumber_Input,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(SignParam__storage_, input),
        .flags = GPBFieldOptional,
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[SignParam class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(SignParam__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
    static const char *oneofs[] = {
      "key",
    };
    [localDescriptor setupOneofs:oneofs
                           count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
                   firstHasIndex:-1];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\002\003\n\000\004\t\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

void SignParam_ClearKeyOneOfCase(SignParam *message) {
  GPBDescriptor *descriptor = [SignParam descriptor];
  GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
  GPBClearOneof(message, oneof);
}
#pragma mark - ExternalAddressParam

@implementation ExternalAddressParam

@dynamic id_p;
@dynamic chainType;
@dynamic externalIdx;

typedef struct ExternalAddressParam__storage_ {
  uint32_t _has_storage_[1];
  uint32_t externalIdx;
  NSString *id_p;
  NSString *chainType;
} ExternalAddressParam__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = ExternalAddressParam_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(ExternalAddressParam__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "chainType",
        .dataTypeSpecific.clazz = Nil,
        .number = ExternalAddressParam_FieldNumber_ChainType,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(ExternalAddressParam__storage_, chainType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "externalIdx",
        .dataTypeSpecific.clazz = Nil,
        .number = ExternalAddressParam_FieldNumber_ExternalIdx,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(ExternalAddressParam__storage_, externalIdx),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeUInt32,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[ExternalAddressParam class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(ExternalAddressParam__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\002\002\t\000\003\013\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - ExternalAddressResult

@implementation ExternalAddressResult

@dynamic address;
@dynamic derivedPath;
@dynamic type;

typedef struct ExternalAddressResult__storage_ {
  uint32_t _has_storage_[1];
  NSString *address;
  NSString *derivedPath;
  NSString *type;
} ExternalAddressResult__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "address",
        .dataTypeSpecific.clazz = Nil,
        .number = ExternalAddressResult_FieldNumber_Address,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(ExternalAddressResult__storage_, address),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "derivedPath",
        .dataTypeSpecific.clazz = Nil,
        .number = ExternalAddressResult_FieldNumber_DerivedPath,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(ExternalAddressResult__storage_, derivedPath),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "type",
        .dataTypeSpecific.clazz = Nil,
        .number = ExternalAddressResult_FieldNumber_Type,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(ExternalAddressResult__storage_, type),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[ExternalAddressResult class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(ExternalAddressResult__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\002\013\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - ExternalAddressExtra

@implementation ExternalAddressExtra

@dynamic encXpub;
@dynamic hasExternalAddress, externalAddress;

typedef struct ExternalAddressExtra__storage_ {
  uint32_t _has_storage_[1];
  NSString *encXpub;
  ExternalAddressExtra_ExternalAddress *externalAddress;
} ExternalAddressExtra__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "encXpub",
        .dataTypeSpecific.clazz = Nil,
        .number = ExternalAddressExtra_FieldNumber_EncXpub,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(ExternalAddressExtra__storage_, encXpub),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "externalAddress",
        .dataTypeSpecific.clazz = GPBObjCClass(ExternalAddressExtra_ExternalAddress),
        .number = ExternalAddressExtra_FieldNumber_ExternalAddress,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(ExternalAddressExtra__storage_, externalAddress),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom),
        .dataType = GPBDataTypeMessage,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[ExternalAddressExtra class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(ExternalAddressExtra__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\002\001\007\000\002\017\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - ExternalAddressExtra_ExternalAddress

@implementation ExternalAddressExtra_ExternalAddress

@dynamic address;
@dynamic derivedPath;
@dynamic type;

typedef struct ExternalAddressExtra_ExternalAddress__storage_ {
  uint32_t _has_storage_[1];
  NSString *address;
  NSString *derivedPath;
  NSString *type;
} ExternalAddressExtra_ExternalAddress__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "address",
        .dataTypeSpecific.clazz = Nil,
        .number = ExternalAddressExtra_ExternalAddress_FieldNumber_Address,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(ExternalAddressExtra_ExternalAddress__storage_, address),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "derivedPath",
        .dataTypeSpecific.clazz = Nil,
        .number = ExternalAddressExtra_ExternalAddress_FieldNumber_DerivedPath,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(ExternalAddressExtra_ExternalAddress__storage_, derivedPath),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "type",
        .dataTypeSpecific.clazz = Nil,
        .number = ExternalAddressExtra_ExternalAddress_FieldNumber_Type,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(ExternalAddressExtra_ExternalAddress__storage_, type),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[ExternalAddressExtra_ExternalAddress class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(ExternalAddressExtra_ExternalAddress__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\002\013\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    [localDescriptor setupContainingMessageClass:GPBObjCClass(ExternalAddressExtra)];
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - BtcForkDeriveExtraParam

@implementation BtcForkDeriveExtraParam

@dynamic network;
@dynamic segWit;

typedef struct BtcForkDeriveExtraParam__storage_ {
  uint32_t _has_storage_[1];
  NSString *network;
  NSString *segWit;
} BtcForkDeriveExtraParam__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "network",
        .dataTypeSpecific.clazz = Nil,
        .number = BtcForkDeriveExtraParam_FieldNumber_Network,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(BtcForkDeriveExtraParam__storage_, network),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "segWit",
        .dataTypeSpecific.clazz = Nil,
        .number = BtcForkDeriveExtraParam_FieldNumber_SegWit,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(BtcForkDeriveExtraParam__storage_, segWit),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[BtcForkDeriveExtraParam class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(BtcForkDeriveExtraParam__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\002\006\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - HdStoreExtendedPublicKeyParam

@implementation HdStoreExtendedPublicKeyParam

@dynamic id_p;
@dynamic password;
@dynamic chainType;
@dynamic address;

typedef struct HdStoreExtendedPublicKeyParam__storage_ {
  uint32_t _has_storage_[1];
  NSString *id_p;
  NSString *password;
  NSString *chainType;
  NSString *address;
} HdStoreExtendedPublicKeyParam__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "id_p",
        .dataTypeSpecific.clazz = Nil,
        .number = HdStoreExtendedPublicKeyParam_FieldNumber_Id_p,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(HdStoreExtendedPublicKeyParam__storage_, id_p),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "password",
        .dataTypeSpecific.clazz = Nil,
        .number = HdStoreExtendedPublicKeyParam_FieldNumber_Password,
        .hasIndex = 1,
        .offset = (uint32_t)offsetof(HdStoreExtendedPublicKeyParam__storage_, password),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "chainType",
        .dataTypeSpecific.clazz = Nil,
        .number = HdStoreExtendedPublicKeyParam_FieldNumber_ChainType,
        .hasIndex = 2,
        .offset = (uint32_t)offsetof(HdStoreExtendedPublicKeyParam__storage_, chainType),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
      {
        .name = "address",
        .dataTypeSpecific.clazz = Nil,
        .number = HdStoreExtendedPublicKeyParam_FieldNumber_Address,
        .hasIndex = 3,
        .offset = (uint32_t)offsetof(HdStoreExtendedPublicKeyParam__storage_, address),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[HdStoreExtendedPublicKeyParam class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(HdStoreExtendedPublicKeyParam__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\003\t\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end

#pragma mark - HdStoreExtendedPublicKeyResponse

@implementation HdStoreExtendedPublicKeyResponse

@dynamic extendedPublicKey;

typedef struct HdStoreExtendedPublicKeyResponse__storage_ {
  uint32_t _has_storage_[1];
  NSString *extendedPublicKey;
} HdStoreExtendedPublicKeyResponse__storage_;

// This method is threadsafe because it is initially called
// in +initialize for each subclass.
+ (GPBDescriptor *)descriptor {
  static GPBDescriptor *descriptor = nil;
  if (!descriptor) {
    static GPBMessageFieldDescription fields[] = {
      {
        .name = "extendedPublicKey",
        .dataTypeSpecific.clazz = Nil,
        .number = HdStoreExtendedPublicKeyResponse_FieldNumber_ExtendedPublicKey,
        .hasIndex = 0,
        .offset = (uint32_t)offsetof(HdStoreExtendedPublicKeyResponse__storage_, extendedPublicKey),
        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
        .dataType = GPBDataTypeString,
      },
    };
    GPBDescriptor *localDescriptor =
        [GPBDescriptor allocDescriptorForClass:[HdStoreExtendedPublicKeyResponse class]
                                     rootClass:[ParamsRoot class]
                                          file:ParamsRoot_FileDescriptor()
                                        fields:fields
                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
                                   storageSize:sizeof(HdStoreExtendedPublicKeyResponse__storage_)
                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
#if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    static const char *extraTextFormatInfo =
        "\001\001\021\000";
    [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
#endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
    #if defined(DEBUG) && DEBUG
      NSAssert(descriptor == nil, @"Startup recursed!");
    #endif  // DEBUG
    descriptor = localDescriptor;
  }
  return descriptor;
}

@end


#pragma clang diagnostic pop

// @@protoc_insertion_point(global_scope)
