> allOffsets,
+) {
+ final object = Address(
+ derivationIndex: reader.readLong(offsets[0]),
+ otherData: reader.readStringOrNull(offsets[1]),
+ publicKey: reader.readByteList(offsets[2]) ?? [],
+ subType: _AddresssubTypeValueEnumMap[reader.readByteOrNull(offsets[3])] ??
+ AddressSubType.receiving,
+ type: _AddresstypeValueEnumMap[reader.readByteOrNull(offsets[4])] ??
+ AddressType.p2pkh,
+ value: reader.readString(offsets[5]),
+ walletId: reader.readString(offsets[6]),
+ );
+ object.id = id;
+ return object;
+}
+
+P _addressDeserializeProp(
+ IsarReader reader,
+ int propertyId,
+ int offset,
+ Map> allOffsets,
+) {
+ switch (propertyId) {
+ case 0:
+ return (reader.readLong(offset)) as P;
+ case 1:
+ return (reader.readStringOrNull(offset)) as P;
+ case 2:
+ return (reader.readByteList(offset) ?? []) as P;
+ case 3:
+ return (_AddresssubTypeValueEnumMap[reader.readByteOrNull(offset)] ??
+ AddressSubType.receiving) as P;
+ case 4:
+ return (_AddresstypeValueEnumMap[reader.readByteOrNull(offset)] ??
+ AddressType.p2pkh) as P;
+ case 5:
+ return (reader.readString(offset)) as P;
+ case 6:
+ return (reader.readString(offset)) as P;
+ default:
+ throw IsarError('Unknown property with id $propertyId');
+ }
+}
+
+const _AddresssubTypeEnumValueMap = {
+ 'receiving': 0,
+ 'change': 1,
+ 'paynymNotification': 2,
+ 'paynymSend': 3,
+ 'paynymReceive': 4,
+ 'unknown': 5,
+ 'nonWallet': 6,
+};
+const _AddresssubTypeValueEnumMap = {
+ 0: AddressSubType.receiving,
+ 1: AddressSubType.change,
+ 2: AddressSubType.paynymNotification,
+ 3: AddressSubType.paynymSend,
+ 4: AddressSubType.paynymReceive,
+ 5: AddressSubType.unknown,
+ 6: AddressSubType.nonWallet,
+};
+const _AddresstypeEnumValueMap = {
+ 'p2pkh': 0,
+ 'p2sh': 1,
+ 'p2wpkh': 2,
+ 'cryptonote': 3,
+ 'mimbleWimble': 4,
+ 'unknown': 5,
+ 'nonWallet': 6,
+};
+const _AddresstypeValueEnumMap = {
+ 0: AddressType.p2pkh,
+ 1: AddressType.p2sh,
+ 2: AddressType.p2wpkh,
+ 3: AddressType.cryptonote,
+ 4: AddressType.mimbleWimble,
+ 5: AddressType.unknown,
+ 6: AddressType.nonWallet,
+};
+
+Id _addressGetId(Address object) {
+ return object.id;
+}
+
+List> _addressGetLinks(Address object) {
+ return [object.transactions];
+}
+
+void _addressAttach(IsarCollection col, Id id, Address object) {
+ object.id = id;
+ object.transactions
+ .attach(col, col.isar.collection(), r'transactions', id);
+}
+
+extension AddressByIndex on IsarCollection {
+ Future getByValueWalletId(String value, String walletId) {
+ return getByIndex(r'value_walletId', [value, walletId]);
+ }
+
+ Address? getByValueWalletIdSync(String value, String walletId) {
+ return getByIndexSync(r'value_walletId', [value, walletId]);
+ }
+
+ Future deleteByValueWalletId(String value, String walletId) {
+ return deleteByIndex(r'value_walletId', [value, walletId]);
+ }
+
+ bool deleteByValueWalletIdSync(String value, String walletId) {
+ return deleteByIndexSync(r'value_walletId', [value, walletId]);
+ }
+
+ Future> getAllByValueWalletId(
+ List valueValues, List walletIdValues) {
+ final len = valueValues.length;
+ assert(walletIdValues.length == len,
+ 'All index values must have the same length');
+ final values = >[];
+ for (var i = 0; i < len; i++) {
+ values.add([valueValues[i], walletIdValues[i]]);
+ }
+
+ return getAllByIndex(r'value_walletId', values);
+ }
+
+ List getAllByValueWalletIdSync(
+ List valueValues, List walletIdValues) {
+ final len = valueValues.length;
+ assert(walletIdValues.length == len,
+ 'All index values must have the same length');
+ final values = >[];
+ for (var i = 0; i < len; i++) {
+ values.add([valueValues[i], walletIdValues[i]]);
+ }
+
+ return getAllByIndexSync(r'value_walletId', values);
+ }
+
+ Future deleteAllByValueWalletId(
+ List valueValues, List walletIdValues) {
+ final len = valueValues.length;
+ assert(walletIdValues.length == len,
+ 'All index values must have the same length');
+ final values = >[];
+ for (var i = 0; i < len; i++) {
+ values.add([valueValues[i], walletIdValues[i]]);
+ }
+
+ return deleteAllByIndex(r'value_walletId', values);
+ }
+
+ int deleteAllByValueWalletIdSync(
+ List valueValues, List walletIdValues) {
+ final len = valueValues.length;
+ assert(walletIdValues.length == len,
+ 'All index values must have the same length');
+ final values = >[];
+ for (var i = 0; i < len; i++) {
+ values.add([valueValues[i], walletIdValues[i]]);
+ }
+
+ return deleteAllByIndexSync(r'value_walletId', values);
+ }
+
+ Future putByValueWalletId(Address object) {
+ return putByIndex(r'value_walletId', object);
+ }
+
+ Id putByValueWalletIdSync(Address object, {bool saveLinks = true}) {
+ return putByIndexSync(r'value_walletId', object, saveLinks: saveLinks);
+ }
+
+ Future> putAllByValueWalletId(List objects) {
+ return putAllByIndex(r'value_walletId', objects);
+ }
+
+ List putAllByValueWalletIdSync(List objects,
+ {bool saveLinks = true}) {
+ return putAllByIndexSync(r'value_walletId', objects, saveLinks: saveLinks);
+ }
+}
+
+extension AddressQueryWhereSort on QueryBuilder {
+ QueryBuilder anyId() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(const IdWhereClause.any());
+ });
+ }
+
+ QueryBuilder anyDerivationIndex() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(
+ const IndexWhereClause.any(indexName: r'derivationIndex'),
+ );
+ });
+ }
+}
+
+extension AddressQueryWhere on QueryBuilder {
+ QueryBuilder idEqualTo(Id id) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(IdWhereClause.between(
+ lower: id,
+ upper: id,
+ ));
+ });
+ }
+
+ QueryBuilder idNotEqualTo(Id id) {
+ return QueryBuilder.apply(this, (query) {
+ if (query.whereSort == Sort.asc) {
+ return query
+ .addWhereClause(
+ IdWhereClause.lessThan(upper: id, includeUpper: false),
+ )
+ .addWhereClause(
+ IdWhereClause.greaterThan(lower: id, includeLower: false),
+ );
+ } else {
+ return query
+ .addWhereClause(
+ IdWhereClause.greaterThan(lower: id, includeLower: false),
+ )
+ .addWhereClause(
+ IdWhereClause.lessThan(upper: id, includeUpper: false),
+ );
+ }
+ });
+ }
+
+ QueryBuilder idGreaterThan(Id id,
+ {bool include = false}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(
+ IdWhereClause.greaterThan(lower: id, includeLower: include),
+ );
+ });
+ }
+
+ QueryBuilder idLessThan(Id id,
+ {bool include = false}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(
+ IdWhereClause.lessThan(upper: id, includeUpper: include),
+ );
+ });
+ }
+
+ QueryBuilder idBetween(
+ Id lowerId,
+ Id upperId, {
+ bool includeLower = true,
+ bool includeUpper = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(IdWhereClause.between(
+ lower: lowerId,
+ includeLower: includeLower,
+ upper: upperId,
+ includeUpper: includeUpper,
+ ));
+ });
+ }
+
+ QueryBuilder walletIdEqualTo(
+ String walletId) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(IndexWhereClause.equalTo(
+ indexName: r'walletId',
+ value: [walletId],
+ ));
+ });
+ }
+
+ QueryBuilder walletIdNotEqualTo(
+ String walletId) {
+ return QueryBuilder.apply(this, (query) {
+ if (query.whereSort == Sort.asc) {
+ return query
+ .addWhereClause(IndexWhereClause.between(
+ indexName: r'walletId',
+ lower: [],
+ upper: [walletId],
+ includeUpper: false,
+ ))
+ .addWhereClause(IndexWhereClause.between(
+ indexName: r'walletId',
+ lower: [walletId],
+ includeLower: false,
+ upper: [],
+ ));
+ } else {
+ return query
+ .addWhereClause(IndexWhereClause.between(
+ indexName: r'walletId',
+ lower: [walletId],
+ includeLower: false,
+ upper: [],
+ ))
+ .addWhereClause(IndexWhereClause.between(
+ indexName: r'walletId',
+ lower: [],
+ upper: [walletId],
+ includeUpper: false,
+ ));
+ }
+ });
+ }
+
+ QueryBuilder valueEqualToAnyWalletId(
+ String value) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(IndexWhereClause.equalTo(
+ indexName: r'value_walletId',
+ value: [value],
+ ));
+ });
+ }
+
+ QueryBuilder valueNotEqualToAnyWalletId(
+ String value) {
+ return QueryBuilder.apply(this, (query) {
+ if (query.whereSort == Sort.asc) {
+ return query
+ .addWhereClause(IndexWhereClause.between(
+ indexName: r'value_walletId',
+ lower: [],
+ upper: [value],
+ includeUpper: false,
+ ))
+ .addWhereClause(IndexWhereClause.between(
+ indexName: r'value_walletId',
+ lower: [value],
+ includeLower: false,
+ upper: [],
+ ));
+ } else {
+ return query
+ .addWhereClause(IndexWhereClause.between(
+ indexName: r'value_walletId',
+ lower: [value],
+ includeLower: false,
+ upper: [],
+ ))
+ .addWhereClause(IndexWhereClause.between(
+ indexName: r'value_walletId',
+ lower: [],
+ upper: [value],
+ includeUpper: false,
+ ));
+ }
+ });
+ }
+
+ QueryBuilder valueWalletIdEqualTo(
+ String value, String walletId) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(IndexWhereClause.equalTo(
+ indexName: r'value_walletId',
+ value: [value, walletId],
+ ));
+ });
+ }
+
+ QueryBuilder
+ valueEqualToWalletIdNotEqualTo(String value, String walletId) {
+ return QueryBuilder.apply(this, (query) {
+ if (query.whereSort == Sort.asc) {
+ return query
+ .addWhereClause(IndexWhereClause.between(
+ indexName: r'value_walletId',
+ lower: [value],
+ upper: [value, walletId],
+ includeUpper: false,
+ ))
+ .addWhereClause(IndexWhereClause.between(
+ indexName: r'value_walletId',
+ lower: [value, walletId],
+ includeLower: false,
+ upper: [value],
+ ));
+ } else {
+ return query
+ .addWhereClause(IndexWhereClause.between(
+ indexName: r'value_walletId',
+ lower: [value, walletId],
+ includeLower: false,
+ upper: [value],
+ ))
+ .addWhereClause(IndexWhereClause.between(
+ indexName: r'value_walletId',
+ lower: [value],
+ upper: [value, walletId],
+ includeUpper: false,
+ ));
+ }
+ });
+ }
+
+ QueryBuilder derivationIndexEqualTo(
+ int derivationIndex) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(IndexWhereClause.equalTo(
+ indexName: r'derivationIndex',
+ value: [derivationIndex],
+ ));
+ });
+ }
+
+ QueryBuilder derivationIndexNotEqualTo(
+ int derivationIndex) {
+ return QueryBuilder.apply(this, (query) {
+ if (query.whereSort == Sort.asc) {
+ return query
+ .addWhereClause(IndexWhereClause.between(
+ indexName: r'derivationIndex',
+ lower: [],
+ upper: [derivationIndex],
+ includeUpper: false,
+ ))
+ .addWhereClause(IndexWhereClause.between(
+ indexName: r'derivationIndex',
+ lower: [derivationIndex],
+ includeLower: false,
+ upper: [],
+ ));
+ } else {
+ return query
+ .addWhereClause(IndexWhereClause.between(
+ indexName: r'derivationIndex',
+ lower: [derivationIndex],
+ includeLower: false,
+ upper: [],
+ ))
+ .addWhereClause(IndexWhereClause.between(
+ indexName: r'derivationIndex',
+ lower: [],
+ upper: [derivationIndex],
+ includeUpper: false,
+ ));
+ }
+ });
+ }
+
+ QueryBuilder derivationIndexGreaterThan(
+ int derivationIndex, {
+ bool include = false,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(IndexWhereClause.between(
+ indexName: r'derivationIndex',
+ lower: [derivationIndex],
+ includeLower: include,
+ upper: [],
+ ));
+ });
+ }
+
+ QueryBuilder derivationIndexLessThan(
+ int derivationIndex, {
+ bool include = false,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(IndexWhereClause.between(
+ indexName: r'derivationIndex',
+ lower: [],
+ upper: [derivationIndex],
+ includeUpper: include,
+ ));
+ });
+ }
+
+ QueryBuilder derivationIndexBetween(
+ int lowerDerivationIndex,
+ int upperDerivationIndex, {
+ bool includeLower = true,
+ bool includeUpper = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addWhereClause(IndexWhereClause.between(
+ indexName: r'derivationIndex',
+ lower: [lowerDerivationIndex],
+ includeLower: includeLower,
+ upper: [upperDerivationIndex],
+ includeUpper: includeUpper,
+ ));
+ });
+ }
+}
+
+extension AddressQueryFilter
+ on QueryBuilder {
+ QueryBuilder derivationIndexEqualTo(
+ int value) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.equalTo(
+ property: r'derivationIndex',
+ value: value,
+ ));
+ });
+ }
+
+ QueryBuilder
+ derivationIndexGreaterThan(
+ int value, {
+ bool include = false,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.greaterThan(
+ include: include,
+ property: r'derivationIndex',
+ value: value,
+ ));
+ });
+ }
+
+ QueryBuilder derivationIndexLessThan(
+ int value, {
+ bool include = false,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.lessThan(
+ include: include,
+ property: r'derivationIndex',
+ value: value,
+ ));
+ });
+ }
+
+ QueryBuilder derivationIndexBetween(
+ int lower,
+ int upper, {
+ bool includeLower = true,
+ bool includeUpper = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.between(
+ property: r'derivationIndex',
+ lower: lower,
+ includeLower: includeLower,
+ upper: upper,
+ includeUpper: includeUpper,
+ ));
+ });
+ }
+
+ QueryBuilder idEqualTo(Id value) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.equalTo(
+ property: r'id',
+ value: value,
+ ));
+ });
+ }
+
+ QueryBuilder idGreaterThan(
+ Id value, {
+ bool include = false,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.greaterThan(
+ include: include,
+ property: r'id',
+ value: value,
+ ));
+ });
+ }
+
+ QueryBuilder idLessThan(
+ Id value, {
+ bool include = false,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.lessThan(
+ include: include,
+ property: r'id',
+ value: value,
+ ));
+ });
+ }
+
+ QueryBuilder idBetween(
+ Id lower,
+ Id upper, {
+ bool includeLower = true,
+ bool includeUpper = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.between(
+ property: r'id',
+ lower: lower,
+ includeLower: includeLower,
+ upper: upper,
+ includeUpper: includeUpper,
+ ));
+ });
+ }
+
+ QueryBuilder otherDataIsNull() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(const FilterCondition.isNull(
+ property: r'otherData',
+ ));
+ });
+ }
+
+ QueryBuilder otherDataIsNotNull() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(const FilterCondition.isNotNull(
+ property: r'otherData',
+ ));
+ });
+ }
+
+ QueryBuilder otherDataEqualTo(
+ String? value, {
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.equalTo(
+ property: r'otherData',
+ value: value,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder otherDataGreaterThan(
+ String? value, {
+ bool include = false,
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.greaterThan(
+ include: include,
+ property: r'otherData',
+ value: value,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder otherDataLessThan(
+ String? value, {
+ bool include = false,
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.lessThan(
+ include: include,
+ property: r'otherData',
+ value: value,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder otherDataBetween(
+ String? lower,
+ String? upper, {
+ bool includeLower = true,
+ bool includeUpper = true,
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.between(
+ property: r'otherData',
+ lower: lower,
+ includeLower: includeLower,
+ upper: upper,
+ includeUpper: includeUpper,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder otherDataStartsWith(
+ String value, {
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.startsWith(
+ property: r'otherData',
+ value: value,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder otherDataEndsWith(
+ String value, {
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.endsWith(
+ property: r'otherData',
+ value: value,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder otherDataContains(
+ String value,
+ {bool caseSensitive = true}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.contains(
+ property: r'otherData',
+ value: value,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder otherDataMatches(
+ String pattern,
+ {bool caseSensitive = true}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.matches(
+ property: r'otherData',
+ wildcard: pattern,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder otherDataIsEmpty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.equalTo(
+ property: r'otherData',
+ value: '',
+ ));
+ });
+ }
+
+ QueryBuilder otherDataIsNotEmpty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.greaterThan(
+ property: r'otherData',
+ value: '',
+ ));
+ });
+ }
+
+ QueryBuilder publicKeyElementEqualTo(
+ int value) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.equalTo(
+ property: r'publicKey',
+ value: value,
+ ));
+ });
+ }
+
+ QueryBuilder
+ publicKeyElementGreaterThan(
+ int value, {
+ bool include = false,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.greaterThan(
+ include: include,
+ property: r'publicKey',
+ value: value,
+ ));
+ });
+ }
+
+ QueryBuilder
+ publicKeyElementLessThan(
+ int value, {
+ bool include = false,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.lessThan(
+ include: include,
+ property: r'publicKey',
+ value: value,
+ ));
+ });
+ }
+
+ QueryBuilder publicKeyElementBetween(
+ int lower,
+ int upper, {
+ bool includeLower = true,
+ bool includeUpper = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.between(
+ property: r'publicKey',
+ lower: lower,
+ includeLower: includeLower,
+ upper: upper,
+ includeUpper: includeUpper,
+ ));
+ });
+ }
+
+ QueryBuilder publicKeyLengthEqualTo(
+ int length) {
+ return QueryBuilder.apply(this, (query) {
+ return query.listLength(
+ r'publicKey',
+ length,
+ true,
+ length,
+ true,
+ );
+ });
+ }
+
+ QueryBuilder publicKeyIsEmpty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.listLength(
+ r'publicKey',
+ 0,
+ true,
+ 0,
+ true,
+ );
+ });
+ }
+
+ QueryBuilder publicKeyIsNotEmpty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.listLength(
+ r'publicKey',
+ 0,
+ false,
+ 999999,
+ true,
+ );
+ });
+ }
+
+ QueryBuilder publicKeyLengthLessThan(
+ int length, {
+ bool include = false,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.listLength(
+ r'publicKey',
+ 0,
+ true,
+ length,
+ include,
+ );
+ });
+ }
+
+ QueryBuilder
+ publicKeyLengthGreaterThan(
+ int length, {
+ bool include = false,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.listLength(
+ r'publicKey',
+ length,
+ include,
+ 999999,
+ true,
+ );
+ });
+ }
+
+ QueryBuilder publicKeyLengthBetween(
+ int lower,
+ int upper, {
+ bool includeLower = true,
+ bool includeUpper = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.listLength(
+ r'publicKey',
+ lower,
+ includeLower,
+ upper,
+ includeUpper,
+ );
+ });
+ }
+
+ QueryBuilder subTypeEqualTo(
+ AddressSubType value) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.equalTo(
+ property: r'subType',
+ value: value,
+ ));
+ });
+ }
+
+ QueryBuilder subTypeGreaterThan(
+ AddressSubType value, {
+ bool include = false,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.greaterThan(
+ include: include,
+ property: r'subType',
+ value: value,
+ ));
+ });
+ }
+
+ QueryBuilder subTypeLessThan(
+ AddressSubType value, {
+ bool include = false,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.lessThan(
+ include: include,
+ property: r'subType',
+ value: value,
+ ));
+ });
+ }
+
+ QueryBuilder subTypeBetween(
+ AddressSubType lower,
+ AddressSubType upper, {
+ bool includeLower = true,
+ bool includeUpper = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.between(
+ property: r'subType',
+ lower: lower,
+ includeLower: includeLower,
+ upper: upper,
+ includeUpper: includeUpper,
+ ));
+ });
+ }
+
+ QueryBuilder typeEqualTo(
+ AddressType value) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.equalTo(
+ property: r'type',
+ value: value,
+ ));
+ });
+ }
+
+ QueryBuilder typeGreaterThan(
+ AddressType value, {
+ bool include = false,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.greaterThan(
+ include: include,
+ property: r'type',
+ value: value,
+ ));
+ });
+ }
+
+ QueryBuilder typeLessThan(
+ AddressType value, {
+ bool include = false,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.lessThan(
+ include: include,
+ property: r'type',
+ value: value,
+ ));
+ });
+ }
+
+ QueryBuilder typeBetween(
+ AddressType lower,
+ AddressType upper, {
+ bool includeLower = true,
+ bool includeUpper = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.between(
+ property: r'type',
+ lower: lower,
+ includeLower: includeLower,
+ upper: upper,
+ includeUpper: includeUpper,
+ ));
+ });
+ }
+
+ QueryBuilder valueEqualTo(
+ String value, {
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.equalTo(
+ property: r'value',
+ value: value,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder valueGreaterThan(
+ String value, {
+ bool include = false,
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.greaterThan(
+ include: include,
+ property: r'value',
+ value: value,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder valueLessThan(
+ String value, {
+ bool include = false,
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.lessThan(
+ include: include,
+ property: r'value',
+ value: value,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder valueBetween(
+ String lower,
+ String upper, {
+ bool includeLower = true,
+ bool includeUpper = true,
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.between(
+ property: r'value',
+ lower: lower,
+ includeLower: includeLower,
+ upper: upper,
+ includeUpper: includeUpper,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder valueStartsWith(
+ String value, {
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.startsWith(
+ property: r'value',
+ value: value,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder valueEndsWith(
+ String value, {
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.endsWith(
+ property: r'value',
+ value: value,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder valueContains(
+ String value,
+ {bool caseSensitive = true}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.contains(
+ property: r'value',
+ value: value,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder valueMatches(
+ String pattern,
+ {bool caseSensitive = true}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.matches(
+ property: r'value',
+ wildcard: pattern,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder valueIsEmpty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.equalTo(
+ property: r'value',
+ value: '',
+ ));
+ });
+ }
+
+ QueryBuilder valueIsNotEmpty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.greaterThan(
+ property: r'value',
+ value: '',
+ ));
+ });
+ }
+
+ QueryBuilder walletIdEqualTo(
+ String value, {
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.equalTo(
+ property: r'walletId',
+ value: value,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder walletIdGreaterThan(
+ String value, {
+ bool include = false,
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.greaterThan(
+ include: include,
+ property: r'walletId',
+ value: value,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder walletIdLessThan(
+ String value, {
+ bool include = false,
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.lessThan(
+ include: include,
+ property: r'walletId',
+ value: value,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder walletIdBetween(
+ String lower,
+ String upper, {
+ bool includeLower = true,
+ bool includeUpper = true,
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.between(
+ property: r'walletId',
+ lower: lower,
+ includeLower: includeLower,
+ upper: upper,
+ includeUpper: includeUpper,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder walletIdStartsWith(
+ String value, {
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.startsWith(
+ property: r'walletId',
+ value: value,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder walletIdEndsWith(
+ String value, {
+ bool caseSensitive = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.endsWith(
+ property: r'walletId',
+ value: value,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder walletIdContains(
+ String value,
+ {bool caseSensitive = true}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.contains(
+ property: r'walletId',
+ value: value,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder walletIdMatches(
+ String pattern,
+ {bool caseSensitive = true}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.matches(
+ property: r'walletId',
+ wildcard: pattern,
+ caseSensitive: caseSensitive,
+ ));
+ });
+ }
+
+ QueryBuilder walletIdIsEmpty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.equalTo(
+ property: r'walletId',
+ value: '',
+ ));
+ });
+ }
+
+ QueryBuilder walletIdIsNotEmpty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addFilterCondition(FilterCondition.greaterThan(
+ property: r'walletId',
+ value: '',
+ ));
+ });
+ }
+}
+
+extension AddressQueryObject
+ on QueryBuilder {}
+
+extension AddressQueryLinks
+ on QueryBuilder {
+ QueryBuilder transactions(
+ FilterQuery q) {
+ return QueryBuilder.apply(this, (query) {
+ return query.link(q, r'transactions');
+ });
+ }
+
+ QueryBuilder
+ transactionsLengthEqualTo(int length) {
+ return QueryBuilder.apply(this, (query) {
+ return query.linkLength(r'transactions', length, true, length, true);
+ });
+ }
+
+ QueryBuilder transactionsIsEmpty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.linkLength(r'transactions', 0, true, 0, true);
+ });
+ }
+
+ QueryBuilder
+ transactionsIsNotEmpty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.linkLength(r'transactions', 0, false, 999999, true);
+ });
+ }
+
+ QueryBuilder
+ transactionsLengthLessThan(
+ int length, {
+ bool include = false,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.linkLength(r'transactions', 0, true, length, include);
+ });
+ }
+
+ QueryBuilder
+ transactionsLengthGreaterThan(
+ int length, {
+ bool include = false,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.linkLength(r'transactions', length, include, 999999, true);
+ });
+ }
+
+ QueryBuilder
+ transactionsLengthBetween(
+ int lower,
+ int upper, {
+ bool includeLower = true,
+ bool includeUpper = true,
+ }) {
+ return QueryBuilder.apply(this, (query) {
+ return query.linkLength(
+ r'transactions', lower, includeLower, upper, includeUpper);
+ });
+ }
+}
+
+extension AddressQuerySortBy on QueryBuilder {
+ QueryBuilder sortByDerivationIndex() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'derivationIndex', Sort.asc);
+ });
+ }
+
+ QueryBuilder sortByDerivationIndexDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'derivationIndex', Sort.desc);
+ });
+ }
+
+ QueryBuilder sortByOtherData() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'otherData', Sort.asc);
+ });
+ }
+
+ QueryBuilder sortByOtherDataDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'otherData', Sort.desc);
+ });
+ }
+
+ QueryBuilder sortBySubType() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'subType', Sort.asc);
+ });
+ }
+
+ QueryBuilder sortBySubTypeDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'subType', Sort.desc);
+ });
+ }
+
+ QueryBuilder sortByType() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'type', Sort.asc);
+ });
+ }
+
+ QueryBuilder sortByTypeDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'type', Sort.desc);
+ });
+ }
+
+ QueryBuilder sortByValue() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'value', Sort.asc);
+ });
+ }
+
+ QueryBuilder sortByValueDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'value', Sort.desc);
+ });
+ }
+
+ QueryBuilder sortByWalletId() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'walletId', Sort.asc);
+ });
+ }
+
+ QueryBuilder sortByWalletIdDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'walletId', Sort.desc);
+ });
+ }
+}
+
+extension AddressQuerySortThenBy
+ on QueryBuilder {
+ QueryBuilder thenByDerivationIndex() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'derivationIndex', Sort.asc);
+ });
+ }
+
+ QueryBuilder thenByDerivationIndexDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'derivationIndex', Sort.desc);
+ });
+ }
+
+ QueryBuilder thenById() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'id', Sort.asc);
+ });
+ }
+
+ QueryBuilder thenByIdDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'id', Sort.desc);
+ });
+ }
+
+ QueryBuilder thenByOtherData() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'otherData', Sort.asc);
+ });
+ }
+
+ QueryBuilder thenByOtherDataDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'otherData', Sort.desc);
+ });
+ }
+
+ QueryBuilder thenBySubType() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'subType', Sort.asc);
+ });
+ }
+
+ QueryBuilder thenBySubTypeDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'subType', Sort.desc);
+ });
+ }
+
+ QueryBuilder thenByType() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'type', Sort.asc);
+ });
+ }
+
+ QueryBuilder thenByTypeDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'type', Sort.desc);
+ });
+ }
+
+ QueryBuilder thenByValue() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'value', Sort.asc);
+ });
+ }
+
+ QueryBuilder thenByValueDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'value', Sort.desc);
+ });
+ }
+
+ QueryBuilder thenByWalletId() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'walletId', Sort.asc);
+ });
+ }
+
+ QueryBuilder thenByWalletIdDesc() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addSortBy(r'walletId', Sort.desc);
+ });
+ }
+}
+
+extension AddressQueryWhereDistinct
+ on QueryBuilder {
+ QueryBuilder distinctByDerivationIndex() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addDistinctBy(r'derivationIndex');
+ });
+ }
+
+ QueryBuilder distinctByOtherData(
+ {bool caseSensitive = true}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addDistinctBy(r'otherData', caseSensitive: caseSensitive);
+ });
+ }
+
+ QueryBuilder distinctByPublicKey() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addDistinctBy(r'publicKey');
+ });
+ }
+
+ QueryBuilder distinctBySubType() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addDistinctBy(r'subType');
+ });
+ }
+
+ QueryBuilder distinctByType() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addDistinctBy(r'type');
+ });
+ }
+
+ QueryBuilder distinctByValue(
+ {bool caseSensitive = true}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addDistinctBy(r'value', caseSensitive: caseSensitive);
+ });
+ }
+
+ QueryBuilder distinctByWalletId(
+ {bool caseSensitive = true}) {
+ return QueryBuilder.apply(this, (query) {
+ return query.addDistinctBy(r'walletId', caseSensitive: caseSensitive);
+ });
+ }
+}
+
+extension AddressQueryProperty
+ on QueryBuilder {
+ QueryBuilder idProperty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addPropertyName(r'id');
+ });
+ }
+
+ QueryBuilder derivationIndexProperty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addPropertyName(r'derivationIndex');
+ });
+ }
+
+ QueryBuilder otherDataProperty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addPropertyName(r'otherData');
+ });
+ }
+
+ QueryBuilder, QQueryOperations> publicKeyProperty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addPropertyName(r'publicKey');
+ });
+ }
+
+ QueryBuilder subTypeProperty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addPropertyName(r'subType');
+ });
+ }
+
+ QueryBuilder typeProperty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addPropertyName(r'type');
+ });
+ }
+
+ QueryBuilder valueProperty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addPropertyName(r'value');
+ });
+ }
+
+ QueryBuilder walletIdProperty() {
+ return QueryBuilder.apply(this, (query) {
+ return query.addPropertyName(r'walletId');
+ });
+ }
+}
diff --git a/lib/models/isar/models/address/crypto_currency_address.dart b/lib/models/isar/models/address/crypto_currency_address.dart
new file mode 100644
index 000000000..4c8670a30
--- /dev/null
+++ b/lib/models/isar/models/address/crypto_currency_address.dart
@@ -0,0 +1,3 @@
+abstract class CryptoCurrencyAddress {
+// future use?
+}
diff --git a/lib/models/isar/models/blockchain_data/input.dart b/lib/models/isar/models/blockchain_data/input.dart
new file mode 100644
index 000000000..58bbef889
--- /dev/null
+++ b/lib/models/isar/models/blockchain_data/input.dart
@@ -0,0 +1,46 @@
+import 'package:isar/isar.dart';
+import 'package:stackwallet/models/isar/models/blockchain_data/output.dart';
+import 'package:stackwallet/models/isar/models/blockchain_data/transaction.dart';
+
+part 'input.g.dart';
+
+@Collection()
+class Input {
+ Input({
+ required this.walletId,
+ required this.txid,
+ required this.vout,
+ required this.scriptSig,
+ required this.scriptSigAsm,
+ required this.isCoinbase,
+ required this.sequence,
+ required this.innerRedeemScriptAsm,
+ });
+
+ Id id = Isar.autoIncrement;
+
+ @Index()
+ late final String walletId;
+
+ late final String txid;
+
+ late final int vout;
+
+ late final String? scriptSig;
+
+ late final String? scriptSigAsm;
+
+ // TODO: find witness type // is it even used?
+ // late List? witness;
+
+ late final bool? isCoinbase;
+
+ late final int? sequence;
+
+ late final String? innerRedeemScriptAsm;
+
+ final prevOut = IsarLink