@inno-isw/react-native-rtp 0.1.0 → 0.3.0

package/src/client.ts

@@ -5,12 +5,15 @@ import {
   findValidationErrors,
   isExpired,
   isRtpPayload,
+  mergeRequest,
+  toRequestPatch,
   toRtpRequest,
 } from './validate';
 import type {
   RtpClient,
   RtpClientOptions,
   RtpCredential,
+  RtpPayload,
   RtpReceiveOutcome,
   RtpRequest,
   RtpResult,
@@ -21,36 +24,118 @@ interface Entry {
   status: RtpStatus;
 }
 
+/** Statuses after which a request is finished with. */
+const TERMINAL_STATUSES: ReadonlySet<RtpStatus> = new Set([
+  RTP_STATUS.ACCEPTED,
+  RTP_STATUS.DECLINED,
+  RTP_STATUS.EXPIRED,
+  RTP_STATUS.FAILED,
+]);
+
+/**
+ * Map a backend status string onto the normalized SDK status.
+ *
+ * Unknown values are deliberately **not** treated as success — they map to
+ * `undefined` so the caller can decide, rather than silently reporting an
+ * approved payment for a status the client does not understand.
+ */
+export function normalizeBackendStatus(raw: unknown): RtpStatus | undefined {
+  if (typeof raw !== 'string') {
+    return undefined;
+  }
+  switch (raw.toUpperCase()) {
+    case 'ACCEPTED':
+    case 'APPROVED':
+    case 'SUCCESS':
+    case 'SUCCESSFUL':
+      return RTP_STATUS.ACCEPTED;
+    case 'DECLINED':
+    case 'USER_DECLINED':
+      return RTP_STATUS.DECLINED;
+    case 'EXPIRED':
+      return RTP_STATUS.EXPIRED;
+    case 'PENDING':
+    case 'PROCESSING':
+      return RTP_STATUS.PENDING;
+    case 'FAILED':
+    case 'REJECTED':
+      return RTP_STATUS.FAILED;
+    default:
+      return undefined;
+  }
+}
+
 /**
  * Create a portable Request-to-Pay client.
  *
  * The client owns validation, de-duplication, expiry, status computation and
- * the accept/decline/status calls. It owns no UI, no navigation and no crypto.
- * Every external effect is injected so the same contract can be re-implemented
- * on other platforms.
+ * the accept/decline/retrieve calls. It owns no UI, no navigation and no
+ * crypto. Every external effect is injected so the same contract can be
+ * re-implemented on other platforms.
  */
 export function createRtpClient(options: RtpClientOptions): RtpClient {
   const {
     transport,
-    getAuthHeaders = async () => ({}),
     getCurrentUser = () => null,
     now = defaultNow,
     logger = noopLogger,
     basePath = '/rtp',
   } = options;
 
-  if (!transport) {
-    throw new Error('[react-native-rtp] `transport` is required');
-  }
-
   const emitter = createEmitter();
   const entries = new Map<string, Entry>();
 
+  // --- expiry scheduling --------------------------------------------------
+  // Expiry is not only evaluated lazily: an inactive timer fires at `expiresAt`
+  // so a request cannot remain actionable after it has lapsed (INDV-3807/3808).
+  let expiryTimer: ReturnType<typeof setTimeout> | undefined;
+  let expiryTimerId: string | undefined;
+
+  function clearExpiryTimer(): void {
+    if (expiryTimer !== undefined) {
+      clearTimeout(expiryTimer);
+    }
+    expiryTimer = undefined;
+    expiryTimerId = undefined;
+  }
+
+  function scheduleExpiry(entry: Entry): void {
+    clearExpiryTimer();
+
+    const expiry = new Date(entry.request.expiresAt).getTime();
+    if (Number.isNaN(expiry)) {
+      return;
+    }
+
+    const id = entry.request.id;
+    expiryTimerId = id;
+    expiryTimer = setTimeout(
+      () => {
+        const current = entries.get(id);
+        if (!current || TERMINAL_STATUSES.has(current.status)) {
+          return;
+        }
+        logger('[react-native-rtp] request expired:', id);
+        emitResult({ id, status: RTP_STATUS.EXPIRED });
+      },
+      Math.max(0, expiry - now())
+    );
+
+    // Never keep a Node process (e.g. Jest) alive for a pending expiry.
+    const handle = expiryTimer as unknown as { unref?: () => void };
+    if (typeof handle?.unref === 'function') {
+      handle.unref();
+    }
+  }
+
   function setStatus(id: string, status: RtpStatus): void {
     const entry = entries.get(id);
     if (entry) {
       entry.status = status;
     }
+    if (TERMINAL_STATUSES.has(status) && expiryTimerId === id) {
+      clearExpiryTimer();
+    }
     emitter.emit(RTP_EVENT.STATE, { id, status });
   }
 
@@ -89,7 +174,8 @@ export function createRtpClient(options: RtpClientOptions): RtpClient {
     }
 
     const request = toRtpRequest(payload);
-    entries.set(id, { request, status: RTP_STATUS.RECEIVED });
+    const entry: Entry = { request, status: RTP_STATUS.RECEIVED };
+    entries.set(id, entry);
 
     if (isExpired(request, now())) {
       const result = emitResult({ id, status: RTP_STATUS.EXPIRED });
@@ -100,6 +186,7 @@ export function createRtpClient(options: RtpClientOptions): RtpClient {
 
     if (!currentUser) {
       setStatus(id, RTP_STATUS.AWAITING_AUTH);
+      scheduleExpiry(entry);
       return { handled: true, request, status: RTP_STATUS.AWAITING_AUTH };
     }
 
@@ -114,10 +201,95 @@ export function createRtpClient(options: RtpClientOptions): RtpClient {
     }
 
     setStatus(id, RTP_STATUS.READY);
+    scheduleExpiry(entry);
     emitter.emit(RTP_EVENT.REQUEST, request);
     return { handled: true, request, status: RTP_STATUS.READY };
   }
 
+  /**
+   * Fetch (or refresh) authorization details for a request from the backend,
+   * and reconcile the backend status. This is the "retrieve details" step the
+   * authorization page needs before it can be trusted (INDV-3804).
+   */
+  async function retrieve(id: string): Promise<RtpResult> {
+    const entry = entries.get(id);
+    if (!entry) {
+      return fail(id, RTP_ERROR.UNKNOWN);
+    }
+
+    if (isExpired(entry.request, now())) {
+      return emitResult({ id, status: RTP_STATUS.EXPIRED });
+    }
+
+    if (TERMINAL_STATUSES.has(entry.status)) {
+      return { id, status: entry.status };
+    }
+
+    // Transport-free mode: there is no backend to fetch from, so the details
+    // already held from the payload are authoritative. This is the shape the
+    // client runs in when the host settles the payment through its own core
+    // banking rather than an RTP backend.
+    if (!transport) {
+      setStatus(id, RTP_STATUS.READY);
+      scheduleExpiry(entry);
+      emitter.emit(RTP_EVENT.REQUEST, entry.request);
+      return { id, status: RTP_STATUS.READY };
+    }
+
+    setStatus(id, RTP_STATUS.RETRIEVING);
+
+    try {
+      const headers = {};
+      const res = await transport.get(`${basePath}/${id}`, headers);
+      const data = (res?.data ?? {}) as Record<string, unknown>;
+
+      const mapped = normalizeBackendStatus(data.status);
+
+      if (
+        mapped === RTP_STATUS.EXPIRED ||
+        mapped === RTP_STATUS.DECLINED ||
+        mapped === RTP_STATUS.FAILED
+      ) {
+        return emitResult({
+          id,
+          status: mapped,
+          data,
+          error:
+            mapped === RTP_STATUS.FAILED
+              ? RTP_ERROR.BACKEND_REJECTED
+              : undefined,
+        });
+      }
+
+      if (mapped === RTP_STATUS.ACCEPTED) {
+        return emitResult({ id, status: RTP_STATUS.ACCEPTED, data });
+      }
+
+      if (mapped === RTP_STATUS.PENDING) {
+        return emitResult({ id, status: RTP_STATUS.PENDING, data });
+      }
+
+      // Merge any returned details (a full payload, or nested under `request`).
+      const incoming = (data.request ?? data) as
+        Partial<RtpPayload> | undefined;
+      if (incoming && typeof incoming === 'object') {
+        entry.request = mergeRequest(entry.request, toRequestPatch(incoming));
+      }
+
+      if (isExpired(entry.request, now())) {
+        return emitResult({ id, status: RTP_STATUS.EXPIRED });
+      }
+
+      setStatus(id, RTP_STATUS.READY);
+      scheduleExpiry(entry);
+      emitter.emit(RTP_EVENT.REQUEST, entry.request);
+      return { id, status: RTP_STATUS.READY, data };
+    } catch (err) {
+      logger('[react-native-rtp] retrieve failed:', err);
+      return fail(id, RTP_ERROR.RETRIEVE_FAILED);
+    }
+  }
+
   /**
    * Called by the host after a successful login to release any requests that
    * were waiting on the auth gate.
@@ -149,6 +321,7 @@ export function createRtpClient(options: RtpClientOptions): RtpClient {
       }
 
       setStatus(id, RTP_STATUS.READY);
+      scheduleExpiry(entry);
       emitter.emit(RTP_EVENT.REQUEST, entry.request);
     }
   }
@@ -169,25 +342,35 @@ export function createRtpClient(options: RtpClientOptions): RtpClient {
 
     setStatus(id, RTP_STATUS.PROCESSING);
 
+    // Transport-free mode: acceptance is realised by the host's own payment
+    // flow; the client only records the decision locally.
+    if (!transport) {
+      return emitResult({ id, status: RTP_STATUS.ACCEPTED });
+    }
+
     try {
-      const headers = await getAuthHeaders();
+      const headers = {};
       const res = await transport.post(
         `${basePath}/${id}/accept`,
         { credential },
         headers
       );
-      const backendStatus = res?.data?.status;
-      const status: RtpStatus =
-        backendStatus === 'DECLINED'
-          ? RTP_STATUS.DECLINED
-          : backendStatus === 'FAILED'
-            ? RTP_STATUS.FAILED
-            : RTP_STATUS.ACCEPTED;
+      const data = (res?.data ?? {}) as Record<string, unknown>;
+
+      // If the backend returned a status we recognise, honour it. If it
+      // returned no status at all, the accept call itself succeeded. If it
+      // returned a status we do NOT understand, fail closed rather than
+      // showing the customer an approved payment we cannot vouch for.
+      const hasStatus = data.status !== undefined && data.status !== null;
+      const mapped = normalizeBackendStatus(data.status);
+      const status: RtpStatus = hasStatus
+        ? (mapped ?? RTP_STATUS.FAILED)
+        : RTP_STATUS.ACCEPTED;
 
       return emitResult({
         id,
         status,
-        data: res?.data,
+        data,
         error:
           status === RTP_STATUS.FAILED ? RTP_ERROR.BACKEND_REJECTED : undefined,
       });
@@ -209,14 +392,34 @@ export function createRtpClient(options: RtpClientOptions): RtpClient {
 
     setStatus(id, RTP_STATUS.PROCESSING);
 
+    // Transport-free mode: the decline is recorded locally; a host with a
+    // backend still posts it through `transport`.
+    if (!transport) {
+      return emitResult({ id, status: RTP_STATUS.DECLINED });
+    }
+
     try {
-      const headers = await getAuthHeaders();
+      const headers = {};
       const res = await transport.post(
         `${basePath}/${id}/decline`,
         { reason },
         headers
       );
-      return emitResult({ id, status: RTP_STATUS.DECLINED, data: res?.data });
+      const data = (res?.data ?? {}) as Record<string, unknown>;
+
+      const mapped = normalizeBackendStatus(data.status);
+      const status: RtpStatus =
+        mapped === RTP_STATUS.EXPIRED || mapped === RTP_STATUS.FAILED
+          ? mapped
+          : RTP_STATUS.DECLINED;
+
+      return emitResult({
+        id,
+        status,
+        data,
+        error:
+          status === RTP_STATUS.FAILED ? RTP_ERROR.BACKEND_REJECTED : undefined,
+      });
     } catch (err) {
       logger('[react-native-rtp] decline failed:', err);
       return fail(id, RTP_ERROR.NETWORK_ERROR);
@@ -226,12 +429,16 @@ export function createRtpClient(options: RtpClientOptions): RtpClient {
   return {
     isRtp: isRtpPayload,
     receive,
+    retrieve,
     resumeAuth,
     accept,
     decline,
     getStatus: (id: string) => entries.get(id)?.status,
     getRequest: (id: string) => entries.get(id)?.request,
     acknowledge: (id: string) => {
+      if (expiryTimerId === id) {
+        clearExpiryTimer();
+      }
       entries.delete(id);
     },
     on: emitter.on,

package/src/constants.ts

@@ -7,6 +7,8 @@
 export const RTP_STATUS = {
   /** Payload arrived and passed validation, but is not yet actionable. */
   RECEIVED: 'RECEIVED',
+  /** Authorization details are being fetched from the backend. */
+  RETRIEVING: 'RETRIEVING',
   /** Expired before it could be actioned. */
   EXPIRED: 'EXPIRED',
   /** Valid, but the user is not authenticated yet (login gate). */
@@ -15,6 +17,8 @@ export const RTP_STATUS = {
   READY: 'READY',
   /** Accept/decline in flight. */
   PROCESSING: 'PROCESSING',
+  /** Backend accepted the action but a final decision is still pending. */
+  PENDING: 'PENDING',
   /** Backend confirmed acceptance. */
   ACCEPTED: 'ACCEPTED',
   /** Backend confirmed (or user initiated) a decline. */
@@ -41,6 +45,7 @@ export type RtpEvent = (typeof RTP_EVENT)[keyof typeof RTP_EVENT];
 export const RTP_ERROR = {
   INVALID_PAYLOAD: 'INVALID_PAYLOAD',
   RECIPIENT_MISMATCH: 'RECIPIENT_MISMATCH',
+  RETRIEVE_FAILED: 'RETRIEVE_FAILED',
   NETWORK_ERROR: 'NETWORK_ERROR',
   BACKEND_REJECTED: 'BACKEND_REJECTED',
   UNKNOWN: 'UNKNOWN',

package/src/index.tsx

@@ -1,11 +1,13 @@
 // Core (platform-agnostic)
-export { createRtpClient } from './client';
+export { createRtpClient, normalizeBackendStatus } from './client';
 export { RTP_STATUS, RTP_EVENT, RTP_ERROR } from './constants';
 export type { RtpStatus, RtpEvent, RtpError } from './constants';
 export {
   isRtpPayload,
   findValidationErrors,
   toRtpRequest,
+  toRequestPatch,
+  mergeRequest,
   isExpired,
 } from './validate';
 export { mapPushToRtp } from './push';

package/src/mock/makeRtpPayload.ts

@@ -41,6 +41,9 @@ export function makeRtpPayload(
     currency: 'NGN',
     narration: 'Payment for invoice 1042',
     transactionRef: `TRX-${from}-${counter}`,
+    orderNumber: `ORD-${from}-${counter}`,
+    deepLink: `quickteller://rtp/${from}-${counter}`,
+    actionMessage: 'Review and approve this payment request',
     recipient: 'john.doe@quickteller.com',
     expiresAt: new Date(from + expiresInMs).toISOString(),
     payer: {

package/src/mock/mockTransport.ts

@@ -7,8 +7,14 @@ export interface MockTransportOptions {
   failAccept?: boolean;
   /** Simulate a network failure on decline. */
   failDecline?: boolean;
+  /** Simulate a network failure on retrieve (details fetch). */
+  failRetrieve?: boolean;
   /** Backend status to return for accept. */
-  acceptStatus?: 'ACCEPTED' | 'DECLINED' | 'FAILED';
+  acceptStatus?: 'ACCEPTED' | 'DECLINED' | 'FAILED' | 'PENDING' | 'EXPIRED';
+  /** Backend status to return for retrieve. Unknown values fall through to READY. */
+  retrieveStatus?: string;
+  /** Request details to return from retrieve (overlaid onto the held request). */
+  retrieveRequest?: Record<string, unknown>;
 }
 
 export interface RecordedCall {
@@ -41,7 +47,10 @@ export function createMockTransport(
     latencyMs = 250,
     failAccept = false,
     failDecline = false,
+    failRetrieve = false,
     acceptStatus = 'ACCEPTED',
+    retrieveStatus = 'READY',
+    retrieveRequest,
   } = options;
 
   const calls: RecordedCall[] = [];
@@ -86,9 +95,16 @@ export function createMockTransport(
     ): Promise<RtpHttpResponse<T>> {
       calls.push({ method: 'get', path, headers });
       await delay();
+      if (failRetrieve) {
+        throw new Error('Mock network failure on retrieve');
+      }
       return {
         status: 200,
-        data: { id: extractId(path), status: 'PENDING' } as T,
+        data: {
+          id: extractId(path),
+          status: retrieveStatus,
+          request: retrieveRequest,
+        } as T,
       };
     },
   };

package/src/react/RtpProvider.tsx

@@ -7,7 +7,13 @@ import React, {
   useRef,
   useState,
 } from 'react';
-import type { RtpClient, RtpCredential, RtpRequest, RtpResult } from '../types';
+import type {
+  RtpClient,
+  RtpCredential,
+  RtpReceiveOutcome,
+  RtpRequest,
+  RtpResult,
+} from '../types';
 import { RTP_STATUS } from '../constants';
 import type { RtpStatus } from '../constants';
 
@@ -46,14 +52,18 @@ export interface RtpContextValue {
   status: RtpStatus | null;
   /** True when a request is ready for the user to act on. */
   isReady: boolean;
+  /** True while authorization details are being fetched from the backend. */
+  isLoading: boolean;
   /** Accept the active request with an opaque credential. */
   accept: (credential?: RtpCredential) => Promise<RtpResult | undefined>;
   /** Decline the active request. */
   decline: (reason?: string) => Promise<RtpResult | undefined>;
+  /** Fetch/refresh authorization details for the active request. */
+  retrieve: (id?: string) => Promise<RtpResult | undefined>;
   /** Dismiss the active request from the UI. */
   dismiss: () => void;
   /** Feed a raw decoded payload into the client (for host push adapters). */
-  receive: (payload: unknown) => void;
+  receive: (payload: unknown) => Promise<RtpReceiveOutcome | undefined>;
   /** Last terminal result, for rendering feedback. */
   lastResult: RtpResult | null;
 }
@@ -79,9 +89,9 @@ export function RtpProvider({
   const activeIdRef = useRef<string | null>(null);
 
   const receive = useCallback(
-    (payload: unknown) => {
+    async (payload: unknown) => {
       onIncomingPayload?.(payload);
-      client.receive(payload);
+      return client.receive(payload);
     },
     [client, onIncomingPayload]
   );
@@ -160,6 +170,17 @@ export function RtpProvider({
     [client, request]
   );
 
+  const retrieve = useCallback(
+    async (id?: string) => {
+      const target = id ?? request?.id ?? activeIdRef.current;
+      if (!target) {
+        return undefined;
+      }
+      return client.retrieve(target);
+    },
+    [client, request]
+  );
+
   const dismiss = useCallback(() => {
     setRequest(null);
     setStatus(null);
@@ -168,19 +189,33 @@ export function RtpProvider({
   }, []);
 
   const isReady = status === RTP_STATUS.READY;
+  const isLoading = status === RTP_STATUS.RETRIEVING;
 
   const value = useMemo<RtpContextValue>(
     () => ({
       request,
       status,
       isReady,
+      isLoading,
       accept,
       decline,
+      retrieve,
       dismiss,
       receive,
       lastResult,
     }),
-    [request, status, isReady, accept, decline, dismiss, receive, lastResult]
+    [
+      request,
+      status,
+      isReady,
+      isLoading,
+      accept,
+      decline,
+      retrieve,
+      dismiss,
+      receive,
+      lastResult,
+    ]
   );
 
   return <RtpContext.Provider value={value}>{children}</RtpContext.Provider>;

package/src/types.ts

@@ -27,6 +27,12 @@ export interface RtpPayload {
   narration?: string;
   /** Backend reference for the transaction. */
   transactionRef?: string;
+  /** Merchant/issuer order number for the request (distinct from transactionRef). */
+  orderNumber?: string;
+  /** Secure transaction / deep-link reference the host can use to open the flow. */
+  deepLink?: string;
+  /** Instruction shown to the customer describing the action required. */
+  actionMessage?: string;
   /** ISO 8601 timestamp after which the request can no longer be actioned. */
   expiresAt: string;
   /** Alias (phone/email) the request is addressed to, for identity matching. */
@@ -40,6 +46,12 @@ export interface RtpParty {
   name: string;
   accountNumber?: string;
   bank?: string;
+  /**
+   * Destination institution code (e.g. a NIP bank code) for the `payee`.
+   * The host uses it to route the resulting transfer to the right bank; the
+   * SDK never interprets it.
+   */
+  bankCode?: string;
   /** Optional display URL for a logo/avatar. */
   logoUrl?: string;
 }
@@ -53,6 +65,9 @@ export interface RtpRequest {
   payee: RtpParty;
   narration?: string;
   transactionRef?: string;
+  orderNumber?: string;
+  deepLink?: string;
+  actionMessage?: string;
   expiresAt: string;
   recipient?: string;
 }
@@ -113,14 +128,13 @@ export interface RtpStorage {
 }
 
 export interface RtpClientOptions {
-  /** Injected HTTP client. */
-  transport: RtpTransport;
   /**
-   * Returns auth headers for an outgoing request. Called per request so the
-   * host can refresh tokens / compute MACs.
+   * Injected HTTP client. Optional: when omitted the client runs
+   * transport-free — it validates and tracks the request but performs no
+   * network calls, which is the shape a host uses when the payment itself is
+   * settled through the host's own core banking rather than an RTP backend.
    */
-  getAuthHeaders?: () =>
-    Promise<Record<string, string>> | Record<string, string>;
+  transport?: RtpTransport;
   /**
    * Returns the currently authenticated user's alias (phone/email), or null
    * when logged out. Used for the auth gate and recipient matching.
@@ -145,6 +159,8 @@ export interface RtpEventMap {
 export interface RtpClient {
   isRtp: (payload: unknown) => payload is RtpPayload;
   receive: (payload: unknown) => Promise<RtpReceiveOutcome>;
+  /** Fetch/refresh authorization details for a request from the backend. */
+  retrieve: (id: string) => Promise<RtpResult>;
   resumeAuth: () => void;
   accept: (params: {
     id: string;

package/src/validate.ts

@@ -78,11 +78,59 @@ export function toRtpRequest(payload: RtpPayload): RtpRequest {
     payee: payload.payee,
     narration: payload.narration,
     transactionRef: payload.transactionRef,
+    orderNumber: payload.orderNumber,
+    deepLink: payload.deepLink,
+    actionMessage: payload.actionMessage,
     expiresAt: payload.expiresAt,
     recipient: payload.recipient,
   };
 }
 
+/**
+ * Build a partial-request patch from an incoming payload, copying only the
+ * fields that are actually present. Used to overlay retrieved backend details
+ * without a partial response erasing data already held from the push.
+ */
+export function toRequestPatch(
+  payload: Partial<RtpPayload>
+): Partial<RtpRequest> {
+  const patch: Partial<RtpRequest> = {};
+  if (payload.rtpId !== undefined) patch.id = payload.rtpId;
+  if (payload.amount !== undefined) patch.amount = toAmount(payload.amount);
+  if (payload.currency !== undefined) patch.currency = payload.currency;
+  if (payload.payer !== undefined) patch.payer = payload.payer;
+  if (payload.payee !== undefined) patch.payee = payload.payee;
+  if (payload.narration !== undefined) patch.narration = payload.narration;
+  if (payload.transactionRef !== undefined)
+    patch.transactionRef = payload.transactionRef;
+  if (payload.orderNumber !== undefined)
+    patch.orderNumber = payload.orderNumber;
+  if (payload.deepLink !== undefined) patch.deepLink = payload.deepLink;
+  if (payload.actionMessage !== undefined)
+    patch.actionMessage = payload.actionMessage;
+  if (payload.expiresAt !== undefined) patch.expiresAt = payload.expiresAt;
+  if (payload.recipient !== undefined) patch.recipient = payload.recipient;
+  return patch;
+}
+
+/**
+ * Overlay a patch onto an existing request. Only defined, non-null values are
+ * copied so a partial response never erases information already held.
+ */
+export function mergeRequest(
+  current: RtpRequest,
+  patch: Partial<RtpRequest>
+): RtpRequest {
+  const next: RtpRequest = { ...current };
+  for (const key of Object.keys(patch) as (keyof RtpRequest)[]) {
+    const value = patch[key];
+    if (value !== undefined && value !== null) {
+      (next as any)[key] = value;
+    }
+  }
+  return next;
+}
+
 /** Pure expiry check. Re-evaluated on every transition, not just on receive. */
 export function isExpired(request: RtpRequest, now: number): boolean {
   const expiry = new Date(request.expiresAt).getTime();