REST API
For server-side credential issuance without user presence, resolve the user and store an encrypted credential in DStorage:- Resolve user:
POST /v1/auth/initialize-user - Store encrypted VC:
POST /v1/dstorage/vcs - Sandbox:
https://api.sandbox.mocachain.org/v1 - Production:
https://mocachain-mainnet.api.air3.com/v1
The production endpoint is for approved production partners on Moca Chain private Mainnet. See Production mainnet access before requesting mainnet $MOCA gas tokens.
x-partner-auth header. Full endpoint reference and implementation examples: Issuance API Reference.
- Web
- Flutter
AirService
class AirService {
constructor({ partnerId: string; });
get buildEnv(): BUILD_ENV_TYPE;
get isInitialized(): boolean;
get isLoggedIn(): boolean;
get isWalletInitialized(): boolean;
get provider(): EIP1193Provider;
init({
buildEnv: BUILD_ENV_TYPE;
// Only when buildEnv is PRODUCTION:
credentialNetwork?: "testnet" | "mainnet";
enableLogging: boolean;
skipRehydration: boolean;
preloadWallet: boolean;
preloadCredential: boolean;
sessionConfig?: Partial<AirSessionConfig>;
}): Promise<AirLoginResult | null>;
login(options?: { authToken?: string }): Promise<AirLoginResult>;
isSmartAccountDeployed(): Promise<boolean>;
deploySmartAccount(): Promise<{ txHash: string }>;
getProvider(): EIP1193Provider;
preloadWallet(): Promise<void>;
preloadCredential(): Promise<void>;
setupOrUpdateMfa(): Promise<void>;
getUserInfo(): Promise<AirUserDetails>;
goToPartner(partnerUrl: string): Promise<{ urlWithToken: string }>;
getAccessToken(): Promise<{ token: string }>;
updateSessionConfig(config: Partial<AirSessionConfig>): Promise<AirSessionConfig>;
showSwapUI(options?: {
initialFromToken?: string;
fallbackFromToken?: string;
initialToToken?: string;
defaultSlippage?: number;
}): Promise<{ txHash: `0x${string}` }>;
showOnRampUI(options: {
displayCurrencyCode: string;
targetCurrencyCode?: string;
}): Promise<void>;
showTransferUI(options?: ShowTransferUIOptions): Promise<ShowTransferUIResult>;
showReceiveUI(): Promise<void>;
getAgentKeys(): Promise<AgentPublicKey[]>;
registerAgentKey(publicKey: string): Promise<AgentPublicKey>;
removeAgentKey(id: string): Promise<void>;
startRecovery(payload?: unknown): Promise<void>;
issueCredential({
authToken: string;
issuerDid: string;
credentialId: string;
credentialSubject: Record<string, unknown>;
curve?: "secp256r1" | "secp256k1";
}): Promise<{ cakPublicKey?: string }>;
verifyCredential({
authToken: string;
programId: string;
redirectUrl?: string;
fieldsToDisclose?: "*" | string[];
}): Promise<CredentialVerificationResult>;
logout(): Promise<void>;
cleanUp(): Promise<void>;
on(listener: AirEventListener): void;
off(listener: AirEventListener): void;
clearEventListeners(): void;
}
fieldsToDisclose is documented in Selective Disclosure.Types
export type AirIdDetails = {
id: string;
name?: string;
node: string;
status: "minting" | "minted";
chainId: number;
imageUrl?: string;
};
export type AbstractAccountAddressEntry = {
readonly address: string;
readonly chainIds: readonly string[];
};
export type AirUserDetails = {
partnerId?: string;
partnerUserId?: string;
airId?: AirIdDetails;
user: {
id: string;
abstractAccountAddress?: string;
email?: string;
wallet?: string;
isMFASetup: boolean;
};
};
export type AirInitializationResult = {
rehydrated: boolean;
};
export type AirLoginResult = {
isLoggedIn: boolean;
id: string;
abstractAccountAddress?: string;
abstractAccountAddresses?: readonly AbstractAccountAddressEntry[];
token: string;
isMFASetup: boolean;
};
export type AirWalletInitializedResult = {
abstractAccountAddress: string | null;
isMFASetup: boolean;
};
export type AgentPublicKey = {
id: string;
publicKey: string;
createdAt: string;
};
export type ShowTransferUIOptions = {
tokenSymbol?: string;
chainId?: number;
recipientAddress?: string;
amount?: string;
};
export type ShowTransferUIResult = {
txHash: `0x${string}`;
symbol: string;
chainId: number;
decimals: number;
address: `0x${string}`;
recipientAddress: string;
amount: string;
};
export type CredentialVerificationResult =
| {
status:
| "Non-Compliant"
| "Pending"
| "Revoking"
| "Revoked"
| "Expired"
| "NotFound";
}
| {
status: "Compliant";
zkProofs: Record<string, string>;
transactionHash: string;
cakPrivateKey?: string;
};
export type ClaimAirIdResult = {
airId: AirIdDetails;
};
export type AirEventOnInitialized = {
event: "initialized";
result: AirInitializationResult;
};
export type AirEventOnLoggedIn = {
event: "logged_in";
result: AirLoginResult;
};
export type AirEventOnAirIdMintingStarted = {
event: "air_id_minting_started";
};
export type AirEventOnAirIdMintingFailed = {
event: "air_id_minting_failed";
errorMessage?: string;
};
export type AirEventOnLoggedOut = {
event: "logged_out";
};
export type AirEventOnWalletInitialized = {
event: "wallet_initialized";
result: AirWalletInitializedResult;
};
export type AirEventData =
| AirEventOnInitialized
| AirEventOnLoggedIn
| AirEventOnWalletInitialized
| AirEventOnAirIdMintingStarted
| AirEventOnAirIdMintingFailed
| AirEventOnLoggedOut;
export type AirEventListener = (data: AirEventData) => void;
export type CredentialNetwork = "testnet" | "mainnet";
export type SupportedCurrencyCode = "EUR" | "USD" | "CNY" | "KRW" | "TRY";
export type AirSessionConfig = {
locale: string;
currency: SupportedCurrencyCode;
};
export type ClaimAirIdOptions =
| {
token?: string;
background?: false;
offchain?: boolean;
}
| {
token: string;
background: true;
offchain?: boolean;
};
AirService
class AirService {
Stream<AirEvent> get airEvents;
void on(AirEventListener listener);
void off(AirEventListener listener);
void clearEventListeners();
bool get isInitialized;
Future<void> initialize({
required String partnerId,
Environment env = Environment.production,
required GlobalKey<NavigatorState> navigatorKey,
bool enableLogging = false,
SessionConfig? sessionConfig,
});
Future<LoginResult> login({
String? authToken,
});
Future<LoginResult> rehydrate();
Future<UserInfo> getUserInfo();
Future<SessionConfig> updateSessionConfig({
String? locale,
String? currency,
});
Future<void> preloadWallet();
Future<void> preloadCredential();
Future<CredentialIssuanceResult> issueCredential({
required String authToken,
required String issuerDid,
required String credentialId,
required Map<String, dynamic> credentialSubject,
String? curve,
});
Future<CredentialVerificationResult> verifyCredential({
required String authToken,
required String programId,
String? redirectUrl,
});
Future<String?> getAbstractAccountAddress();
Future<List<String>> getAccounts();
Future<void> setupOrUpdateMfa();
Future<BigInt> getBalance(String address);
Future<EthereumRpcSuccessResponse> call(
String address,
String function,
List<dynamic> params,
String abi,
);
Future<String> signMessage(String message);
Future<String> sendTransaction(Transaction transaction);
Future<EthereumRpcSuccessResponse> sendEthereumRpcRequest(
EthereumRpcRequest request
);
Future<String> deploySmartAccount();
Future<bool> isSmartAccountDeployed();
Future<void> showSwapUi();
Future<void> showOnRampUi({
required String displayCurrencyCode,
String? targetCurrencyCode,
});
Future<void> logout();
void cleanup();
}
Models
enum Environment { staging, uat, sandbox, production }
class SessionConfig {
final String? locale;
final String? currency;
}
class LoginResult {
final bool isLoggedIn;
final String? id;
final String? abstractAccountAddress;
final String? token;
final bool? isMFASetup;
}
enum AirIdStatus {
minting,
minted,
}
class AirId {
final String id;
final String name;
final String node;
final AirIdStatus status;
final int? chainId;
final String? imageUrl;
}
class UserInfo {
final AirId? airId;
final String? partnerUserId;
final String? partnerId;
final User? user;
}
class User {
final String id;
final String? abstractAccountAddress;
final String? email;
final bool isMFASetup;
}
class CredentialIssuanceResult {
final String? cakPublicKey;
}
class EthereumRpcRequest {
final String method;
final List<dynamic> params;
final String? requestId;
}
class EthereumRpcSuccessResponse {
final dynamic response;
}
class AirEvent { }
class AirInitializedEvent extends AirEvent {}
class AirLoggedInEvent extends AirEvent {
final LoginResult payload;
}
class AirLoggedOutEvent extends AirEvent { }
class AirWalletInitializedEvent extends AirEvent { }
typedef AirEventListener = void Function(AirEvent event);
enum ExceptionType {
client,
sdk,
server,
unknown,
}
class AirKitException implements Exception {
final String message;
final ExceptionType type;
}