Send and receive SMS messages using your Android phone programmatically via a simple HTTP API
package tests
import (
"bytes"
"context"
"crypto/rand"
"encoding/json"
"fmt"
"io"
"math/big"
"mime/multipart"
"net/http"
"net/url"
"strings"
"testing"
"time"
httpsms "github.com/NdoleStudio/httpsms-go"
"github.com/golang-jwt/jwt/v5"
"github.com/google/uuid"
"github.com/stretchr/testify/require"
"github.com/wiremock/go-wiremock"
wmJournal "github.com/wiremock/go-wiremock/journal"
)
const (
apiBaseURL = "http://localhost:8000"
wiremockURL = "http://localhost:8080"
wiremockWebhookURL = "http://wiremock.local:8080" // reachable from API container, passes URL validation (needs a dot)
adapterControlURL = "http://localhost:9092"
userAPIKey = "test-user-api-key"
systemAPIKey = "system-user-api-key"
)
type testPhone struct {
PhoneNumber string
PhoneAPIKey string
FcmToken string
}
type adapterTestPhone struct {
testPhone
PhoneID string
GatewayID string
}
type notificationRecord struct {
GatewayID string `json:"gateway_id"`
Data map[string]string `json:"data"`
MessageID string `json:"message_id,omitempty"`
Kind string `json:"kind"`
Processed bool `json:"processed"`
Error string `json:"error,omitempty"`
Authorization string `json:"authorization,omitempty"`
}
func newAPIClient() *httpsms.Client {
return httpsms.New(
httpsms.WithBaseURL(apiBaseURL),
httpsms.WithAPIKey(userAPIKey),
)
}
func newPhoneClient(phoneAPIKey string) *httpsms.Client {
return httpsms.New(
httpsms.WithBaseURL(apiBaseURL),
httpsms.WithAPIKey(phoneAPIKey),
)
}
func newWireMockClient() *wiremock.Client {
return wiremock.NewClient(wiremockURL)
}
func randomPhoneNumber() string {
n, err := rand.Int(rand.Reader, big.NewInt(10000))
if err != nil {
return "+18005550000"
}
return fmt.Sprintf("+1800555%04d", n.Int64())
}
func randomEncryptionKey() string {
b := make([]byte, 16)
_, err := rand.Read(b)
if err != nil {
return uuid.New().String()
}
return fmt.Sprintf("%x", b)
}
func setupPhone(ctx context.Context, t *testing.T, messagesPerMinute uint) testPhone {
t.Helper()
phoneNumber := randomPhoneNumber()
fcmToken := "fcm-" + uuid.New().String()
client := newAPIClient()
// Create the phone API key first so that a few seconds pass (during phone upsert)
// before we use it, giving the cache time to clear.
apiKeyResp, resp, err := client.PhoneAPIKeys.Store(ctx, &httpsms.PhoneAPIKeyStoreParams{
Name: "test-key-" + uuid.New().String(),
})
require.NoError(t, err)
require.Equal(t, http.StatusOK, resp.HTTPResponse.StatusCode, "phone api key store failed")
phoneAPIKeyValue := apiKeyResp.Data.APIKey
require.NotEmpty(t, phoneAPIKeyValue)
_, resp, err = client.Phones.Upsert(ctx, &httpsms.PhoneUpsertParams{
PhoneNumber: phoneNumber,
FcmToken: fcmToken,
MessagesPerMinute: messagesPerMinute,
MaxSendAttempts: 2,
MessageExpirationSeconds: 600,
SIM: "SIM1",
})
require.NoError(t, err)
require.Equal(t, http.StatusOK, resp.HTTPResponse.StatusCode, "phone upsert failed")
phoneClient := newPhoneClient(phoneAPIKeyValue)
_, resp, err = phoneClient.Phones.UpsertFCMToken(ctx, &httpsms.PhoneFCMTokenParams{
PhoneNumber: phoneNumber,
FcmToken: fcmToken,
SIM: "SIM1",
})
require.NoError(t, err)
require.Equal(t, http.StatusOK, resp.HTTPResponse.StatusCode, "fcm token bind failed")
waitForPhoneAuthorization(ctx, t, phoneAPIKeyValue, phoneNumber, 20*time.Second)
return testPhone{
PhoneNumber: phoneNumber,
PhoneAPIKey: phoneAPIKeyValue,
FcmToken: fcmToken,
}
}
func setupAdapterPhone(ctx context.Context, t *testing.T, messagesPerMinute uint) adapterTestPhone {
t.Helper()
gatewayID := uuid.NewString()
phoneNumber := randomPhoneNumber()
client := newAPIClient()
apiKeyResponse, response, err := client.PhoneAPIKeys.Store(ctx, &httpsms.PhoneAPIKeyStoreParams{
Name: "adapter-test-key-" + uuid.NewString(),
})
require.NoError(t, err)
require.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode, "phone api key store failed")
phoneAPIKey := apiKeyResponse.Data.APIKey
require.NotEmpty(t, phoneAPIKey)
// Upsert the phone first so its ID is known before the adapter emulator is registered:
// the API signs notification requests with a JWT keyed by the phone ID, and the emulator
// needs that ID up front to validate the JWT on every notification it receives.
callbackURL := fmt.Sprintf("https://adapter-emulator:9091/notifications/%s", gatewayID)
phoneResponse, response, err := client.Phones.Upsert(ctx, &httpsms.PhoneUpsertParams{
PhoneNumber: phoneNumber,
FcmToken: callbackURL,
MessagesPerMinute: messagesPerMinute,
MaxSendAttempts: 2,
MessageExpirationSeconds: 600,
SIM: "SIM1",
})
require.NoError(t, err)
require.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode, "phone upsert failed")
require.NotEmpty(t, phoneResponse.Data.ID)
registrationBody, err := json.Marshal(map[string]any{
"phone_number": phoneNumber,
"phone_api_key": phoneAPIKey,
"phone_id": phoneResponse.Data.ID,
})
require.NoError(t, err)
registrationRequest, err := http.NewRequestWithContext(
ctx,
http.MethodPut,
fmt.Sprintf("%s/test/gateways/%s", adapterControlURL, gatewayID),
bytes.NewReader(registrationBody),
)
require.NoError(t, err)
registrationRequest.Header.Set("Content-Type", "application/json")
registrationResponse, err := http.DefaultClient.Do(registrationRequest)
require.NoError(t, err)
registrationResponseBody, err := io.ReadAll(registrationResponse.Body)
registrationResponse.Body.Close()
require.NoError(t, err)
require.Equal(
t,
http.StatusNoContent,
registrationResponse.StatusCode,
"adapter gateway registration failed: %s",
string(registrationResponseBody),
)
phoneClient := newPhoneClient(phoneAPIKey)
_, response, err = phoneClient.Phones.UpsertFCMToken(ctx, &httpsms.PhoneFCMTokenParams{
PhoneNumber: phoneNumber,
FcmToken: callbackURL,
SIM: "SIM1",
})
require.NoError(t, err)
require.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode, "adapter callback bind failed")
waitForPhoneAuthorization(ctx, t, phoneAPIKey, phoneNumber, 20*time.Second)
return adapterTestPhone{
testPhone: testPhone{
PhoneNumber: phoneNumber,
PhoneAPIKey: phoneAPIKey,
FcmToken: callbackURL,
},
PhoneID: phoneResponse.Data.ID,
GatewayID: gatewayID,
}
}
func dispatchInternalEvent(ctx context.Context, t *testing.T, event map[string]any) {
t.Helper()
body, err := json.Marshal(event)
require.NoError(t, err)
request, err := http.NewRequestWithContext(ctx, http.MethodPost, apiBaseURL+"/v1/events", bytes.NewReader(body))
require.NoError(t, err)
request.Header.Set("Content-Type", "application/json")
request.Header.Set("x-api-key", systemAPIKey)
response, err := http.DefaultClient.Do(request)
require.NoError(t, err)
defer response.Body.Close()
responseBody, err := io.ReadAll(response.Body)
require.NoError(t, err)
require.Equal(t, http.StatusNoContent, response.StatusCode, "event dispatch failed: %s", string(responseBody))
}
func waitForAdapterMessageRecords(
t *testing.T,
gatewayID string,
messageID string,
timeout time.Duration,
) []notificationRecord {
t.Helper()
deadline := time.Now().Add(timeout)
var records []notificationRecord
var lastErr error
for time.Now().Before(deadline) {
records, lastErr = fetchAdapterNotificationRecords(gatewayID, messageID)
if lastErr == nil && len(records) > 0 && adapterRecordsProcessed(records) {
return records
}
time.Sleep(500 * time.Millisecond)
}
require.NoError(t, lastErr)
require.NotEmpty(t, records, "adapter message record for %s was not available within %v", messageID, timeout)
require.True(t, adapterRecordsProcessed(records), "adapter message records were not processed: %#v", records)
return records
}
func waitForAdapterHeartbeatRecord(
t *testing.T,
gatewayID string,
timeout time.Duration,
) notificationRecord {
t.Helper()
deadline := time.Now().Add(timeout)
var lastErr error
for time.Now().Before(deadline) {
records, err := fetchAdapterNotificationRecords(gatewayID, "")
lastErr = err
if err == nil {
for _, record := range records {
if record.Kind == "heartbeat" && record.Processed {
return record
}
}
}
time.Sleep(500 * time.Millisecond)
}
require.NoError(t, lastErr)
t.Fatalf("processed adapter heartbeat record was not available within %v", timeout)
return notificationRecord{}
}
func triggerAdapterIncoming(
ctx context.Context,
t *testing.T,
phone adapterTestPhone,
contact string,
content string,
) string {
t.Helper()
body, err := json.Marshal(map[string]any{
"contact": contact,
"content": content,
"encrypted": false,
})
require.NoError(t, err)
request, err := http.NewRequestWithContext(
ctx,
http.MethodPost,
fmt.Sprintf("%s/test/gateways/%s/incoming", adapterControlURL, phone.GatewayID),
bytes.NewReader(body),
)
require.NoError(t, err)
request.Header.Set("Content-Type", "application/json")
response, err := http.DefaultClient.Do(request)
require.NoError(t, err)
defer response.Body.Close()
responseBody, err := io.ReadAll(response.Body)
require.NoError(t, err)
require.Equal(t, http.StatusOK, response.StatusCode, "adapter incoming trigger failed: %s", string(responseBody))
var result struct {
Data struct {
ID string `json:"id"`
} `json:"data"`
}
require.NoError(t, json.Unmarshal(responseBody, &result))
require.NotEmpty(t, result.Data.ID)
return result.Data.ID
}
func fetchAdapterNotificationRecords(gatewayID string, messageID string) ([]notificationRecord, error) {
endpoint := fmt.Sprintf("%s/test/gateways/%s/notifications", adapterControlURL, gatewayID)
if messageID != "" {
endpoint += "?message_id=" + url.QueryEscape(messageID)
}
response, err := (&http.Client{Timeout: 5 * time.Second}).Get(endpoint)
if err != nil {
return nil, fmt.Errorf("fetch adapter notification records: %w", err)
}
defer response.Body.Close()
responseBody, err := io.ReadAll(response.Body)
if err != nil {
return nil, fmt.Errorf("read adapter notification records: %w", err)
}
if response.StatusCode != http.StatusOK {
return nil, fmt.Errorf("fetch adapter notification records: status %d: %s", response.StatusCode, string(responseBody))
}
var result struct {
Data []notificationRecord `json:"data"`
}
if err := json.Unmarshal(responseBody, &result); err != nil {
return nil, fmt.Errorf("decode adapter notification records: %w", err)
}
return result.Data, nil
}
func adapterRecordsProcessed(records []notificationRecord) bool {
for _, record := range records {
if !record.Processed {
return false
}
}
return true
}
func waitForPhoneAuthorization(
ctx context.Context,
t *testing.T,
phoneAPIKey string,
phoneNumber string,
timeout time.Duration,
) {
t.Helper()
body, err := json.Marshal(map[string]interface{}{
"phone_numbers": []string{phoneNumber},
"charging": true,
})
require.NoError(t, err)
var responseBody []byte
var statusCode int
deadline := time.Now().Add(timeout)
for time.Now().Before(deadline) {
request, requestErr := http.NewRequestWithContext(
ctx,
http.MethodPost,
apiBaseURL+"/v1/heartbeats",
bytes.NewReader(body),
)
require.NoError(t, requestErr)
request.Header.Set("Content-Type", "application/json")
request.Header.Set("x-api-key", phoneAPIKey)
response, requestErr := http.DefaultClient.Do(request)
require.NoError(t, requestErr)
responseBody, requestErr = io.ReadAll(response.Body)
response.Body.Close()
require.NoError(t, requestErr)
statusCode = response.StatusCode
if statusCode == http.StatusCreated {
return
}
if statusCode != http.StatusUnauthorized {
require.Equal(t, http.StatusCreated, statusCode, "phone authorization check failed: %s", string(responseBody))
}
time.Sleep(500 * time.Millisecond)
}
require.Equal(t, http.StatusCreated, statusCode, "phone authorization was not ready within %v: %s", timeout, string(responseBody))
}
func setupWebhook(ctx context.Context, t *testing.T, phoneNumber string, events []string) (signingKey string, webhookPath string) {
t.Helper()
signingKey = randomEncryptionKey()
webhookPath = "/webhooks/" + uuid.New().String()
webhookURL := wiremockWebhookURL + webhookPath
client := newAPIClient()
_, resp, err := client.Webhooks.Store(ctx, &httpsms.WebhookStoreParams{
SigningKey: signingKey,
URL: webhookURL,
PhoneNumbers: []string{phoneNumber},
Events: events,
})
require.NoError(t, err)
require.Equal(t, http.StatusCreated, resp.HTTPResponse.StatusCode, "webhook store failed")
return signingKey, webhookPath
}
func fireEvent(ctx context.Context, t *testing.T, phoneAPIKey string, messageID string, eventName string) {
t.Helper()
url := fmt.Sprintf("%s/v1/messages/%s/events", apiBaseURL, messageID)
payload := map[string]interface{}{
"event_name": eventName,
"timestamp": time.Now().UTC().Format(time.RFC3339),
}
body, err := json.Marshal(payload)
require.NoError(t, err)
req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
require.NoError(t, err)
req.Header.Set("Content-Type", "application/json")
req.Header.Set("x-api-key", phoneAPIKey)
resp, err := http.DefaultClient.Do(req)
require.NoError(t, err)
defer resp.Body.Close()
respBody, err := io.ReadAll(resp.Body)
require.NoError(t, err)
require.Equal(t, http.StatusOK, resp.StatusCode, "fire event %s failed: %s", eventName, string(respBody))
}
func pollMessageStatus(ctx context.Context, t *testing.T, messageID string, targetStatus string, timeout time.Duration) httpsms.Message {
t.Helper()
deadline := time.Now().Add(timeout)
lastStatus := "not observed"
for time.Now().Before(deadline) {
url := fmt.Sprintf("%s/v1/messages/%s", apiBaseURL, messageID)
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
if err == nil {
req.Header.Set("x-api-key", userAPIKey)
req.Header.Set("Content-Type", "application/json")
resp, err := http.DefaultClient.Do(req)
if err == nil {
body, readErr := io.ReadAll(resp.Body)
resp.Body.Close()
if readErr == nil && resp.StatusCode == http.StatusOK {
var result httpsms.MessageResponse
if json.Unmarshal(body, &result) == nil {
lastStatus = result.Data.Status
if result.Data.Status == targetStatus {
return result.Data
}
}
}
}
}
time.Sleep(500 * time.Millisecond)
}
t.Fatalf("message %s did not reach status %q within %v (last observed status: %q)", messageID, targetStatus, timeout, lastStatus)
return httpsms.Message{}
}
func fetchOutstandingMessage(ctx context.Context, t *testing.T, phoneAPIKey string, messageID string) map[string]interface{} {
t.Helper()
url := fmt.Sprintf("%s/v1/messages/outstanding?message_id=%s", apiBaseURL, messageID)
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
require.NoError(t, err)
req.Header.Set("x-api-key", phoneAPIKey)
resp, err := http.DefaultClient.Do(req)
require.NoError(t, err)
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
require.NoError(t, err)
require.Equal(t, http.StatusOK, resp.StatusCode, "outstanding: %s", string(body))
var result map[string]interface{}
require.NoError(t, json.Unmarshal(body, &result))
data, ok := result["data"].(map[string]interface{})
require.True(t, ok, "no data in outstanding response")
return data
}
func findFCMRequests(t *testing.T, messageID string) []wmJournal.GetRequestResponse {
t.Helper()
wm := newWireMockClient()
allReqs, err := wm.GetAllRequests()
require.NoError(t, err)
var matched []wmJournal.GetRequestResponse
for _, req := range allReqs.Requests {
if strings.Contains(req.Request.URL, "/messages:send") || strings.Contains(req.Request.AbsoluteURL, "/messages:send") {
if strings.Contains(req.Request.Body, messageID) {
matched = append(matched, req)
}
}
}
return matched
}
func findWebhookRequests(t *testing.T, webhookPath string) []wmJournal.GetRequestResponse {
t.Helper()
wm := newWireMockClient()
allReqs, err := wm.GetAllRequests()
require.NoError(t, err)
var matched []wmJournal.GetRequestResponse
for _, req := range allReqs.Requests {
if strings.Contains(req.Request.URL, webhookPath) || strings.Contains(req.Request.AbsoluteURL, webhookPath) {
matched = append(matched, req)
}
}
return matched
}
func assertWebhookJWT(t *testing.T, request wmJournal.Request, signingKey string) {
t.Helper()
authHeader := request.Headers["Authorization"]
if authHeader == "" {
authHeader = request.Headers["authorization"]
}
require.NotEmpty(t, authHeader, "webhook request missing Authorization header")
require.True(t, strings.HasPrefix(authHeader, "Bearer "), "Authorization header must start with Bearer")
tokenString := strings.TrimPrefix(authHeader, "Bearer ")
token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
require.Equal(t, jwt.SigningMethodHS256, token.Method, "unexpected signing method")
return []byte(signingKey), nil
})
require.NoError(t, err, "JWT validation failed")
require.True(t, token.Valid, "JWT token is not valid")
claims, ok := token.Claims.(jwt.MapClaims)
require.True(t, ok, "cannot parse claims")
require.Equal(t, "api.httpsms.com", claims["iss"], "issuer mismatch")
require.NotEmpty(t, claims["sub"], "subject mismatch")
exp, err := claims.GetExpirationTime()
require.NoError(t, err)
require.True(t, exp.After(time.Now()), "token is expired")
nbf, err := claims.GetNotBefore()
require.NoError(t, err)
require.True(t, nbf.Before(time.Now()), "token not yet valid")
}
// assertAdapterNotificationJWT validates the JWT the API signs adapter notification requests
// with, using the receiving phone's ID as the HMAC-SHA256 secret (see
// api/pkg/services/http_notification_sender.go getAuthToken). The phone ID is only used as the
// secret and is never embedded in a claim, so this only checks the signature and issuer, not a
// subject; the adapter emulator itself rejects notifications with an invalid signature (401).
func assertAdapterNotificationJWT(t *testing.T, record notificationRecord, phoneID string) {
t.Helper()
require.NotEmpty(t, record.Authorization, "adapter notification record missing Authorization header")
require.True(t, strings.HasPrefix(record.Authorization, "Bearer "), "Authorization header must start with Bearer")
tokenString := strings.TrimPrefix(record.Authorization, "Bearer ")
token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
require.Equal(t, jwt.SigningMethodHS256, token.Method, "unexpected signing method")
return []byte(phoneID), nil
})
require.NoError(t, err, "JWT validation failed")
require.True(t, token.Valid, "JWT token is not valid")
claims, ok := token.Claims.(jwt.MapClaims)
require.True(t, ok, "cannot parse claims")
require.Equal(t, "api.httpsms.com", claims["iss"], "issuer mismatch")
require.Empty(t, claims["sub"], "phone ID must not be embedded in a claim since it is also the signing secret")
exp, err := claims.GetExpirationTime()
require.NoError(t, err)
require.True(t, exp.After(time.Now()), "token is expired")
nbf, err := claims.GetNotBefore()
require.NoError(t, err)
require.True(t, nbf.Before(time.Now()), "token not yet valid")
}
func waitForWebhookEvents(t *testing.T, webhookPath string, expectedCount int, timeout time.Duration) []wmJournal.GetRequestResponse {
t.Helper()
deadline := time.Now().Add(timeout)
for time.Now().Before(deadline) {
requests := findWebhookRequests(t, webhookPath)
if len(requests) >= expectedCount {
return requests
}
time.Sleep(500 * time.Millisecond)
}
requests := findWebhookRequests(t, webhookPath)
require.GreaterOrEqual(t, len(requests), expectedCount, "expected at least %d webhook events on %s, got %d", expectedCount, webhookPath, len(requests))
return requests
}
func waitForFCMPush(t *testing.T, messageID string, timeout time.Duration) []wmJournal.GetRequestResponse {
t.Helper()
deadline := time.Now().Add(timeout)
for time.Now().Before(deadline) {
requests := findFCMRequests(t, messageID)
if len(requests) >= 1 {
return requests
}
time.Sleep(500 * time.Millisecond)
}
t.Fatalf("FCM push for message %s not found within %v", messageID, timeout)
return nil
}
type BulkMessageEntry struct {
RequestID string `json:"request_id"`
Total int `json:"total"`
ScheduledCount int `json:"scheduled_count"`
PendingCount int `json:"pending_count"`
FailedCount int `json:"failed_count"`
ExpiredCount int `json:"expired_count"`
SentCount int `json:"sent_count"`
DeliveredCount int `json:"delivered_count"`
CreatedAt string `json:"created_at"`
}
func uploadBulkFile(ctx context.Context, t *testing.T, filename string, fileBytes []byte) (int, []byte) {
t.Helper()
var buf bytes.Buffer
writer := multipart.NewWriter(&buf)
part, err := writer.CreateFormFile("document", filename)
require.NoError(t, err)
_, err = part.Write(fileBytes)
require.NoError(t, err)
require.NoError(t, writer.Close())
url := apiBaseURL + "/v1/bulk-messages"
req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, &buf)
require.NoError(t, err)
req.Header.Set("Content-Type", writer.FormDataContentType())
req.Header.Set("x-api-key", userAPIKey)
resp, err := http.DefaultClient.Do(req)
require.NoError(t, err)
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
require.NoError(t, err)
return resp.StatusCode, body
}
func fetchBulkMessages(ctx context.Context, t *testing.T) []BulkMessageEntry {
t.Helper()
url := apiBaseURL + "/v1/bulk-messages"
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
require.NoError(t, err)
req.Header.Set("x-api-key", userAPIKey)
resp, err := http.DefaultClient.Do(req)
require.NoError(t, err)
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
require.NoError(t, err)
require.Equal(t, http.StatusOK, resp.StatusCode, "fetch bulk messages failed: %s", string(body))
var result struct {
Data []BulkMessageEntry `json:"data"`
}
require.NoError(t, json.Unmarshal(body, &result))
return result.Data
}
func searchMessages(ctx context.Context, t *testing.T, contact string, owner string) []httpsms.Message {
t.Helper()
url := fmt.Sprintf("%s/v1/messages?contact=%s&owner=%s&limit=20&skip=0", apiBaseURL, contact, owner)
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
require.NoError(t, err)
req.Header.Set("x-api-key", userAPIKey)
resp, err := http.DefaultClient.Do(req)
require.NoError(t, err)
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
require.NoError(t, err)
require.Equal(t, http.StatusOK, resp.StatusCode, "search messages failed: %s", string(body))
var result struct {
Data []httpsms.Message `json:"data"`
}
require.NoError(t, json.Unmarshal(body, &result))
return result.Data
}
func findBulkEntry(entries []BulkMessageEntry, requestID string) *BulkMessageEntry {
for i := range entries {
if entries[i].RequestID == requestID {
return &entries[i]
}
}
return nil
}