refactor(spl) "spl"->"sol" where appropriate

diff --git a/lib/db/isar/main_db.dart b/lib/db/isar/main_db.dart
index a3a18a7..be46edf 100644
--- a/lib/db/isar/main_db.dart
+++ b/lib/db/isar/main_db.dart
@@ -59,7 +59,7 @@ class MainDB {
         AddressSchema,
         AddressLabelSchema,
         EthContractSchema,
-        SplTokenSchema,
+        SolContractSchema,
         TransactionBlockExplorerSchema,
         StackThemeSchema,
         ContactEntrySchema,
@@ -628,20 +628,21 @@ class MainDB {
 
   // Solana tokens.
 
-  QueryBuilder<SplToken, SplToken, QWhere> getSplTokens() =>
-      isar.splTokens.where();
+  QueryBuilder<SolContract, SolContract, QWhere> getSolContracts() =>
+      isar.solContracts.where();
 
-  Future<SplToken?> getSplToken(String tokenMint) =>
-      isar.splTokens.where().addressEqualTo(tokenMint).findFirst();
+  Future<SolContract?> getSolContract(String tokenMint) =>
+      isar.solContracts.where().addressEqualTo(tokenMint).findFirst();
 
-  SplToken? getSplTokenSync(String tokenMint) =>
-      isar.splTokens.where().addressEqualTo(tokenMint).findFirstSync();
+  SolContract? getSolContractSync(String tokenMint) =>
+      isar.solContracts.where().addressEqualTo(tokenMint).findFirstSync();
 
-  Future<int> putSplToken(SplToken token) => isar.writeTxn(() async {
-    return await isar.splTokens.put(token);
+  Future<int> putSolContract(SolContract token) => isar.writeTxn(() async {
+    return await isar.solContracts.put(token);
   });
 
-  Future<void> putSplTokens(List<SplToken> tokens) => isar.writeTxn(() async {
-    await isar.splTokens.putAll(tokens);
-  });
+  Future<void> putSolContracts(List<SolContract> tokens) =>
+      isar.writeTxn(() async {
+        await isar.solContracts.putAll(tokens);
+      });
 }
diff --git a/lib/models/add_wallet_list_entity/sub_classes/sol_token_entity.dart b/lib/models/add_wallet_list_entity/sub_classes/sol_token_entity.dart
index f7a35ca..1f4c01f 100644
--- a/lib/models/add_wallet_list_entity/sub_classes/sol_token_entity.dart
+++ b/lib/models/add_wallet_list_entity/sub_classes/sol_token_entity.dart
@@ -7,14 +7,14 @@
  *
  */
 
-import '../add_wallet_list_entity.dart';
-import '../../isar/models/solana/spl_token.dart';
 import '../../../wallets/crypto_currency/crypto_currency.dart';
+import '../../isar/models/solana/sol_contract.dart';
+import '../add_wallet_list_entity.dart';
 
 class SolTokenEntity extends AddWalletListEntity {
   SolTokenEntity(this.token);
 
-  final SplToken token;
+  final SolContract token;
 
   @override
   CryptoCurrency get cryptoCurrency => Solana(CryptoCurrencyNetwork.main);
diff --git a/lib/models/isar/models/isar_models.dart b/lib/models/isar/models/isar_models.dart
index eb61a82..cf27091 100644
--- a/lib/models/isar/models/isar_models.dart
+++ b/lib/models/isar/models/isar_models.dart
@@ -16,6 +16,6 @@ export 'blockchain_data/transaction.dart';
 export 'blockchain_data/utxo.dart';
 export 'ethereum/eth_contract.dart';
 export 'log.dart';
-export 'solana/spl_token.dart';
+export 'solana/sol_contract.dart';
 export 'transaction_note.dart';
 export '../../../wallets/isar/models/wallet_solana_token_info.dart';
diff --git a/lib/models/isar/models/solana/sol_contract.dart b/lib/models/isar/models/solana/sol_contract.dart
new file mode 100644
index 0000000..ba2493e
--- /dev/null
+++ b/lib/models/isar/models/solana/sol_contract.dart
@@ -0,0 +1,62 @@
+/*
+ * This file is part of Stack Wallet.
+ *
+ * Copyright (c) 2025 Cypher Stack
+ * All Rights Reserved.
+ * The code is distributed under GPLv3 license, see LICENSE file for details.
+ *
+ */
+
+import 'package:isar_community/isar.dart';
+
+import '../contract.dart';
+
+part 'sol_contract.g.dart';
+
+@collection
+class SolContract extends Contract {
+  SolContract({
+    required this.address,
+    required this.name,
+    required this.symbol,
+    required this.decimals,
+    this.logoUri,
+    this.metadataAddress,
+  });
+
+  Id id = Isar.autoIncrement;
+
+  @override
+  @Index(unique: true, replace: true)
+  late final String address; // Mint address.
+
+  @override
+  late final String name;
+
+  @override
+  late final String symbol;
+
+  @override
+  late final int decimals;
+
+  late final String? logoUri;
+
+  late final String? metadataAddress;
+
+  SolContract copyWith({
+    Id? id,
+    String? address,
+    String? name,
+    String? symbol,
+    int? decimals,
+    String? logoUri,
+    String? metadataAddress,
+  }) => SolContract(
+    address: address ?? this.address,
+    name: name ?? this.name,
+    symbol: symbol ?? this.symbol,
+    decimals: decimals ?? this.decimals,
+    logoUri: logoUri ?? this.logoUri,
+    metadataAddress: metadataAddress ?? this.metadataAddress,
+  )..id = id ?? this.id;
+}
diff --git a/lib/models/isar/models/solana/sol_contract.g.dart b/lib/models/isar/models/solana/sol_contract.g.dart
new file mode 100644
index 0000000..b75906e
--- /dev/null
+++ b/lib/models/isar/models/solana/sol_contract.g.dart
@@ -0,0 +1,1498 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'sol_contract.dart';
+
+// **************************************************************************
+// IsarCollectionGenerator
+// **************************************************************************
+
+// coverage:ignore-file
+// ignore_for_file: duplicate_ignore, non_constant_identifier_names, constant_identifier_names, invalid_use_of_protected_member, unnecessary_cast, prefer_const_constructors, lines_longer_than_80_chars, require_trailing_commas, inference_failure_on_function_invocation, unnecessary_parenthesis, unnecessary_raw_strings, unnecessary_null_checks, join_return_with_assignment, prefer_final_locals, avoid_js_rounded_ints, avoid_positional_boolean_parameters, always_specify_types
+
+extension GetSolContractCollection on Isar {
+  IsarCollection<SolContract> get solContracts => this.collection();
+}
+
+const SolContractSchema = CollectionSchema(
+  name: r'SolContract',
+  id: 1474803837279318906,
+  properties: {
+    r'address': PropertySchema(id: 0, name: r'address', type: IsarType.string),
+    r'decimals': PropertySchema(id: 1, name: r'decimals', type: IsarType.long),
+    r'logoUri': PropertySchema(id: 2, name: r'logoUri', type: IsarType.string),
+    r'metadataAddress': PropertySchema(
+      id: 3,
+      name: r'metadataAddress',
+      type: IsarType.string,
+    ),
+    r'name': PropertySchema(id: 4, name: r'name', type: IsarType.string),
+    r'symbol': PropertySchema(id: 5, name: r'symbol', type: IsarType.string),
+  },
+
+  estimateSize: _solContractEstimateSize,
+  serialize: _solContractSerialize,
+  deserialize: _solContractDeserialize,
+  deserializeProp: _solContractDeserializeProp,
+  idName: r'id',
+  indexes: {
+    r'address': IndexSchema(
+      id: -259407546592846288,
+      name: r'address',
+      unique: true,
+      replace: true,
+      properties: [
+        IndexPropertySchema(
+          name: r'address',
+          type: IndexType.hash,
+          caseSensitive: true,
+        ),
+      ],
+    ),
+  },
+  links: {},
+  embeddedSchemas: {},
+
+  getId: _solContractGetId,
+  getLinks: _solContractGetLinks,
+  attach: _solContractAttach,
+  version: '3.3.0-dev.2',
+);
+
+int _solContractEstimateSize(
+  SolContract object,
+  List<int> offsets,
+  Map<Type, List<int>> allOffsets,
+) {
+  var bytesCount = offsets.last;
+  bytesCount += 3 + object.address.length * 3;
+  {
+    final value = object.logoUri;
+    if (value != null) {
+      bytesCount += 3 + value.length * 3;
+    }
+  }
+  {
+    final value = object.metadataAddress;
+    if (value != null) {
+      bytesCount += 3 + value.length * 3;
+    }
+  }
+  bytesCount += 3 + object.name.length * 3;
+  bytesCount += 3 + object.symbol.length * 3;
+  return bytesCount;
+}
+
+void _solContractSerialize(
+  SolContract object,
+  IsarWriter writer,
+  List<int> offsets,
+  Map<Type, List<int>> allOffsets,
+) {
+  writer.writeString(offsets[0], object.address);
+  writer.writeLong(offsets[1], object.decimals);
+  writer.writeString(offsets[2], object.logoUri);
+  writer.writeString(offsets[3], object.metadataAddress);
+  writer.writeString(offsets[4], object.name);
+  writer.writeString(offsets[5], object.symbol);
+}
+
+SolContract _solContractDeserialize(
+  Id id,
+  IsarReader reader,
+  List<int> offsets,
+  Map<Type, List<int>> allOffsets,
+) {
+  final object = SolContract(
+    address: reader.readString(offsets[0]),
+    decimals: reader.readLong(offsets[1]),
+    logoUri: reader.readStringOrNull(offsets[2]),
+    metadataAddress: reader.readStringOrNull(offsets[3]),
+    name: reader.readString(offsets[4]),
+    symbol: reader.readString(offsets[5]),
+  );
+  object.id = id;
+  return object;
+}
+
+P _solContractDeserializeProp<P>(
+  IsarReader reader,
+  int propertyId,
+  int offset,
+  Map<Type, List<int>> allOffsets,
+) {
+  switch (propertyId) {
+    case 0:
+      return (reader.readString(offset)) as P;
+    case 1:
+      return (reader.readLong(offset)) as P;
+    case 2:
+      return (reader.readStringOrNull(offset)) as P;
+    case 3:
+      return (reader.readStringOrNull(offset)) as P;
+    case 4:
+      return (reader.readString(offset)) as P;
+    case 5:
+      return (reader.readString(offset)) as P;
+    default:
+      throw IsarError('Unknown property with id $propertyId');
+  }
+}
+
+Id _solContractGetId(SolContract object) {
+  return object.id;
+}
+
+List<IsarLinkBase<dynamic>> _solContractGetLinks(SolContract object) {
+  return [];
+}
+
+void _solContractAttach(
+  IsarCollection<dynamic> col,
+  Id id,
+  SolContract object,
+) {
+  object.id = id;
+}
+
+extension SolContractByIndex on IsarCollection<SolContract> {
+  Future<SolContract?> getByAddress(String address) {
+    return getByIndex(r'address', [address]);
+  }
+
+  SolContract? getByAddressSync(String address) {
+    return getByIndexSync(r'address', [address]);
+  }
+
+  Future<bool> deleteByAddress(String address) {
+    return deleteByIndex(r'address', [address]);
+  }
+
+  bool deleteByAddressSync(String address) {
+    return deleteByIndexSync(r'address', [address]);
+  }
+
+  Future<List<SolContract?>> getAllByAddress(List<String> addressValues) {
+    final values = addressValues.map((e) => [e]).toList();
+    return getAllByIndex(r'address', values);
+  }
+
+  List<SolContract?> getAllByAddressSync(List<String> addressValues) {
+    final values = addressValues.map((e) => [e]).toList();
+    return getAllByIndexSync(r'address', values);
+  }
+
+  Future<int> deleteAllByAddress(List<String> addressValues) {
+    final values = addressValues.map((e) => [e]).toList();
+    return deleteAllByIndex(r'address', values);
+  }
+
+  int deleteAllByAddressSync(List<String> addressValues) {
+    final values = addressValues.map((e) => [e]).toList();
+    return deleteAllByIndexSync(r'address', values);
+  }
+
+  Future<Id> putByAddress(SolContract object) {
+    return putByIndex(r'address', object);
+  }
+
+  Id putByAddressSync(SolContract object, {bool saveLinks = true}) {
+    return putByIndexSync(r'address', object, saveLinks: saveLinks);
+  }
+
+  Future<List<Id>> putAllByAddress(List<SolContract> objects) {
+    return putAllByIndex(r'address', objects);
+  }
+
+  List<Id> putAllByAddressSync(
+    List<SolContract> objects, {
+    bool saveLinks = true,
+  }) {
+    return putAllByIndexSync(r'address', objects, saveLinks: saveLinks);
+  }
+}
+
+extension SolContractQueryWhereSort
+    on QueryBuilder<SolContract, SolContract, QWhere> {
+  QueryBuilder<SolContract, SolContract, QAfterWhere> anyId() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addWhereClause(const IdWhereClause.any());
+    });
+  }
+}
+
+extension SolContractQueryWhere
+    on QueryBuilder<SolContract, SolContract, QWhereClause> {
+  QueryBuilder<SolContract, SolContract, QAfterWhereClause> idEqualTo(Id id) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addWhereClause(IdWhereClause.between(lower: id, upper: id));
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterWhereClause> 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<SolContract, SolContract, QAfterWhereClause> idGreaterThan(
+    Id id, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addWhereClause(
+        IdWhereClause.greaterThan(lower: id, includeLower: include),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterWhereClause> idLessThan(
+    Id id, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addWhereClause(
+        IdWhereClause.lessThan(upper: id, includeUpper: include),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterWhereClause> 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<SolContract, SolContract, QAfterWhereClause> addressEqualTo(
+    String address,
+  ) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addWhereClause(
+        IndexWhereClause.equalTo(indexName: r'address', value: [address]),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterWhereClause> addressNotEqualTo(
+    String address,
+  ) {
+    return QueryBuilder.apply(this, (query) {
+      if (query.whereSort == Sort.asc) {
+        return query
+            .addWhereClause(
+              IndexWhereClause.between(
+                indexName: r'address',
+                lower: [],
+                upper: [address],
+                includeUpper: false,
+              ),
+            )
+            .addWhereClause(
+              IndexWhereClause.between(
+                indexName: r'address',
+                lower: [address],
+                includeLower: false,
+                upper: [],
+              ),
+            );
+      } else {
+        return query
+            .addWhereClause(
+              IndexWhereClause.between(
+                indexName: r'address',
+                lower: [address],
+                includeLower: false,
+                upper: [],
+              ),
+            )
+            .addWhereClause(
+              IndexWhereClause.between(
+                indexName: r'address',
+                lower: [],
+                upper: [address],
+                includeUpper: false,
+              ),
+            );
+      }
+    });
+  }
+}
+
+extension SolContractQueryFilter
+    on QueryBuilder<SolContract, SolContract, QFilterCondition> {
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> addressEqualTo(
+    String value, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.equalTo(
+          property: r'address',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  addressGreaterThan(
+    String value, {
+    bool include = false,
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.greaterThan(
+          include: include,
+          property: r'address',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> addressLessThan(
+    String value, {
+    bool include = false,
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.lessThan(
+          include: include,
+          property: r'address',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> addressBetween(
+    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'address',
+          lower: lower,
+          includeLower: includeLower,
+          upper: upper,
+          includeUpper: includeUpper,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  addressStartsWith(String value, {bool caseSensitive = true}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.startsWith(
+          property: r'address',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> addressEndsWith(
+    String value, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.endsWith(
+          property: r'address',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> addressContains(
+    String value, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.contains(
+          property: r'address',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> addressMatches(
+    String pattern, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.matches(
+          property: r'address',
+          wildcard: pattern,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  addressIsEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.equalTo(property: r'address', value: ''),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  addressIsNotEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.greaterThan(property: r'address', value: ''),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> decimalsEqualTo(
+    int value,
+  ) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.equalTo(property: r'decimals', value: value),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  decimalsGreaterThan(int value, {bool include = false}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.greaterThan(
+          include: include,
+          property: r'decimals',
+          value: value,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  decimalsLessThan(int value, {bool include = false}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.lessThan(
+          include: include,
+          property: r'decimals',
+          value: value,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> decimalsBetween(
+    int lower,
+    int upper, {
+    bool includeLower = true,
+    bool includeUpper = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.between(
+          property: r'decimals',
+          lower: lower,
+          includeLower: includeLower,
+          upper: upper,
+          includeUpper: includeUpper,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> idEqualTo(
+    Id value,
+  ) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.equalTo(property: r'id', value: value),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> idGreaterThan(
+    Id value, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.greaterThan(
+          include: include,
+          property: r'id',
+          value: value,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> idLessThan(
+    Id value, {
+    bool include = false,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.lessThan(
+          include: include,
+          property: r'id',
+          value: value,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> 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<SolContract, SolContract, QAfterFilterCondition>
+  logoUriIsNull() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        const FilterCondition.isNull(property: r'logoUri'),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  logoUriIsNotNull() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        const FilterCondition.isNotNull(property: r'logoUri'),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> logoUriEqualTo(
+    String? value, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.equalTo(
+          property: r'logoUri',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  logoUriGreaterThan(
+    String? value, {
+    bool include = false,
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.greaterThan(
+          include: include,
+          property: r'logoUri',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> logoUriLessThan(
+    String? value, {
+    bool include = false,
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.lessThan(
+          include: include,
+          property: r'logoUri',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> logoUriBetween(
+    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'logoUri',
+          lower: lower,
+          includeLower: includeLower,
+          upper: upper,
+          includeUpper: includeUpper,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  logoUriStartsWith(String value, {bool caseSensitive = true}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.startsWith(
+          property: r'logoUri',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> logoUriEndsWith(
+    String value, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.endsWith(
+          property: r'logoUri',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> logoUriContains(
+    String value, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.contains(
+          property: r'logoUri',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> logoUriMatches(
+    String pattern, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.matches(
+          property: r'logoUri',
+          wildcard: pattern,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  logoUriIsEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.equalTo(property: r'logoUri', value: ''),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  logoUriIsNotEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.greaterThan(property: r'logoUri', value: ''),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  metadataAddressIsNull() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        const FilterCondition.isNull(property: r'metadataAddress'),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  metadataAddressIsNotNull() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        const FilterCondition.isNotNull(property: r'metadataAddress'),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  metadataAddressEqualTo(String? value, {bool caseSensitive = true}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.equalTo(
+          property: r'metadataAddress',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  metadataAddressGreaterThan(
+    String? value, {
+    bool include = false,
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.greaterThan(
+          include: include,
+          property: r'metadataAddress',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  metadataAddressLessThan(
+    String? value, {
+    bool include = false,
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.lessThan(
+          include: include,
+          property: r'metadataAddress',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  metadataAddressBetween(
+    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'metadataAddress',
+          lower: lower,
+          includeLower: includeLower,
+          upper: upper,
+          includeUpper: includeUpper,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  metadataAddressStartsWith(String value, {bool caseSensitive = true}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.startsWith(
+          property: r'metadataAddress',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  metadataAddressEndsWith(String value, {bool caseSensitive = true}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.endsWith(
+          property: r'metadataAddress',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  metadataAddressContains(String value, {bool caseSensitive = true}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.contains(
+          property: r'metadataAddress',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  metadataAddressMatches(String pattern, {bool caseSensitive = true}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.matches(
+          property: r'metadataAddress',
+          wildcard: pattern,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  metadataAddressIsEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.equalTo(property: r'metadataAddress', value: ''),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  metadataAddressIsNotEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.greaterThan(property: r'metadataAddress', value: ''),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> nameEqualTo(
+    String value, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.equalTo(
+          property: r'name',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> nameGreaterThan(
+    String value, {
+    bool include = false,
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.greaterThan(
+          include: include,
+          property: r'name',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> nameLessThan(
+    String value, {
+    bool include = false,
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.lessThan(
+          include: include,
+          property: r'name',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> nameBetween(
+    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'name',
+          lower: lower,
+          includeLower: includeLower,
+          upper: upper,
+          includeUpper: includeUpper,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> nameStartsWith(
+    String value, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.startsWith(
+          property: r'name',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> nameEndsWith(
+    String value, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.endsWith(
+          property: r'name',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> nameContains(
+    String value, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.contains(
+          property: r'name',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> nameMatches(
+    String pattern, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.matches(
+          property: r'name',
+          wildcard: pattern,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> nameIsEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.equalTo(property: r'name', value: ''),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  nameIsNotEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.greaterThan(property: r'name', value: ''),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> symbolEqualTo(
+    String value, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.equalTo(
+          property: r'symbol',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  symbolGreaterThan(
+    String value, {
+    bool include = false,
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.greaterThan(
+          include: include,
+          property: r'symbol',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> symbolLessThan(
+    String value, {
+    bool include = false,
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.lessThan(
+          include: include,
+          property: r'symbol',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> symbolBetween(
+    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'symbol',
+          lower: lower,
+          includeLower: includeLower,
+          upper: upper,
+          includeUpper: includeUpper,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  symbolStartsWith(String value, {bool caseSensitive = true}) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.startsWith(
+          property: r'symbol',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> symbolEndsWith(
+    String value, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.endsWith(
+          property: r'symbol',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> symbolContains(
+    String value, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.contains(
+          property: r'symbol',
+          value: value,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition> symbolMatches(
+    String pattern, {
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.matches(
+          property: r'symbol',
+          wildcard: pattern,
+          caseSensitive: caseSensitive,
+        ),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  symbolIsEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.equalTo(property: r'symbol', value: ''),
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterFilterCondition>
+  symbolIsNotEmpty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addFilterCondition(
+        FilterCondition.greaterThan(property: r'symbol', value: ''),
+      );
+    });
+  }
+}
+
+extension SolContractQueryObject
+    on QueryBuilder<SolContract, SolContract, QFilterCondition> {}
+
+extension SolContractQueryLinks
+    on QueryBuilder<SolContract, SolContract, QFilterCondition> {}
+
+extension SolContractQuerySortBy
+    on QueryBuilder<SolContract, SolContract, QSortBy> {
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> sortByAddress() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'address', Sort.asc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> sortByAddressDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'address', Sort.desc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> sortByDecimals() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'decimals', Sort.asc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> sortByDecimalsDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'decimals', Sort.desc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> sortByLogoUri() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'logoUri', Sort.asc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> sortByLogoUriDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'logoUri', Sort.desc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> sortByMetadataAddress() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'metadataAddress', Sort.asc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy>
+  sortByMetadataAddressDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'metadataAddress', Sort.desc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> sortByName() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'name', Sort.asc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> sortByNameDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'name', Sort.desc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> sortBySymbol() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'symbol', Sort.asc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> sortBySymbolDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'symbol', Sort.desc);
+    });
+  }
+}
+
+extension SolContractQuerySortThenBy
+    on QueryBuilder<SolContract, SolContract, QSortThenBy> {
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> thenByAddress() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'address', Sort.asc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> thenByAddressDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'address', Sort.desc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> thenByDecimals() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'decimals', Sort.asc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> thenByDecimalsDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'decimals', Sort.desc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> thenById() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'id', Sort.asc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> thenByIdDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'id', Sort.desc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> thenByLogoUri() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'logoUri', Sort.asc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> thenByLogoUriDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'logoUri', Sort.desc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> thenByMetadataAddress() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'metadataAddress', Sort.asc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy>
+  thenByMetadataAddressDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'metadataAddress', Sort.desc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> thenByName() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'name', Sort.asc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> thenByNameDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'name', Sort.desc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> thenBySymbol() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'symbol', Sort.asc);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QAfterSortBy> thenBySymbolDesc() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addSortBy(r'symbol', Sort.desc);
+    });
+  }
+}
+
+extension SolContractQueryWhereDistinct
+    on QueryBuilder<SolContract, SolContract, QDistinct> {
+  QueryBuilder<SolContract, SolContract, QDistinct> distinctByAddress({
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addDistinctBy(r'address', caseSensitive: caseSensitive);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QDistinct> distinctByDecimals() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addDistinctBy(r'decimals');
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QDistinct> distinctByLogoUri({
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addDistinctBy(r'logoUri', caseSensitive: caseSensitive);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QDistinct> distinctByMetadataAddress({
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addDistinctBy(
+        r'metadataAddress',
+        caseSensitive: caseSensitive,
+      );
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QDistinct> distinctByName({
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addDistinctBy(r'name', caseSensitive: caseSensitive);
+    });
+  }
+
+  QueryBuilder<SolContract, SolContract, QDistinct> distinctBySymbol({
+    bool caseSensitive = true,
+  }) {
+    return QueryBuilder.apply(this, (query) {
+      return query.addDistinctBy(r'symbol', caseSensitive: caseSensitive);
+    });
+  }
+}
+
+extension SolContractQueryProperty
+    on QueryBuilder<SolContract, SolContract, QQueryProperty> {
+  QueryBuilder<SolContract, int, QQueryOperations> idProperty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addPropertyName(r'id');
+    });
+  }
+
+  QueryBuilder<SolContract, String, QQueryOperations> addressProperty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addPropertyName(r'address');
+    });
+  }
+
+  QueryBuilder<SolContract, int, QQueryOperations> decimalsProperty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addPropertyName(r'decimals');
+    });
+  }
+
+  QueryBuilder<SolContract, String?, QQueryOperations> logoUriProperty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addPropertyName(r'logoUri');
+    });
+  }
+
+  QueryBuilder<SolContract, String?, QQueryOperations>
+  metadataAddressProperty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addPropertyName(r'metadataAddress');
+    });
+  }
+
+  QueryBuilder<SolContract, String, QQueryOperations> nameProperty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addPropertyName(r'name');
+    });
+  }
+
+  QueryBuilder<SolContract, String, QQueryOperations> symbolProperty() {
+    return QueryBuilder.apply(this, (query) {
+      return query.addPropertyName(r'symbol');
+    });
+  }
+}
diff --git a/lib/models/isar/models/solana/spl_token.dart b/lib/models/isar/models/solana/spl_token.dart
deleted file mode 100644
index 218001d..0000000
--- a/lib/models/isar/models/solana/spl_token.dart
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * This file is part of Stack Wallet.
- *
- * Copyright (c) 2025 Cypher Stack
- * All Rights Reserved.
- * The code is distributed under GPLv3 license, see LICENSE file for details.
- *
- */
-
-import 'package:isar_community/isar.dart';
-
-import '../contract.dart';
-
-part 'spl_token.g.dart';
-
-@collection
-class SplToken extends Contract {
-  SplToken({
-    required this.address,
-    required this.name,
-    required this.symbol,
-    required this.decimals,
-    this.logoUri,
-    this.metadataAddress,
-  });
-
-  Id id = Isar.autoIncrement;
-
-  @override
-  @Index(unique: true, replace: true)
-  late final String address; // Mint address.
-
-  @override
-  late final String name;
-
-  @override
-  late final String symbol;
-
-  @override
-  late final int decimals;
-
-  late final String? logoUri;
-
-  late final String? metadataAddress;
-
-  SplToken copyWith({
-    Id? id,
-    String? address,
-    String? name,
-    String? symbol,
-    int? decimals,
-    String? logoUri,
-    String? metadataAddress,
-  }) => SplToken(
-    address: address ?? this.address,
-    name: name ?? this.name,
-    symbol: symbol ?? this.symbol,
-    decimals: decimals ?? this.decimals,
-    logoUri: logoUri ?? this.logoUri,
-    metadataAddress: metadataAddress ?? this.metadataAddress,
-  )..id = id ?? this.id;
-}
diff --git a/lib/models/isar/models/solana/spl_token.g.dart b/lib/models/isar/models/solana/spl_token.g.dart
deleted file mode 100644
index 317e34b..0000000
--- a/lib/models/isar/models/solana/spl_token.g.dart
+++ /dev/null
@@ -1,1482 +0,0 @@
-// GENERATED CODE - DO NOT MODIFY BY HAND
-
-part of 'spl_token.dart';
-
-// **************************************************************************
-// IsarCollectionGenerator
-// **************************************************************************
-
-// coverage:ignore-file
-// ignore_for_file: duplicate_ignore, non_constant_identifier_names, constant_identifier_names, invalid_use_of_protected_member, unnecessary_cast, prefer_const_constructors, lines_longer_than_80_chars, require_trailing_commas, inference_failure_on_function_invocation, unnecessary_parenthesis, unnecessary_raw_strings, unnecessary_null_checks, join_return_with_assignment, prefer_final_locals, avoid_js_rounded_ints, avoid_positional_boolean_parameters, always_specify_types
-
-extension GetSplTokenCollection on Isar {
-  IsarCollection<SplToken> get splTokens => this.collection();
-}
-
-const SplTokenSchema = CollectionSchema(
-  name: r'SplToken',
-  id: 8546297717864199659,
-  properties: {
-    r'address': PropertySchema(id: 0, name: r'address', type: IsarType.string),
-    r'decimals': PropertySchema(id: 1, name: r'decimals', type: IsarType.long),
-    r'logoUri': PropertySchema(id: 2, name: r'logoUri', type: IsarType.string),
-    r'metadataAddress': PropertySchema(
-      id: 3,
-      name: r'metadataAddress',
-      type: IsarType.string,
-    ),
-    r'name': PropertySchema(id: 4, name: r'name', type: IsarType.string),
-    r'symbol': PropertySchema(id: 5, name: r'symbol', type: IsarType.string),
-  },
-
-  estimateSize: _splTokenEstimateSize,
-  serialize: _splTokenSerialize,
-  deserialize: _splTokenDeserialize,
-  deserializeProp: _splTokenDeserializeProp,
-  idName: r'id',
-  indexes: {
-    r'address': IndexSchema(
-      id: -259407546592846288,
-      name: r'address',
-      unique: true,
-      replace: true,
-      properties: [
-        IndexPropertySchema(
-          name: r'address',
-          type: IndexType.hash,
-          caseSensitive: true,
-        ),
-      ],
-    ),
-  },
-  links: {},
-  embeddedSchemas: {},
-
-  getId: _splTokenGetId,
-  getLinks: _splTokenGetLinks,
-  attach: _splTokenAttach,
-  version: '3.3.0-dev.2',
-);
-
-int _splTokenEstimateSize(
-  SplToken object,
-  List<int> offsets,
-  Map<Type, List<int>> allOffsets,
-) {
-  var bytesCount = offsets.last;
-  bytesCount += 3 + object.address.length * 3;
-  {
-    final value = object.logoUri;
-    if (value != null) {
-      bytesCount += 3 + value.length * 3;
-    }
-  }
-  {
-    final value = object.metadataAddress;
-    if (value != null) {
-      bytesCount += 3 + value.length * 3;
-    }
-  }
-  bytesCount += 3 + object.name.length * 3;
-  bytesCount += 3 + object.symbol.length * 3;
-  return bytesCount;
-}
-
-void _splTokenSerialize(
-  SplToken object,
-  IsarWriter writer,
-  List<int> offsets,
-  Map<Type, List<int>> allOffsets,
-) {
-  writer.writeString(offsets[0], object.address);
-  writer.writeLong(offsets[1], object.decimals);
-  writer.writeString(offsets[2], object.logoUri);
-  writer.writeString(offsets[3], object.metadataAddress);
-  writer.writeString(offsets[4], object.name);
-  writer.writeString(offsets[5], object.symbol);
-}
-
-SplToken _splTokenDeserialize(
-  Id id,
-  IsarReader reader,
-  List<int> offsets,
-  Map<Type, List<int>> allOffsets,
-) {
-  final object = SplToken(
-    address: reader.readString(offsets[0]),
-    decimals: reader.readLong(offsets[1]),
-    logoUri: reader.readStringOrNull(offsets[2]),
-    metadataAddress: reader.readStringOrNull(offsets[3]),
-    name: reader.readString(offsets[4]),
-    symbol: reader.readString(offsets[5]),
-  );
-  object.id = id;
-  return object;
-}
-
-P _splTokenDeserializeProp<P>(
-  IsarReader reader,
-  int propertyId,
-  int offset,
-  Map<Type, List<int>> allOffsets,
-) {
-  switch (propertyId) {
-    case 0:
-      return (reader.readString(offset)) as P;
-    case 1:
-      return (reader.readLong(offset)) as P;
-    case 2:
-      return (reader.readStringOrNull(offset)) as P;
-    case 3:
-      return (reader.readStringOrNull(offset)) as P;
-    case 4:
-      return (reader.readString(offset)) as P;
-    case 5:
-      return (reader.readString(offset)) as P;
-    default:
-      throw IsarError('Unknown property with id $propertyId');
-  }
-}
-
-Id _splTokenGetId(SplToken object) {
-  return object.id;
-}
-
-List<IsarLinkBase<dynamic>> _splTokenGetLinks(SplToken object) {
-  return [];
-}
-
-void _splTokenAttach(IsarCollection<dynamic> col, Id id, SplToken object) {
-  object.id = id;
-}
-
-extension SplTokenByIndex on IsarCollection<SplToken> {
-  Future<SplToken?> getByAddress(String address) {
-    return getByIndex(r'address', [address]);
-  }
-
-  SplToken? getByAddressSync(String address) {
-    return getByIndexSync(r'address', [address]);
-  }
-
-  Future<bool> deleteByAddress(String address) {
-    return deleteByIndex(r'address', [address]);
-  }
-
-  bool deleteByAddressSync(String address) {
-    return deleteByIndexSync(r'address', [address]);
-  }
-
-  Future<List<SplToken?>> getAllByAddress(List<String> addressValues) {
-    final values = addressValues.map((e) => [e]).toList();
-    return getAllByIndex(r'address', values);
-  }
-
-  List<SplToken?> getAllByAddressSync(List<String> addressValues) {
-    final values = addressValues.map((e) => [e]).toList();
-    return getAllByIndexSync(r'address', values);
-  }
-
-  Future<int> deleteAllByAddress(List<String> addressValues) {
-    final values = addressValues.map((e) => [e]).toList();
-    return deleteAllByIndex(r'address', values);
-  }
-
-  int deleteAllByAddressSync(List<String> addressValues) {
-    final values = addressValues.map((e) => [e]).toList();
-    return deleteAllByIndexSync(r'address', values);
-  }
-
-  Future<Id> putByAddress(SplToken object) {
-    return putByIndex(r'address', object);
-  }
-
-  Id putByAddressSync(SplToken object, {bool saveLinks = true}) {
-    return putByIndexSync(r'address', object, saveLinks: saveLinks);
-  }
-
-  Future<List<Id>> putAllByAddress(List<SplToken> objects) {
-    return putAllByIndex(r'address', objects);
-  }
-
-  List<Id> putAllByAddressSync(
-    List<SplToken> objects, {
-    bool saveLinks = true,
-  }) {
-    return putAllByIndexSync(r'address', objects, saveLinks: saveLinks);
-  }
-}
-
-extension SplTokenQueryWhereSort on QueryBuilder<SplToken, SplToken, QWhere> {
-  QueryBuilder<SplToken, SplToken, QAfterWhere> anyId() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addWhereClause(const IdWhereClause.any());
-    });
-  }
-}
-
-extension SplTokenQueryWhere on QueryBuilder<SplToken, SplToken, QWhereClause> {
-  QueryBuilder<SplToken, SplToken, QAfterWhereClause> idEqualTo(Id id) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addWhereClause(IdWhereClause.between(lower: id, upper: id));
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterWhereClause> 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<SplToken, SplToken, QAfterWhereClause> idGreaterThan(
-    Id id, {
-    bool include = false,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addWhereClause(
-        IdWhereClause.greaterThan(lower: id, includeLower: include),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterWhereClause> idLessThan(
-    Id id, {
-    bool include = false,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addWhereClause(
-        IdWhereClause.lessThan(upper: id, includeUpper: include),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterWhereClause> 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<SplToken, SplToken, QAfterWhereClause> addressEqualTo(
-    String address,
-  ) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addWhereClause(
-        IndexWhereClause.equalTo(indexName: r'address', value: [address]),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterWhereClause> addressNotEqualTo(
-    String address,
-  ) {
-    return QueryBuilder.apply(this, (query) {
-      if (query.whereSort == Sort.asc) {
-        return query
-            .addWhereClause(
-              IndexWhereClause.between(
-                indexName: r'address',
-                lower: [],
-                upper: [address],
-                includeUpper: false,
-              ),
-            )
-            .addWhereClause(
-              IndexWhereClause.between(
-                indexName: r'address',
-                lower: [address],
-                includeLower: false,
-                upper: [],
-              ),
-            );
-      } else {
-        return query
-            .addWhereClause(
-              IndexWhereClause.between(
-                indexName: r'address',
-                lower: [address],
-                includeLower: false,
-                upper: [],
-              ),
-            )
-            .addWhereClause(
-              IndexWhereClause.between(
-                indexName: r'address',
-                lower: [],
-                upper: [address],
-                includeUpper: false,
-              ),
-            );
-      }
-    });
-  }
-}
-
-extension SplTokenQueryFilter
-    on QueryBuilder<SplToken, SplToken, QFilterCondition> {
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> addressEqualTo(
-    String value, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.equalTo(
-          property: r'address',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> addressGreaterThan(
-    String value, {
-    bool include = false,
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.greaterThan(
-          include: include,
-          property: r'address',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> addressLessThan(
-    String value, {
-    bool include = false,
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.lessThan(
-          include: include,
-          property: r'address',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> addressBetween(
-    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'address',
-          lower: lower,
-          includeLower: includeLower,
-          upper: upper,
-          includeUpper: includeUpper,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> addressStartsWith(
-    String value, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.startsWith(
-          property: r'address',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> addressEndsWith(
-    String value, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.endsWith(
-          property: r'address',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> addressContains(
-    String value, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.contains(
-          property: r'address',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> addressMatches(
-    String pattern, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.matches(
-          property: r'address',
-          wildcard: pattern,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> addressIsEmpty() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.equalTo(property: r'address', value: ''),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> addressIsNotEmpty() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.greaterThan(property: r'address', value: ''),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> decimalsEqualTo(
-    int value,
-  ) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.equalTo(property: r'decimals', value: value),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> decimalsGreaterThan(
-    int value, {
-    bool include = false,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.greaterThan(
-          include: include,
-          property: r'decimals',
-          value: value,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> decimalsLessThan(
-    int value, {
-    bool include = false,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.lessThan(
-          include: include,
-          property: r'decimals',
-          value: value,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> decimalsBetween(
-    int lower,
-    int upper, {
-    bool includeLower = true,
-    bool includeUpper = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.between(
-          property: r'decimals',
-          lower: lower,
-          includeLower: includeLower,
-          upper: upper,
-          includeUpper: includeUpper,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> idEqualTo(Id value) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.equalTo(property: r'id', value: value),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> idGreaterThan(
-    Id value, {
-    bool include = false,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.greaterThan(
-          include: include,
-          property: r'id',
-          value: value,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> idLessThan(
-    Id value, {
-    bool include = false,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.lessThan(
-          include: include,
-          property: r'id',
-          value: value,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> 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<SplToken, SplToken, QAfterFilterCondition> logoUriIsNull() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        const FilterCondition.isNull(property: r'logoUri'),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> logoUriIsNotNull() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        const FilterCondition.isNotNull(property: r'logoUri'),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> logoUriEqualTo(
-    String? value, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.equalTo(
-          property: r'logoUri',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> logoUriGreaterThan(
-    String? value, {
-    bool include = false,
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.greaterThan(
-          include: include,
-          property: r'logoUri',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> logoUriLessThan(
-    String? value, {
-    bool include = false,
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.lessThan(
-          include: include,
-          property: r'logoUri',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> logoUriBetween(
-    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'logoUri',
-          lower: lower,
-          includeLower: includeLower,
-          upper: upper,
-          includeUpper: includeUpper,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> logoUriStartsWith(
-    String value, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.startsWith(
-          property: r'logoUri',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> logoUriEndsWith(
-    String value, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.endsWith(
-          property: r'logoUri',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> logoUriContains(
-    String value, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.contains(
-          property: r'logoUri',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> logoUriMatches(
-    String pattern, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.matches(
-          property: r'logoUri',
-          wildcard: pattern,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> logoUriIsEmpty() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.equalTo(property: r'logoUri', value: ''),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> logoUriIsNotEmpty() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.greaterThan(property: r'logoUri', value: ''),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition>
-  metadataAddressIsNull() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        const FilterCondition.isNull(property: r'metadataAddress'),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition>
-  metadataAddressIsNotNull() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        const FilterCondition.isNotNull(property: r'metadataAddress'),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition>
-  metadataAddressEqualTo(String? value, {bool caseSensitive = true}) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.equalTo(
-          property: r'metadataAddress',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition>
-  metadataAddressGreaterThan(
-    String? value, {
-    bool include = false,
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.greaterThan(
-          include: include,
-          property: r'metadataAddress',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition>
-  metadataAddressLessThan(
-    String? value, {
-    bool include = false,
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.lessThan(
-          include: include,
-          property: r'metadataAddress',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition>
-  metadataAddressBetween(
-    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'metadataAddress',
-          lower: lower,
-          includeLower: includeLower,
-          upper: upper,
-          includeUpper: includeUpper,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition>
-  metadataAddressStartsWith(String value, {bool caseSensitive = true}) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.startsWith(
-          property: r'metadataAddress',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition>
-  metadataAddressEndsWith(String value, {bool caseSensitive = true}) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.endsWith(
-          property: r'metadataAddress',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition>
-  metadataAddressContains(String value, {bool caseSensitive = true}) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.contains(
-          property: r'metadataAddress',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition>
-  metadataAddressMatches(String pattern, {bool caseSensitive = true}) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.matches(
-          property: r'metadataAddress',
-          wildcard: pattern,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition>
-  metadataAddressIsEmpty() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.equalTo(property: r'metadataAddress', value: ''),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition>
-  metadataAddressIsNotEmpty() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.greaterThan(property: r'metadataAddress', value: ''),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> nameEqualTo(
-    String value, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.equalTo(
-          property: r'name',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> nameGreaterThan(
-    String value, {
-    bool include = false,
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.greaterThan(
-          include: include,
-          property: r'name',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> nameLessThan(
-    String value, {
-    bool include = false,
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.lessThan(
-          include: include,
-          property: r'name',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> nameBetween(
-    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'name',
-          lower: lower,
-          includeLower: includeLower,
-          upper: upper,
-          includeUpper: includeUpper,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> nameStartsWith(
-    String value, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.startsWith(
-          property: r'name',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> nameEndsWith(
-    String value, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.endsWith(
-          property: r'name',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> nameContains(
-    String value, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.contains(
-          property: r'name',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> nameMatches(
-    String pattern, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.matches(
-          property: r'name',
-          wildcard: pattern,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> nameIsEmpty() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.equalTo(property: r'name', value: ''),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> nameIsNotEmpty() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.greaterThan(property: r'name', value: ''),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> symbolEqualTo(
-    String value, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.equalTo(
-          property: r'symbol',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> symbolGreaterThan(
-    String value, {
-    bool include = false,
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.greaterThan(
-          include: include,
-          property: r'symbol',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> symbolLessThan(
-    String value, {
-    bool include = false,
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.lessThan(
-          include: include,
-          property: r'symbol',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> symbolBetween(
-    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'symbol',
-          lower: lower,
-          includeLower: includeLower,
-          upper: upper,
-          includeUpper: includeUpper,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> symbolStartsWith(
-    String value, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.startsWith(
-          property: r'symbol',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> symbolEndsWith(
-    String value, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.endsWith(
-          property: r'symbol',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> symbolContains(
-    String value, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.contains(
-          property: r'symbol',
-          value: value,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> symbolMatches(
-    String pattern, {
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.matches(
-          property: r'symbol',
-          wildcard: pattern,
-          caseSensitive: caseSensitive,
-        ),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> symbolIsEmpty() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.equalTo(property: r'symbol', value: ''),
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterFilterCondition> symbolIsNotEmpty() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addFilterCondition(
-        FilterCondition.greaterThan(property: r'symbol', value: ''),
-      );
-    });
-  }
-}
-
-extension SplTokenQueryObject
-    on QueryBuilder<SplToken, SplToken, QFilterCondition> {}
-
-extension SplTokenQueryLinks
-    on QueryBuilder<SplToken, SplToken, QFilterCondition> {}
-
-extension SplTokenQuerySortBy on QueryBuilder<SplToken, SplToken, QSortBy> {
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> sortByAddress() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'address', Sort.asc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> sortByAddressDesc() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'address', Sort.desc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> sortByDecimals() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'decimals', Sort.asc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> sortByDecimalsDesc() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'decimals', Sort.desc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> sortByLogoUri() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'logoUri', Sort.asc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> sortByLogoUriDesc() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'logoUri', Sort.desc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> sortByMetadataAddress() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'metadataAddress', Sort.asc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> sortByMetadataAddressDesc() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'metadataAddress', Sort.desc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> sortByName() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'name', Sort.asc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> sortByNameDesc() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'name', Sort.desc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> sortBySymbol() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'symbol', Sort.asc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> sortBySymbolDesc() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'symbol', Sort.desc);
-    });
-  }
-}
-
-extension SplTokenQuerySortThenBy
-    on QueryBuilder<SplToken, SplToken, QSortThenBy> {
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> thenByAddress() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'address', Sort.asc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> thenByAddressDesc() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'address', Sort.desc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> thenByDecimals() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'decimals', Sort.asc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> thenByDecimalsDesc() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'decimals', Sort.desc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> thenById() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'id', Sort.asc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> thenByIdDesc() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'id', Sort.desc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> thenByLogoUri() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'logoUri', Sort.asc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> thenByLogoUriDesc() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'logoUri', Sort.desc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> thenByMetadataAddress() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'metadataAddress', Sort.asc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> thenByMetadataAddressDesc() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'metadataAddress', Sort.desc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> thenByName() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'name', Sort.asc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> thenByNameDesc() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'name', Sort.desc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> thenBySymbol() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'symbol', Sort.asc);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QAfterSortBy> thenBySymbolDesc() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addSortBy(r'symbol', Sort.desc);
-    });
-  }
-}
-
-extension SplTokenQueryWhereDistinct
-    on QueryBuilder<SplToken, SplToken, QDistinct> {
-  QueryBuilder<SplToken, SplToken, QDistinct> distinctByAddress({
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addDistinctBy(r'address', caseSensitive: caseSensitive);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QDistinct> distinctByDecimals() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addDistinctBy(r'decimals');
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QDistinct> distinctByLogoUri({
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addDistinctBy(r'logoUri', caseSensitive: caseSensitive);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QDistinct> distinctByMetadataAddress({
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addDistinctBy(
-        r'metadataAddress',
-        caseSensitive: caseSensitive,
-      );
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QDistinct> distinctByName({
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addDistinctBy(r'name', caseSensitive: caseSensitive);
-    });
-  }
-
-  QueryBuilder<SplToken, SplToken, QDistinct> distinctBySymbol({
-    bool caseSensitive = true,
-  }) {
-    return QueryBuilder.apply(this, (query) {
-      return query.addDistinctBy(r'symbol', caseSensitive: caseSensitive);
-    });
-  }
-}
-
-extension SplTokenQueryProperty
-    on QueryBuilder<SplToken, SplToken, QQueryProperty> {
-  QueryBuilder<SplToken, int, QQueryOperations> idProperty() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addPropertyName(r'id');
-    });
-  }
-
-  QueryBuilder<SplToken, String, QQueryOperations> addressProperty() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addPropertyName(r'address');
-    });
-  }
-
-  QueryBuilder<SplToken, int, QQueryOperations> decimalsProperty() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addPropertyName(r'decimals');
-    });
-  }
-
-  QueryBuilder<SplToken, String?, QQueryOperations> logoUriProperty() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addPropertyName(r'logoUri');
-    });
-  }
-
-  QueryBuilder<SplToken, String?, QQueryOperations> metadataAddressProperty() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addPropertyName(r'metadataAddress');
-    });
-  }
-
-  QueryBuilder<SplToken, String, QQueryOperations> nameProperty() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addPropertyName(r'name');
-    });
-  }
-
-  QueryBuilder<SplToken, String, QQueryOperations> symbolProperty() {
-    return QueryBuilder.apply(this, (query) {
-      return query.addPropertyName(r'symbol');
-    });
-  }
-}
diff --git a/lib/pages/add_wallet_views/add_token_view/add_custom_solana_token_view.dart b/lib/pages/add_wallet_views/add_token_view/add_custom_solana_token_view.dart
index ab23228..c5f1308 100644
--- a/lib/pages/add_wallet_views/add_token_view/add_custom_solana_token_view.dart
+++ b/lib/pages/add_wallet_views/add_token_view/add_custom_solana_token_view.dart
@@ -14,7 +14,7 @@ import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 
-import '../../../models/isar/models/solana/spl_token.dart';
+import '../../../models/isar/models/solana/sol_contract.dart';
 import '../../../services/solana/solana_token_api.dart';
 import '../../../themes/stack_colors.dart';
 import '../../../utilities/text_styles.dart';
@@ -53,7 +53,7 @@ class _AddCustomSolanaTokenViewState
   bool enableSubFields = false;
   bool addTokenButtonEnabled = false;
 
-  SplToken? currentToken;
+  SolContract? currentToken;
 
   Future<void> _searchTokenMetadata() async {
     debugPrint('[ADD_CUSTOM_SOLANA_TOKEN] Search button pressed');
@@ -161,7 +161,7 @@ class _AddCustomSolanaTokenViewState
                     ),
                     const SizedBox(height: 8),
                     Text(
-                      "Please enter a valid Solana SPL token mint address "
+                      "Please enter a valid Solana token mint address "
                       "(base58 encoded, ~44 characters).",
                       style: STextStyles.smallMed14(context),
                     ),
@@ -204,7 +204,7 @@ class _AddCustomSolanaTokenViewState
 
     if (response.value != null && response.value!.isNotEmpty) {
       final metadata = response.value!;
-      currentToken = SplToken(
+      currentToken = SolContract(
         address: mintController.text.trim(),
         name: metadata['name'] as String? ?? 'Unknown Token',
         symbol: metadata['symbol'] as String? ?? '???',
@@ -235,7 +235,7 @@ class _AddCustomSolanaTokenViewState
       // custom values.
       setState(() {
         enableSubFields = true;
-        currentToken = SplToken(
+        currentToken = SolContract(
           address: mintController.text.trim(),
           name: '',
           symbol: '',
@@ -370,7 +370,7 @@ class _AddCustomSolanaTokenViewState
               controller: mintController,
               style: STextStyles.field(context),
               decoration: InputDecoration(
-                hintText: "SPL token mint address",
+                hintText: "SOL token mint address",
                 hintStyle: STextStyles.fieldLabel(context),
               ),
             ),
diff --git a/lib/pages/add_wallet_views/add_token_view/edit_wallet_tokens_view.dart b/lib/pages/add_wallet_views/add_token_view/edit_wallet_tokens_view.dart
index 1460f18..d81afe5 100644
--- a/lib/pages/add_wallet_views/add_token_view/edit_wallet_tokens_view.dart
+++ b/lib/pages/add_wallet_views/add_token_view/edit_wallet_tokens_view.dart
@@ -17,7 +17,7 @@ import 'package:isar_community/isar.dart';
 
 import '../../../db/isar/main_db.dart';
 import '../../../models/isar/models/ethereum/eth_contract.dart';
-import '../../../models/isar/models/solana/spl_token.dart';
+import '../../../models/isar/models/solana/sol_contract.dart';
 import '../../../notifications/show_flush_bar.dart';
 import '../../../pages_desktop_specific/desktop_home_view.dart';
 import '../../../providers/global/price_provider.dart';
@@ -26,7 +26,7 @@ import '../../../themes/stack_colors.dart';
 import '../../../utilities/assets.dart';
 import '../../../utilities/constants.dart';
 import '../../../utilities/default_eth_tokens.dart';
-import '../../../utilities/default_spl_tokens.dart';
+import '../../../utilities/default_sol_tokens.dart';
 import '../../../utilities/text_styles.dart';
 import '../../../utilities/util.dart';
 import '../../../wallets/isar/providers/wallet_info_provider.dart';
@@ -187,7 +187,7 @@ class _EditWalletTokensViewState extends ConsumerState<EditWalletTokensView> {
 
   /// Navigate to add custom Solana token view and handle the result.
   Future<void> _addCustomSolanaToken() async {
-    SplToken? token;
+    SolContract? token;
 
     if (isDesktop) {
       token = await showDialog(
@@ -205,11 +205,11 @@ class _EditWalletTokensViewState extends ConsumerState<EditWalletTokensView> {
         AddCustomSolanaTokenView.routeName,
         arguments: widget.walletId,
       );
-      token = result as SplToken?;
+      token = result as SolContract?;
     }
 
     if (token != null) {
-      await MainDB.instance.putSplToken(token);
+      await MainDB.instance.putSolContract(token);
 
       // Also add the custom token mint address to the wallet's custom token list.
       final wallet = ref.read(pWallets).getWallet(widget.walletId);
@@ -247,14 +247,14 @@ class _EditWalletTokensViewState extends ConsumerState<EditWalletTokensView> {
 
     if (wallet is SolanaWallet) {
       final contracts = MainDB.instance
-          .getSplTokens()
+          .getSolContracts()
           .sortByName()
           .findAllSync();
 
       if (contracts.isEmpty) {
-        contracts.addAll(DefaultSplTokens.list);
+        contracts.addAll(DefaultSolTokens.list);
         MainDB.instance
-            .putSplTokens(contracts)
+            .putSolContracts(contracts)
             .then(
               (_) => ref.read(priceAnd24hChangeNotifierProvider).updatePrice(),
             );
diff --git a/lib/pages/add_wallet_views/add_wallet_view/add_wallet_view.dart b/lib/pages/add_wallet_views/add_wallet_view/add_wallet_view.dart
index 4f94e05..13cb7a0 100644
--- a/lib/pages/add_wallet_views/add_wallet_view/add_wallet_view.dart
+++ b/lib/pages/add_wallet_views/add_wallet_view/add_wallet_view.dart
@@ -22,14 +22,14 @@ import '../../../models/add_wallet_list_entity/sub_classes/coin_entity.dart';
 import '../../../models/add_wallet_list_entity/sub_classes/eth_token_entity.dart';
 import '../../../models/add_wallet_list_entity/sub_classes/sol_token_entity.dart';
 import '../../../models/isar/models/ethereum/eth_contract.dart';
-import '../../../models/isar/models/solana/spl_token.dart';
+import '../../../models/isar/models/solana/sol_contract.dart';
 import '../../../pages_desktop_specific/my_stack_view/exit_to_my_stack_button.dart';
 import '../../../providers/providers.dart';
 import '../../../themes/stack_colors.dart';
 import '../../../utilities/assets.dart';
 import '../../../utilities/constants.dart';
 import '../../../utilities/default_eth_tokens.dart';
-import '../../../utilities/default_spl_tokens.dart';
+import '../../../utilities/default_sol_tokens.dart';
 import '../../../utilities/text_styles.dart';
 import '../../../utilities/util.dart';
 import '../../../wallets/crypto_currency/crypto_currency.dart';
@@ -43,8 +43,8 @@ import '../../../widgets/icon_widgets/x_icon.dart';
 import '../../../widgets/rounded_white_container.dart';
 import '../../../widgets/stack_text_field.dart';
 import '../../../widgets/textfield_icon_button.dart';
-import '../add_token_view/add_custom_token_view.dart';
 import '../add_token_view/add_custom_solana_token_view.dart';
+import '../add_token_view/add_custom_token_view.dart';
 import '../add_token_view/sub_widgets/add_custom_token_selector.dart';
 import 'sub_widgets/add_wallet_text.dart';
 import 'sub_widgets/expanding_sub_list_item.dart';
@@ -133,7 +133,7 @@ class _AddWalletViewState extends ConsumerState<AddWalletView> {
   }
 
   Future<void> _addSolToken() async {
-    SplToken? token;
+    SolContract? token;
     if (isDesktop) {
       token = await showDialog(
         context: context,
@@ -151,7 +151,7 @@ class _AddWalletViewState extends ConsumerState<AddWalletView> {
     }
 
     if (token != null) {
-      await MainDB.instance.putSplToken(token);
+      await MainDB.instance.putSolContract(token);
       if (mounted) {
         setState(() {
           if (solTokenEntities
@@ -194,14 +194,14 @@ class _AddWalletViewState extends ConsumerState<AddWalletView> {
 
     if (AppConfig.coins.whereType<Solana>().isNotEmpty) {
       final contracts = MainDB.instance
-          .getSplTokens()
+          .getSolContracts()
           .sortByName()
           .findAllSync();
 
       if (contracts.isEmpty) {
-        contracts.addAll(DefaultSplTokens.list);
+        contracts.addAll(DefaultSolTokens.list);
         MainDB.instance
-            .putSplTokens(contracts)
+            .putSolContracts(contracts)
             .then(
               (value) =>
                   ref.read(priceAnd24hChangeNotifierProvider).updatePrice(),
diff --git a/lib/pages/send_view/confirm_transaction_view.dart b/lib/pages/send_view/confirm_transaction_view.dart
index ee59315..91570b6 100644
--- a/lib/pages/send_view/confirm_transaction_view.dart
+++ b/lib/pages/send_view/confirm_transaction_view.dart
@@ -17,7 +17,7 @@ import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:flutter_svg/svg.dart';
 
-import '../../models/isar/models/solana/spl_token.dart';
+import '../../models/isar/models/solana/sol_contract.dart';
 import '../../models/isar/models/transaction_note.dart';
 import '../../notifications/show_flush_bar.dart';
 import '../../pages_desktop_specific/coin_control/desktop_coin_control_use_dialog.dart';
@@ -631,8 +631,8 @@ class _ConfirmTransactionViewState
                                           .watch(pCurrentTokenWallet)!
                                           .tokenContract
                                     : null,
-                                splToken: widget.isTokenTx && wallet is SolanaWallet
-                                    ? SplToken(
+                                solContract: widget.isTokenTx && wallet is SolanaWallet
+                                    ? SolContract(
                                         address: widget.txData.tokenMint ?? "unknown",
                                         name: widget.txData.tokenSymbol ?? "Token",
                                         symbol: widget.txData.tokenSymbol ?? "TOKEN",
@@ -886,8 +886,8 @@ class _ConfirmTransactionViewState
                                                       )!
                                                       .tokenContract
                                                 : null,
-                                            splToken: widget.isTokenTx && wallet is SolanaWallet
-                                                ? SplToken(
+                                            solContract: widget.isTokenTx && wallet is SolanaWallet
+                                                ? SolContract(
                                                     address: widget.txData.tokenMint ?? "unknown",
                                                     name: widget.txData.tokenSymbol ?? "Token",
                                                     symbol: widget.txData.tokenSymbol ?? "TOKEN",
diff --git a/lib/pages/token_view/solana_token_contract_details_view.dart b/lib/pages/token_view/solana_token_contract_details_view.dart
index eadc8c6..2ed51ed 100644
--- a/lib/pages/token_view/solana_token_contract_details_view.dart
+++ b/lib/pages/token_view/solana_token_contract_details_view.dart
@@ -43,11 +43,11 @@ class _SolanaTokenContractDetailsViewState
     extends ConsumerState<SolanaTokenContractDetailsView> {
   final isDesktop = Util.isDesktop;
 
-  late SplToken token;
+  late SolContract token;
 
   @override
   void initState() {
-    token = MainDB.instance.isar.splTokens
+    token = MainDB.instance.isar.solContracts
         .where()
         .addressEqualTo(widget.tokenMint)
         .findFirstSync()!;
diff --git a/lib/pages/token_view/sub_widgets/sol_token_select_item.dart b/lib/pages/token_view/sub_widgets/sol_token_select_item.dart
index 50a5179..556be9f 100644
--- a/lib/pages/token_view/sub_widgets/sol_token_select_item.dart
+++ b/lib/pages/token_view/sub_widgets/sol_token_select_item.dart
@@ -12,7 +12,7 @@ import 'dart:async';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 
-import '../../../models/isar/models/solana/spl_token.dart';
+import '../../../models/isar/models/solana/sol_contract.dart';
 import '../../../pages_desktop_specific/my_stack_view/wallet_view/desktop_sol_token_view.dart';
 import '../../../providers/providers.dart';
 import '../../../themes/stack_colors.dart';
@@ -38,7 +38,7 @@ class SolTokenSelectItem extends ConsumerStatefulWidget {
   });
 
   final String walletId;
-  final SplToken token;
+  final SolContract token;
 
   @override
   ConsumerState<SolTokenSelectItem> createState() => _SolTokenSelectItemState();
diff --git a/lib/pages/token_view/sub_widgets/sol_tokens_list.dart b/lib/pages/token_view/sub_widgets/sol_tokens_list.dart
index e2502b7..ec8a067 100644
--- a/lib/pages/token_view/sub_widgets/sol_tokens_list.dart
+++ b/lib/pages/token_view/sub_widgets/sol_tokens_list.dart
@@ -11,7 +11,7 @@ import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:isar_community/isar.dart';
 
-import '../../../models/isar/models/solana/spl_token.dart';
+import '../../../models/isar/models/solana/sol_contract.dart';
 import '../../../providers/db/main_db_provider.dart';
 import '../../../utilities/util.dart';
 import 'sol_token_select_item.dart';
@@ -28,7 +28,7 @@ class SolanaTokensList extends StatelessWidget {
   final String searchTerm;
   final List<String> tokenMints;
 
-  List<SplToken> _filter(String searchTerm, List<SplToken> allTokens) {
+  List<SolContract> _filter(String searchTerm, List<SolContract> allTokens) {
     if (tokenMints.isEmpty) {
       return [];
     }
@@ -63,7 +63,7 @@ class SolanaTokensList extends StatelessWidget {
         // Get all available SOL tokens.
         final db = ref.watch(mainDBProvider);
 
-        final allTokens = db.getSplTokens().findAllSync();
+        final allTokens = db.getSolContracts().findAllSync();
 
         final tokens = _filter(searchTerm, allTokens);
 
diff --git a/lib/pages/wallets_view/wallets_overview.dart b/lib/pages/wallets_view/wallets_overview.dart
index 675838d..29aaa3b 100644
--- a/lib/pages/wallets_view/wallets_overview.dart
+++ b/lib/pages/wallets_view/wallets_overview.dart
@@ -164,7 +164,9 @@ class _EthWalletsOverviewState extends ConsumerState<WalletsOverview> {
 
         // fetch each token
         for (final tokenAddress in tokenMintAddresses) {
-          final token = ref.read(mainDBProvider).getSplTokenSync(tokenAddress);
+          final token = ref
+              .read(mainDBProvider)
+              .getSolContractSync(tokenAddress);
 
           // add it to list if it exists in DB
           if (token != null) {
diff --git a/lib/pages_desktop_specific/my_stack_view/wallet_view/sub_widgets/desktop_wallet_summary.dart b/lib/pages_desktop_specific/my_stack_view/wallet_view/sub_widgets/desktop_wallet_summary.dart
index b538eb4..c89a57d 100644
--- a/lib/pages_desktop_specific/my_stack_view/wallet_view/sub_widgets/desktop_wallet_summary.dart
+++ b/lib/pages_desktop_specific/my_stack_view/wallet_view/sub_widgets/desktop_wallet_summary.dart
@@ -188,7 +188,7 @@ class _WDesktopWalletSummaryState extends ConsumerState<DesktopWalletSummary> {
                         .format(
                           balanceToShow,
                           ethContract: tokenContract,
-                          splToken: solanaTokenWallet?.splToken,
+                          solContract: solanaTokenWallet?.solContract,
                         ),
                     style: STextStyles.desktopH3(context),
                   ),
diff --git a/lib/services/price_service.dart b/lib/services/price_service.dart
index d10ebe9..4cbf27d 100644
--- a/lib/services/price_service.dart
+++ b/lib/services/price_service.dart
@@ -26,7 +26,7 @@ class PriceService extends ChangeNotifier {
       (await MainDB.instance.getEthContracts().addressProperty().findAll())
           .toSet();
   Future<Set<String>> get solTokenContractAddressesToCheck async =>
-      (await MainDB.instance.getSplTokens().addressProperty().findAll())
+      (await MainDB.instance.getSolContracts().addressProperty().findAll())
           .toSet();
   final Duration updateInterval = const Duration(seconds: 60);
 
diff --git a/lib/utilities/amount/amount_formatter.dart b/lib/utilities/amount/amount_formatter.dart
index ead3c62..f5e047f 100644
--- a/lib/utilities/amount/amount_formatter.dart
+++ b/lib/utilities/amount/amount_formatter.dart
@@ -1,6 +1,6 @@
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import '../../models/isar/models/ethereum/eth_contract.dart';
-import '../../models/isar/models/solana/spl_token.dart';
+import '../../models/isar/models/solana/sol_contract.dart';
 import '../../providers/global/locale_provider.dart';
 import '../../providers/global/prefs_provider.dart';
 import 'amount.dart';
@@ -53,7 +53,7 @@ class AmountFormatter {
     Amount amount, {
     String? overrideUnit,
     EthContract? ethContract,
-    SplToken? splToken,
+    SolContract? solContract,
     bool withUnitName = true,
     bool indicatePrecisionLoss = true,
   }) {
@@ -66,7 +66,7 @@ class AmountFormatter {
       indicatePrecisionLoss: indicatePrecisionLoss,
       overrideUnit: overrideUnit,
       tokenContract: ethContract,
-      splToken: splToken,
+      splToken: solContract,
     );
   }
 
diff --git a/lib/utilities/amount/amount_unit.dart b/lib/utilities/amount/amount_unit.dart
index 2b320ab..7763a3e 100644
--- a/lib/utilities/amount/amount_unit.dart
+++ b/lib/utilities/amount/amount_unit.dart
@@ -12,7 +12,7 @@ import 'dart:math' as math;
 
 import 'package:decimal/decimal.dart';
 import '../../models/isar/models/ethereum/eth_contract.dart';
-import '../../models/isar/models/solana/spl_token.dart';
+import '../../models/isar/models/solana/sol_contract.dart';
 import 'amount.dart';
 import '../util.dart';
 import '../../wallets/crypto_currency/crypto_currency.dart';
@@ -176,7 +176,7 @@ extension AmountUnitExt on AmountUnit {
     }
   }
 
-  String unitForSplToken(SplToken token) {
+  String unitForSplToken(SolContract token) {
     switch (this) {
       case AmountUnit.normal:
         return token.symbol;
@@ -253,7 +253,7 @@ extension AmountUnitExt on AmountUnit {
     bool indicatePrecisionLoss = true,
     String? overrideUnit,
     EthContract? tokenContract,
-    SplToken? splToken,
+    SolContract? splToken,
   }) {
     assert(maxDecimalPlaces >= 0);
 
diff --git a/lib/utilities/default_sol_tokens.dart b/lib/utilities/default_sol_tokens.dart
new file mode 100644
index 0000000..fbc69a7
--- /dev/null
+++ b/lib/utilities/default_sol_tokens.dart
@@ -0,0 +1,55 @@
+/*
+ * This file is part of Stack Wallet.
+ *
+ * Copyright (c) 2025 Cypher Stack
+ * All Rights Reserved.
+ * The code is distributed under GPLv3 license, see LICENSE file for details.
+ *
+ */
+
+import '../models/isar/models/solana/sol_contract.dart';
+
+abstract class DefaultSolTokens {
+  static List<SolContract> list = [
+    SolContract(
+      address: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+      name: "USD Coin",
+      symbol: "USDC",
+      decimals: 6,
+      logoUri:
+          "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v/logo.png",
+    ),
+    SolContract(
+      address: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenEst",
+      name: "Tether",
+      symbol: "USDT",
+      decimals: 6,
+      logoUri:
+          "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenEst/logo.svg",
+    ),
+    SolContract(
+      address: "MangoCzJ36AjZyKwVj3VnYU4GTonjfVEnJmvvWaxLac",
+      name: "Mango",
+      symbol: "MNGO",
+      decimals: 6,
+      logoUri:
+          "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/MangoCzJ36AjZyKwVj3VnYU4GTonjfVEnJmvvWaxLac/logo.png",
+    ),
+    SolContract(
+      address: "SRMuApVgqbCmmp3uVrwpad5p4stLBUq3nSoSnqQQXmk",
+      name: "Serum",
+      symbol: "SRM",
+      decimals: 6,
+      logoUri:
+          "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/SRMuApVgqbCmmp3uVrwpad5p4stLBUq3nSoSnqQQXmk/logo.png",
+    ),
+    SolContract(
+      address: "orca8TvxvggsCKvVPXSHXDvKgJ3bNroWusDawg461mpD",
+      name: "Orca",
+      symbol: "ORCA",
+      decimals: 6,
+      logoUri:
+          "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/orcaEKTdK7LKz57chYcSKdBI6qrE5dS1zG4FqHWGcKc/logo.svg",
+    ),
+  ];
+}
diff --git a/lib/utilities/default_spl_tokens.dart b/lib/utilities/default_spl_tokens.dart
deleted file mode 100644
index 603ee9c..0000000
--- a/lib/utilities/default_spl_tokens.dart
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * This file is part of Stack Wallet.
- *
- * Copyright (c) 2025 Cypher Stack
- * All Rights Reserved.
- * The code is distributed under GPLv3 license, see LICENSE file for details.
- *
- */
-
-import '../models/isar/models/solana/spl_token.dart';
-
-abstract class DefaultSplTokens {
-  static List<SplToken> list = [
-    SplToken(
-      address: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
-      name: "USD Coin",
-      symbol: "USDC",
-      decimals: 6,
-      logoUri: "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v/logo.png",
-    ),
-    SplToken(
-      address: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenEst",
-      name: "Tether",
-      symbol: "USDT",
-      decimals: 6,
-      logoUri: "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenEst/logo.svg",
-    ),
-    SplToken(
-      address: "MangoCzJ36AjZyKwVj3VnYU4GTonjfVEnJmvvWaxLac",
-      name: "Mango",
-      symbol: "MNGO",
-      decimals: 6,
-      logoUri: "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/MangoCzJ36AjZyKwVj3VnYU4GTonjfVEnJmvvWaxLac/logo.png",
-    ),
-    SplToken(
-      address: "SRMuApVgqbCmmp3uVrwpad5p4stLBUq3nSoSnqQQXmk",
-      name: "Serum",
-      symbol: "SRM",
-      decimals: 6,
-      logoUri: "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/SRMuApVgqbCmmp3uVrwpad5p4stLBUq3nSoSnqQQXmk/logo.png",
-    ),
-    SplToken(
-      address: "orca8TvxvggsCKvVPXSHXDvKgJ3bNroWusDawg461mpD",
-      name: "Orca",
-      symbol: "ORCA",
-      decimals: 6,
-      logoUri: "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/orcaEKTdK7LKz57chYcSKdBI6qrE5dS1zG4FqHWGcKc/logo.svg",
-    ),
-  ];
-}
diff --git a/lib/wallets/isar/models/wallet_solana_token_info.dart b/lib/wallets/isar/models/wallet_solana_token_info.dart
index 16d45b1..473db74 100644
--- a/lib/wallets/isar/models/wallet_solana_token_info.dart
+++ b/lib/wallets/isar/models/wallet_solana_token_info.dart
@@ -41,8 +41,8 @@ class WalletSolanaTokenInfo implements IsarId {
     this.cachedBalanceJsonString,
   });
 
-  SplToken getToken(Isar isar) =>
-      isar.splTokens.where().addressEqualTo(tokenAddress).findFirstSync()!;
+  SolContract getToken(Isar isar) =>
+      isar.solContracts.where().addressEqualTo(tokenAddress).findFirstSync()!;
 
   // Token balance cache.
   Balance getCachedBalance() {
diff --git a/lib/wallets/isar/providers/solana/sol_token_balance_provider.dart b/lib/wallets/isar/providers/solana/sol_token_balance_provider.dart
index 831c508..739e231 100644
--- a/lib/wallets/isar/providers/solana/sol_token_balance_provider.dart
+++ b/lib/wallets/isar/providers/solana/sol_token_balance_provider.dart
@@ -39,13 +39,13 @@ final _wstwiProvider = ChangeNotifierProvider.family<
     );
 
     // Create initial entry if not found.
-    final splToken =
-        isar.splTokens.getByAddressSync(data.tokenMint);
+    final solContract =
+        isar.solContracts.getByAddressSync(data.tokenMint);
 
     initial = WalletSolanaTokenInfo(
       walletId: data.walletId,
       tokenAddress: data.tokenMint,
-      tokenFractionDigits: splToken?.decimals ?? 6,
+      tokenFractionDigits: solContract?.decimals ?? 6,
     );
 
     isar.writeTxnSync(() => isar.walletSolanaTokenInfo.putSync(initial!));
diff --git a/lib/wallets/isar/providers/solana/sol_tokens_provider.dart b/lib/wallets/isar/providers/solana/sol_tokens_provider.dart
index 1396a91..fe6a711 100644
--- a/lib/wallets/isar/providers/solana/sol_tokens_provider.dart
+++ b/lib/wallets/isar/providers/solana/sol_tokens_provider.dart
@@ -11,7 +11,7 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 
 /// Provides a list of Solana token mint addresses for a specific wallet.
 ///
-/// This provider returns the list of Solana SPL token mint addresses
+/// This provider returns the list of Solana token mint addresses
 /// that the wallet has selected. Token details are not currently persisted
 /// in the database - only the mint addresses are stored in WalletInfo's otherData.
 ///
diff --git a/lib/wallets/wallet/impl/sub_wallets/solana_token_wallet.dart b/lib/wallets/wallet/impl/sub_wallets/solana_token_wallet.dart
index 6c9d913..d03b0fd 100644
--- a/lib/wallets/wallet/impl/sub_wallets/solana_token_wallet.dart
+++ b/lib/wallets/wallet/impl/sub_wallets/solana_token_wallet.dart
@@ -31,17 +31,17 @@ class SolanaTokenWallet extends Wallet {
   @override
   int get isarTransactionVersion => 2;
 
-  SolanaTokenWallet(this.parentSolanaWallet, this.splToken)
+  SolanaTokenWallet(this.parentSolanaWallet, this.solContract)
     : super(parentSolanaWallet.cryptoCurrency);
 
   final SolanaWallet parentSolanaWallet;
 
-  final SplToken splToken;
+  final SolContract solContract;
 
-  String get tokenMint => splToken.address;
-  String get tokenName => splToken.name;
-  String get tokenSymbol => splToken.symbol;
-  int get tokenDecimals => splToken.decimals;
+  String get tokenMint => solContract.address;
+  String get tokenName => solContract.name;
+  String get tokenSymbol => solContract.symbol;
+  int get tokenDecimals => solContract.decimals;
 
   @override
   String get walletId => parentSolanaWallet.walletId;
@@ -77,7 +77,7 @@ class SolanaTokenWallet extends Wallet {
 
       if (txData.recipients!.length != 1) {
         throw ArgumentError(
-          "SPL token transfers support only 1 recipient per transaction",
+          "SOL token transfers support only 1 recipient per transaction",
         );
       }
 
diff --git a/lib/widgets/icon_widgets/sol_token_icon.dart b/lib/widgets/icon_widgets/sol_token_icon.dart
index dc01d17..8907651 100644
--- a/lib/widgets/icon_widgets/sol_token_icon.dart
+++ b/lib/widgets/icon_widgets/sol_token_icon.dart
@@ -22,14 +22,14 @@ import '../../utilities/logger.dart';
 import '../../wallets/crypto_currency/crypto_currency.dart';
 import '../loading_indicator.dart';
 
-/// Token icon widget for Solana SPL tokens.
+/// Token icon widget for Solana tokens.
 ///
 /// Displays the token icon by attempting to fetch from exchange data service.
 /// Falls back to generic Solana token icon if no icon is found.
 class SolTokenIcon extends ConsumerStatefulWidget {
   const SolTokenIcon({super.key, required this.mintAddress, this.size = 22});
 
-  /// The SPL token mint address.
+  /// The SOL token mint address.
   final String mintAddress;
 
   final double size;
diff --git a/lib/widgets/wallet_card.dart b/lib/widgets/wallet_card.dart
index 11fec09..8c6ab83 100644
--- a/lib/widgets/wallet_card.dart
+++ b/lib/widgets/wallet_card.dart
@@ -14,7 +14,7 @@ import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 
 import '../models/isar/models/ethereum/eth_contract.dart';
-import '../models/isar/models/solana/spl_token.dart';
+import '../models/isar/models/solana/sol_contract.dart';
 import '../pages/token_view/sol_token_view.dart';
 import '../pages/token_view/token_view.dart';
 import '../pages/wallet_view/wallet_view.dart';
@@ -102,7 +102,7 @@ class SimpleWalletCard extends ConsumerWidget {
     BuildContext context,
     WidgetRef ref,
     Wallet wallet,
-    SplToken token,
+    SolContract token,
   ) async {
     final old = ref.read(solanaTokenServiceStateProvider);
     // exit previous if there is one
@@ -193,7 +193,9 @@ class SimpleWalletCard extends ConsumerWidget {
       if (contractAddress != null) {
         if (wallet.cryptoCurrency is Solana) {
           // Handle Solana token.
-          final token = ref.read(mainDBProvider).getSplTokenSync(contractAddress!);
+          final token = ref
+              .read(mainDBProvider)
+              .getSolContractSync(contractAddress!);
 
           if (token == null) {
             Logging.instance.e(
diff --git a/lib/widgets/wallet_info_row/sub_widgets/wallet_info_row_balance.dart b/lib/widgets/wallet_info_row/sub_widgets/wallet_info_row_balance.dart
index e8c1c59..096428c 100644
--- a/lib/widgets/wallet_info_row/sub_widgets/wallet_info_row_balance.dart
+++ b/lib/widgets/wallet_info_row/sub_widgets/wallet_info_row_balance.dart
@@ -12,7 +12,7 @@ import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import '../../../db/isar/main_db.dart';
 import '../../../models/isar/models/ethereum/eth_contract.dart';
-import '../../../models/isar/models/solana/spl_token.dart';
+import '../../../models/isar/models/solana/sol_contract.dart';
 import '../../../themes/stack_colors.dart';
 import '../../../utilities/amount/amount.dart';
 import '../../../utilities/amount/amount_formatter.dart';
@@ -39,7 +39,7 @@ class WalletInfoRowBalance extends ConsumerWidget {
 
     final Amount totalBalance;
     EthContract? contract;
-    SplToken? splToken;
+    SolContract? splToken;
 
     if (contractAddress == null) {
       totalBalance = info.cachedBalance.total +
@@ -51,7 +51,7 @@ class WalletInfoRowBalance extends ConsumerWidget {
     } else {
       // Check if it's a Solana wallet.
       if (info.coin is Solana) {
-        splToken = MainDB.instance.getSplTokenSync(contractAddress!);
+        splToken = MainDB.instance.getSolContractSync(contractAddress!);
         if (splToken != null) {
           final solanaTokenInfo = ref
               .watch(
diff --git a/lib/widgets/wallet_info_row/wallet_info_row.dart b/lib/widgets/wallet_info_row/wallet_info_row.dart
index 5ea2add..ba2dfa7 100644
--- a/lib/widgets/wallet_info_row/wallet_info_row.dart
+++ b/lib/widgets/wallet_info_row/wallet_info_row.dart
@@ -13,7 +13,6 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 
 import '../../models/isar/models/contract.dart';
 import '../../models/isar/models/ethereum/eth_contract.dart';
-import '../../models/isar/models/solana/spl_token.dart';
 import '../../providers/providers.dart';
 import '../../themes/stack_colors.dart';
 import '../../utilities/text_styles.dart';
@@ -50,13 +49,13 @@ class WalletInfoRow extends ConsumerWidget {
     if (contractAddress != null) {
       if (walletInfo.coin is Solana) {
         // Solana token.
-        final splToken = ref.watch(
+        final solContract = ref.watch(
           mainDBProvider.select(
-            (value) => value.getSplTokenSync(contractAddress!),
+            (value) => value.getSolContractSync(contractAddress!),
           ),
         );
-        contract = splToken;
-        contractName = splToken?.name;
+        contract = solContract;
+        contractName = solContract?.name;
       } else {
         // Ethereum token.
         final ethContract = ref.watch(
diff --git a/test/widget_tests/transaction_card_test.mocks.dart b/test/widget_tests/transaction_card_test.mocks.dart
index aa0c16d..3db3e70 100644
--- a/test/widget_tests/transaction_card_test.mocks.dart
+++ b/test/widget_tests/transaction_card_test.mocks.dart
@@ -1682,42 +1682,44 @@ class MockMainDB extends _i1.Mock implements _i3.MainDB {
           as _i10.Future<void>);
 
   @override
-  _i8.QueryBuilder<_i28.SplToken, _i28.SplToken, _i8.QWhere> getSplTokens() =>
+  _i8.QueryBuilder<_i28.SolContract, _i28.SolContract, _i8.QWhere>
+  getSolContracts() =>
       (super.noSuchMethod(
-            Invocation.method(#getSplTokens, []),
+            Invocation.method(#getSolContracts, []),
             returnValue:
-                _FakeQueryBuilder_7<_i28.SplToken, _i28.SplToken, _i8.QWhere>(
-                  this,
-                  Invocation.method(#getSplTokens, []),
-                ),
+                _FakeQueryBuilder_7<
+                  _i28.SolContract,
+                  _i28.SolContract,
+                  _i8.QWhere
+                >(this, Invocation.method(#getSolContracts, [])),
           )
-          as _i8.QueryBuilder<_i28.SplToken, _i28.SplToken, _i8.QWhere>);
+          as _i8.QueryBuilder<_i28.SolContract, _i28.SolContract, _i8.QWhere>);
 
   @override
-  _i10.Future<_i28.SplToken?> getSplToken(String? tokenMint) =>
+  _i10.Future<_i28.SolContract?> getSolContract(String? tokenMint) =>
       (super.noSuchMethod(
-            Invocation.method(#getSplToken, [tokenMint]),
-            returnValue: _i10.Future<_i28.SplToken?>.value(),
+            Invocation.method(#getSolContract, [tokenMint]),
+            returnValue: _i10.Future<_i28.SolContract?>.value(),
           )
-          as _i10.Future<_i28.SplToken?>);
+          as _i10.Future<_i28.SolContract?>);
 
   @override
-  _i28.SplToken? getSplTokenSync(String? tokenMint) =>
-      (super.noSuchMethod(Invocation.method(#getSplTokenSync, [tokenMint]))
-          as _i28.SplToken?);
+  _i28.SolContract? getSolContractSync(String? tokenMint) =>
+      (super.noSuchMethod(Invocation.method(#getSolContractSync, [tokenMint]))
+          as _i28.SolContract?);
 
   @override
-  _i10.Future<int> putSplToken(_i28.SplToken? token) =>
+  _i10.Future<int> putSolContract(_i28.SolContract? token) =>
       (super.noSuchMethod(
-            Invocation.method(#putSplToken, [token]),
+            Invocation.method(#putSolContract, [token]),
             returnValue: _i10.Future<int>.value(0),
           )
           as _i10.Future<int>);
 
   @override
-  _i10.Future<void> putSplTokens(List<_i28.SplToken>? tokens) =>
+  _i10.Future<void> putSolContracts(List<_i28.SolContract>? tokens) =>
       (super.noSuchMethod(
-            Invocation.method(#putSplTokens, [tokens]),
+            Invocation.method(#putSolContracts, [tokens]),
             returnValue: _i10.Future<void>.value(),
             returnValueForMissingStub: _i10.Future<void>.value(),
           )