socket-function 1.1.49 → 1.2.0

package/time/trueTimeShim.d.ts

@@ -15,28 +15,13 @@ export declare function getTimeComponentsDetailed(): {
     fromTime: number;
     toTime: number;
 };
-export declare function computeTweenedOffset(components: {
-    systemTime: number;
-    fromOffset: number;
-    toOffset: number;
-    fromTime: number;
-}): number;
 export declare function getTimeComponents(): {
     systemTime: number;
     offset: number;
 };
 export declare function getTrueTime(): number;
 export declare function getTrueTimeOffset(): number;
-export type TrueTimeProof = {
-    systemTime: number;
-    fromOffset: number;
-    toOffset: number;
-    fromTime: number;
-    toTime: number;
-    offset: number;
-    measurement?: TimeOffsetProof;
-};
-export declare function getTrueTimeProof(): TrueTimeProof | undefined;
+export declare function getTrueTimeProof(): TimeOffsetProof | undefined;
 export declare function waitForFirstTimeSync(): Promise<void> | undefined;
 declare global {
     var TRUE_TIME_ALREADY_SHIMMED: boolean;

package/time/trueTimeShim.ts

@@ -22,9 +22,6 @@ const NTP_TIMEOUT = 1000 * 10;
 //      the real time to catch up with it.
 const MINIMUM_TIME_RATE = 0.5;
 
-// The offset tweens toward its target at this fraction of elapsed real time, then plateaus once it gets there. Must stay below 1 so output time keeps moving forward even while the offset is shrinking. Tweening across the whole transition window instead would mean a badly-off clock (many seconds) takes the entire window to converge, which breaks transactional consistency with other machines.
-const OFFSET_TWEEN_RATE = 0.5;
-
 const THROW_ON_ERROR = false;
 
 // Hugely important as if we don't synchronize between processes, it means our logs are going to be confusing and out of order.
@@ -141,24 +138,13 @@ export function getTimeComponentsDetailed(): {
     }
 }
 
-export function computeTweenedOffset(components: {
-    systemTime: number;
-    fromOffset: number;
-    toOffset: number;
-    fromTime: number;
-}): number {
-    const elapsed = Math.max(0, components.systemTime - components.fromTime);
-    const delta = components.toOffset - components.fromOffset;
-    const maxChange = elapsed * OFFSET_TWEEN_RATE;
-    if (Math.abs(delta) <= maxChange) {
-        return components.toOffset;
-    }
-    return components.fromOffset + Math.sign(delta) * maxChange;
-}
-
 export function getTimeComponents(): { systemTime: number; offset: number } {
     const detailed = getTimeComponentsDetailed();
-    return { systemTime: detailed.systemTime, offset: computeTweenedOffset(detailed) };
+    const elapsed = detailed.systemTime - detailed.fromTime;
+    const duration = detailed.toTime - detailed.fromTime;
+    const fraction = duration > 0 ? Math.min(1, elapsed / duration) : 0;
+    const offset = detailed.fromOffset + (detailed.toOffset - detailed.fromOffset) * fraction;
+    return { systemTime: detailed.systemTime, offset };
 }
 
 export function getTrueTime() {
@@ -188,30 +174,8 @@ export function getTrueTimeOffset() {
     const { offset } = getTimeComponents();
     return offset;
 }
-export type TrueTimeProof = {
-    systemTime: number;
-    // The tween endpoints the current offset is moving between. When offset !== toOffset we are still converging.
-    fromOffset: number;
-    toOffset: number;
-    fromTime: number;
-    toTime: number;
-    offset: number;
-    // The raw measurement that produced the newest offset. Undefined if the offset came from a caller-provided base that only returns numbers.
-    measurement?: TimeOffsetProof;
-};
-export function getTrueTimeProof(): TrueTimeProof | undefined {
-    const data = cachedTimeOffsetData;
-    if (!data) return undefined;
-    const detailed = getTimeComponentsDetailed();
-    return {
-        systemTime: detailed.systemTime,
-        fromOffset: detailed.fromOffset,
-        toOffset: detailed.toOffset,
-        fromTime: detailed.fromTime,
-        toTime: detailed.toTime,
-        offset: computeTweenedOffset(detailed),
-        measurement: data.proof,
-    };
+export function getTrueTimeProof(): TimeOffsetProof | undefined {
+    return cachedTimeOffsetData?.proof;
 }
 export function waitForFirstTimeSync(): Promise<void> | undefined {
     if (didFirstTimeSync) return undefined;