@dimo-network/data-sdk 1.2.1

package/dist/api/Resource.d.ts

@@ -0,0 +1,11 @@
+import { DimoEnvironment } from '../environments';
+export interface Resource {
+    [key: string]: (...args: any) => any;
+}
+export declare class Resource {
+    api: any;
+    resourceName: any;
+    env: any;
+    constructor(api: any, resourceName: string, env: keyof typeof DimoEnvironment);
+    protected setResource(resources: any): void;
+}

package/dist/api/Resource.js

@@ -0,0 +1,20 @@
+import { Method } from './Method';
+export class Resource {
+    api;
+    resourceName;
+    env;
+    constructor(api, resourceName, env) {
+        this.api = api;
+        this.resourceName = resourceName;
+        this.env = env;
+    }
+    setResource(resources) {
+        Object.keys(resources).forEach(key => {
+            this[key] = (params = {}) => Method(resources[key], // Setup the endpoint resources
+            this.api, // Setup the base URL
+            params, // Pass through the params
+            this.env // Identiy the environment
+            );
+        });
+    }
+}

package/dist/api/functions/getToken.d.ts

@@ -0,0 +1,7 @@
+import { DimoEnvironment } from '../../environments';
+export declare const getToken: (input: {
+    client_id: string;
+    domain: string;
+    private_key: string;
+    address: string;
+}, env: keyof typeof DimoEnvironment) => Promise<any>;

package/dist/api/functions/getToken.js

@@ -0,0 +1,20 @@
+import { DIMO } from '../../dimo';
+export const getToken = async (input, env) => {
+    const sdk = new DIMO(env);
+    const challenge = await sdk.auth.generateChallenge({
+        client_id: input.client_id,
+        domain: input.domain,
+        address: input.client_id
+    });
+    const sign = await sdk.auth.signChallenge({
+        message: challenge.challenge,
+        private_key: input.private_key
+    });
+    const submit = await sdk.auth.submitChallenge({
+        client_id: input.client_id,
+        domain: input.domain,
+        state: challenge.state,
+        signature: sign
+    });
+    return submit;
+};

package/dist/api/functions/index.d.ts

@@ -0,0 +1,3 @@
+import { getToken } from "./getToken";
+import { signChallenge } from "./signChallenge";
+export { getToken, signChallenge };

package/dist/api/functions/index.js

@@ -0,0 +1,3 @@
+import { getToken } from "./getToken";
+import { signChallenge } from "./signChallenge";
+export { getToken, signChallenge };

package/dist/api/functions/signChallenge.d.ts

@@ -0,0 +1,5 @@
+import { DimoEnvironment } from '../../environments';
+export declare const signChallenge: (input: {
+    message: string;
+    private_key: string;
+}, env: keyof typeof DimoEnvironment) => Promise<string>;

package/dist/api/functions/signChallenge.js

@@ -0,0 +1,8 @@
+import { Web3 } from 'web3';
+import { DimoConstants } from '../../constants';
+export const signChallenge = async (input, env) => {
+    const web3 = new Web3(DimoConstants[env].RPC_provider);
+    const formatted_key = '0x' + Buffer.from(input.private_key, 'utf8');
+    const response = web3.eth.accounts.sign(input.message, formatted_key);
+    return response.signature;
+};

package/dist/api/index.d.ts

@@ -0,0 +1 @@
+export * from './resources/DimoRestResources';

package/dist/api/index.js

@@ -0,0 +1 @@
+export * from './resources/DimoRestResources';

package/dist/api/resources/Attestation/index.d.ts

@@ -0,0 +1,5 @@
+import { Resource } from '../../Resource';
+import { DimoEnvironment } from '../../../environments';
+export declare class Attestation extends Resource {
+    constructor(api: any, env: keyof typeof DimoEnvironment);
+}

package/dist/api/resources/Attestation/index.js

@@ -0,0 +1,21 @@
+import { Resource } from '../../Resource';
+export class Attestation extends Resource {
+    constructor(api, env) {
+        super(api, 'Attestation', env);
+        this.setResource({
+            createVinVC: {
+                method: 'POST',
+                path: '/v1/vc/vin/:tokenId',
+                auth: 'privilege_token',
+                queryParams: {
+                    'force': true
+                }
+            },
+            createPomVC: {
+                method: 'POST',
+                path: '/v1/vc/pom/:tokenId',
+                auth: 'privilege_token'
+            }
+        });
+    }
+}

package/dist/api/resources/Auth/index.d.ts

@@ -0,0 +1,5 @@
+import { Resource } from '../../Resource';
+import { DimoEnvironment } from '../../../environments';
+export declare class Auth extends Resource {
+    constructor(api: any, env: keyof typeof DimoEnvironment);
+}

package/dist/api/resources/Auth/index.js

@@ -0,0 +1,42 @@
+import { Resource } from '../../Resource';
+export class Auth extends Resource {
+    constructor(api, env) {
+        super(api, 'Auth', env);
+        this.setResource({
+            generateChallenge: {
+                method: 'POST',
+                path: '/auth/web3/generate_challenge',
+                queryParams: {
+                    'client_id': true,
+                    'domain': true,
+                    'scope': 'openid email',
+                    'response_type': 'code',
+                    'address': '$client_id'
+                }
+            },
+            signChallenge: {
+                method: 'FUNCTION',
+                path: 'signChallenge'
+            },
+            submitChallenge: {
+                method: 'POST',
+                path: '/auth/web3/submit_challenge',
+                body: {
+                    'client_id': true,
+                    'domain': true,
+                    'grant_type': 'authorization_code',
+                    'state': true,
+                    'signature': true
+                },
+                headers: {
+                    'content-type': 'application/x-www-form-urlencoded'
+                },
+                return: 'access_token'
+            },
+            getToken: {
+                method: 'FUNCTION',
+                path: 'getToken'
+            }
+        });
+    }
+}

package/dist/api/resources/DeviceDefinitions/index.d.ts

@@ -0,0 +1,5 @@
+import { Resource } from '../../Resource';
+import { DimoEnvironment } from '../../../environments';
+export declare class DeviceDefinitions extends Resource {
+    constructor(api: any, env: keyof typeof DimoEnvironment);
+}

package/dist/api/resources/DeviceDefinitions/index.js

@@ -0,0 +1,29 @@
+import { Resource } from '../../Resource';
+export class DeviceDefinitions extends Resource {
+    constructor(api, env) {
+        super(api, 'DeviceDefinitions', env);
+        this.setResource({
+            getByMMY: {
+                method: 'GET',
+                queryParams: {
+                    'make': true,
+                    'model': true,
+                    'year': true
+                },
+                path: '/device-definitions'
+            },
+            getById: {
+                method: 'GET',
+                path: '/device-definitions/:id'
+            },
+            listDeviceMakes: {
+                method: 'GET',
+                path: '/device-makes'
+            },
+            getDeviceTypeById: {
+                method: 'GET',
+                path: '/device-types/:id'
+            }
+        });
+    }
+}

package/dist/api/resources/Devices/index.d.ts

@@ -0,0 +1,5 @@
+import { Resource } from '../../Resource';
+import { DimoEnvironment } from '../../../environments';
+export declare class Devices extends Resource {
+    constructor(api: any, env: keyof typeof DimoEnvironment);
+}

package/dist/api/resources/Devices/index.js

@@ -0,0 +1,154 @@
+import { Resource } from '../../Resource';
+export class Devices extends Resource {
+    constructor(api, env) {
+        super(api, 'Devices', env);
+        this.setResource({
+            createVehicle: {
+                method: 'POST',
+                path: '/v1/user/devices',
+                body: {
+                    countryCode: true,
+                    deviceDefinitionId: true
+                },
+                auth: 'access_token'
+            },
+            createVehicleFromSmartcar: {
+                method: 'POST',
+                path: '/v1/user/devices/fromsmartcar',
+                body: {
+                    code: true,
+                    countryCode: true,
+                    redirectURI: true
+                },
+                auth: 'access_token'
+            },
+            createVehicleFromVin: {
+                method: 'POST',
+                path: '/v1/user/devices/fromvin',
+                body: {
+                    canProtocol: false,
+                    countryCode: true,
+                    vin: true
+                },
+                auth: 'access_token'
+            },
+            updateVehicleVin: {
+                method: 'PATCH',
+                path: '/v1/user/devices/:userDeviceId/vin',
+                auth: 'access_token'
+            },
+            getClaimingPayload: {
+                method: 'POST',
+                path: '/v1/aftermarket/device/by-serial/:serial/commands/claim',
+                auth: 'access_token'
+            },
+            signClaimingPayload: {
+                method: 'POST',
+                path: '/v1/aftermarket/device/by-serial/:serial/commands/claim',
+                body: {
+                    claimRequest: true
+                },
+                auth: 'access_token'
+            },
+            getMintingPayload: {
+                method: 'POST',
+                path: '/v1/user/devices/:userDeviceId/commands/mint',
+                auth: 'access_token'
+            },
+            signMintingPayload: {
+                method: 'POST',
+                path: '/v1/user/devices/:userDeviceId/commands/mint',
+                body: {
+                    mintRequest: true
+                },
+                auth: 'access_token'
+            },
+            optInShareData: {
+                method: 'POST',
+                path: '/v1/user/devices/:userDeviceId/commands/opt-in',
+                auth: 'access_token'
+            },
+            refreshSmartcarData: {
+                method: 'POST',
+                path: '/v1/user/devices/:userDeviceId/commands/refresh',
+                auth: 'access_token'
+            },
+            getPairingPayload: {
+                method: 'GET',
+                path: '/v1/user/devices/:userDeviceId/aftermarket/commands/pair',
+                auth: 'access_token'
+            },
+            signPairingPayload: {
+                method: 'POST',
+                path: '/v1/user/devices/:userDeviceId/aftermarket/commands/pair',
+                body: {
+                    userSignature: true
+                },
+                auth: 'access_token'
+            },
+            getUnpairingPayload: {
+                method: 'GET',
+                path: '/v1/user/devices/:userDeviceId/aftermarket/commands/unpair',
+                auth: 'access_token'
+            },
+            signUnpairingPayload: {
+                method: 'POST',
+                path: '/v1/user/devices/:userDeviceId/aftermarket/commands/unpair',
+                body: {
+                    userSignature: true
+                },
+                auth: 'access_token'
+            },
+            lockDoors: {
+                method: 'POST',
+                path: '/v1/vehicle/:tokenId/commands/doors/lock',
+                auth: 'privilege_token'
+            },
+            unlockDoors: {
+                method: 'POST',
+                path: '/v1/vehicle/:tokenId/commands/doors/unlock',
+                auth: 'privilege_token'
+            },
+            openFrunk: {
+                method: 'POST',
+                path: '/v1/vehicle/:tokenId/commands/frunk/open',
+                auth: 'privilege_token'
+            },
+            openTrunk: {
+                method: 'POST',
+                path: '/v1/vehicle/:tokenId/commands/trunk/open',
+                auth: 'privilege_token'
+            },
+            listErrorCodes: {
+                method: 'GET',
+                path: '/v1/user/devices/:userDeviceId/error-codes',
+                auth: 'access_token'
+            },
+            submitErrorCodes: {
+                method: 'POST',
+                path: '/v1/user/devices/:userDeviceId/error-codes',
+                body: {
+                    queryDeviceErrorCodes: true
+                },
+                auth: 'access_token'
+            },
+            clearErrorCodes: {
+                method: 'POST',
+                path: '/v1/user/devices/:userDeviceId/error-codes/clear',
+                auth: 'access_token'
+            },
+            getAftermarketDevice: {
+                method: 'GET',
+                path: '/v1/aftermarket/device/:tokenId',
+            },
+            getAftermarketDeviceImage: {
+                method: 'GET',
+                path: '/v1/aftermarket/device/:tokenId/image',
+            },
+            getAftermarketDeviceMetadataByAddress: {
+                method: 'GET',
+                path: '/v1/aftermarket/device/by-address/:address',
+            }
+        });
+    }
+}

package/dist/api/resources/DimoRestResources.d.ts

@@ -0,0 +1,9 @@
+import { Attestation } from './Attestation';
+import { Auth } from './Auth';
+import { DeviceDefinitions } from './DeviceDefinitions';
+import { Devices } from './Devices';
+import { TokenExchange } from './TokenExchange';
+import { Trips } from './Trips';
+import { Valuations } from './Valuations';
+import { VehicleSignalDecoding } from './VehicleSignalDecoding';
+export { Attestation, Auth, DeviceDefinitions, Devices, TokenExchange, Trips, Valuations, VehicleSignalDecoding };

package/dist/api/resources/DimoRestResources.js

@@ -0,0 +1,9 @@
+import { Attestation } from './Attestation';
+import { Auth } from './Auth';
+import { DeviceDefinitions } from './DeviceDefinitions';
+import { Devices } from './Devices';
+import { TokenExchange } from './TokenExchange';
+import { Trips } from './Trips';
+import { Valuations } from './Valuations';
+import { VehicleSignalDecoding } from './VehicleSignalDecoding';
+export { Attestation, Auth, DeviceDefinitions, Devices, TokenExchange, Trips, Valuations, VehicleSignalDecoding };

package/dist/api/resources/TokenExchange/index.d.ts

@@ -0,0 +1,5 @@
+import { Resource } from '../../Resource';
+import { DimoEnvironment } from '../../../environments';
+export declare class TokenExchange extends Resource {
+    constructor(api: any, env: keyof typeof DimoEnvironment);
+}

package/dist/api/resources/TokenExchange/index.js

@@ -0,0 +1,20 @@
+import { Resource } from '../../Resource';
+import { DimoConstants } from '../../../constants';
+export class TokenExchange extends Resource {
+    constructor(api, env) {
+        super(api, 'TokenExchange', env);
+        this.setResource({
+            exchange: {
+                method: 'POST',
+                path: '/v1/tokens/exchange',
+                body: {
+                    nftContractAddress: DimoConstants[env].NFT_address,
+                    privileges: true,
+                    tokenId: true
+                },
+                auth: 'access_token',
+                return: 'privilege_token'
+            }
+        });
+    }
+}

package/dist/api/resources/Trips/index.d.ts

@@ -0,0 +1,5 @@
+import { Resource } from '../../Resource';
+import { DimoEnvironment } from '../../../environments';
+export declare class Trips extends Resource {
+    constructor(api: any, env: keyof typeof DimoEnvironment);
+}

package/dist/api/resources/Trips/index.js

@@ -0,0 +1,16 @@
+import { Resource } from '../../Resource';
+export class Trips extends Resource {
+    constructor(api, env) {
+        super(api, 'Trips', env);
+        this.setResource({
+            list: {
+                method: 'GET',
+                path: '/v1/vehicle/:tokenId/trips',
+                queryParams: {
+                    page: false
+                },
+                auth: 'privilege_token'
+            }
+        });
+    }
+}

package/dist/api/resources/Valuations/index.d.ts

@@ -0,0 +1,5 @@
+import { Resource } from '../../Resource';
+import { DimoEnvironment } from '../../../environments';
+export declare class Valuations extends Resource {
+    constructor(api: any, env: keyof typeof DimoEnvironment);
+}

package/dist/api/resources/Valuations/index.js

@@ -0,0 +1,23 @@
+import { Resource } from '../../Resource';
+export class Valuations extends Resource {
+    constructor(api, env) {
+        super(api, 'Valuations', env);
+        this.setResource({
+            getValuations: {
+                method: 'GET',
+                path: '/v1/user/devices/:userDeviceId/valuations',
+                auth: 'access_token'
+            },
+            getInstantOffers: {
+                method: 'GET',
+                path: '/v1/user/devices/:userDeviceId/instant-offer',
+                auth: 'access_token'
+            },
+            getOffers: {
+                method: 'GET',
+                path: '/v1/user/devices/:userDeviceId/offers',
+                auth: 'access_token'
+            }
+        });
+    }
+}

package/dist/api/resources/VehicleSignalDecoding/index.d.ts

@@ -0,0 +1,5 @@
+import { Resource } from '../../Resource';
+import { DimoEnvironment } from '../../../environments';
+export declare class VehicleSignalDecoding extends Resource {
+    constructor(api: any, env: keyof typeof DimoEnvironment);
+}

package/dist/api/resources/VehicleSignalDecoding/index.js

@@ -0,0 +1,59 @@
+import { Resource } from '../../Resource';
+export class VehicleSignalDecoding extends Resource {
+    constructor(api, env) {
+        super(api, 'VehicleSignalDecoding', env);
+        this.setResource({
+            listConfigUrlsByVin: {
+                method: 'GET',
+                path: '/v1/device-config/vin/:vin/urls',
+                queryParams: {
+                    protocol: false
+                }
+            },
+            listConfigUrlsByAddress: {
+                method: 'GET',
+                path: '/v1/device-config/eth-addr/:address/urls',
+                queryParams: {
+                    protocol: false
+                }
+            },
+            getPidConfigs: {
+                method: 'GET',
+                path: '/v1/device-config/pids/:templateName',
+            },
+            getDeviceSettings: {
+                method: 'GET',
+                path: '/v1/device-config/settings/:templateName',
+            },
+            getDbcText: {
+                method: 'GET',
+                path: '/v1/device-config/dbc/:templateName'
+            },
+            getDeviceStatusByAddress: {
+                method: 'GET',
+                path: '/v1/device-config/eth-addr/:address/status',
+            },
+            setDeviceStatusByAddress: {
+                method: 'PATCH',
+                path: '/v1/device-config/eth-addr/:address/status',
+                body: {
+                    config: true
+                },
+                auth: 'privilege_token'
+            },
+            getJobsByAddress: {
+                method: 'GET',
+                path: '/v1/device-config/eth-addr/:address/jobs'
+            },
+            getPendingJobsByAddress: {
+                method: 'GET',
+                path: '/v1/device-config/eth-addr/:address/jobs/pending'
+            },
+            setJobStatusByAddress: {
+                method: 'PATCH',
+                path: '/v1/device-config/eth-addr/:address/jobs/:jobId/:status',
+                auth: 'privilege_token'
+            },
+        });
+    }
+}

package/dist/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const DimoConstants: {
+    readonly Production: {
+        readonly NFT_address: "0xbA5738a18d83D41847dfFbDC6101d37C69c9B0cF";
+        readonly RPC_provider: "https://eth.llamarpc.com";
+    };
+    readonly Dev: {
+        readonly NFT_address: "0x45fbCD3ef7361d156e8b16F5538AE36DEdf61Da8";
+        readonly RPC_provider: "https://eth.llamarpc.com";
+    };
+};
+export type DimoConstants = typeof DimoConstants.Production | typeof DimoConstants.Dev;

package/dist/constants.js

@@ -0,0 +1,10 @@
+export const DimoConstants = {
+    Production: {
+        'NFT_address': '0xbA5738a18d83D41847dfFbDC6101d37C69c9B0cF',
+        'RPC_provider': 'https://eth.llamarpc.com',
+    },
+    Dev: {
+        'NFT_address': '0x45fbCD3ef7361d156e8b16F5538AE36DEdf61Da8',
+        'RPC_provider': 'https://eth.llamarpc.com',
+    }
+};

package/dist/dimo.d.ts

@@ -0,0 +1,17 @@
+import { DimoEnvironment } from './environments';
+import { Identity, Telemetry } from './graphql/resources/DimoGraphqlResources';
+import { Attestation, Auth, DeviceDefinitions, Devices, TokenExchange, Trips, Valuations, VehicleSignalDecoding } from './api/resources/DimoRestResources';
+export declare class DIMO {
+    attestation: Attestation;
+    auth: Auth;
+    devicedefinitions: DeviceDefinitions;
+    devices: Devices;
+    identity: Identity;
+    telemetry: Telemetry;
+    tokenexchange: TokenExchange;
+    trips: Trips;
+    valuations: Valuations;
+    vehiclesignaldecoding: VehicleSignalDecoding;
+    constructor(env: keyof typeof DimoEnvironment);
+    authenticate(): Promise<any>;
+}

package/dist/dimo.js

@@ -0,0 +1,68 @@
+import { DimoEnvironment } from './environments';
+import { DimoError } from './errors';
+import { Identity, Telemetry } from './graphql/resources/DimoGraphqlResources';
+import { Attestation, Auth, DeviceDefinitions, Devices, TokenExchange, Trips, Valuations, VehicleSignalDecoding } from './api/resources/DimoRestResources';
+// import { Stream } from './streamr';
+export class DIMO {
+    attestation;
+    auth;
+    devicedefinitions;
+    devices;
+    identity;
+    telemetry;
+    tokenexchange;
+    trips;
+    valuations;
+    vehiclesignaldecoding;
+    constructor(env) {
+        this.identity = new Identity(DimoEnvironment[env].Identity, env);
+        this.telemetry = new Telemetry(DimoEnvironment[env].Telemetry, env);
+        /**
+         * Set up all REST Endpoints
+         */
+        this.attestation = new Attestation(DimoEnvironment[env].Attestation, env);
+        this.auth = new Auth(DimoEnvironment[env].Auth, env);
+        this.devicedefinitions = new DeviceDefinitions(DimoEnvironment[env].DeviceDefinitions, env);
+        this.devices = new Devices(DimoEnvironment[env].Devices, env);
+        this.tokenexchange = new TokenExchange(DimoEnvironment[env].TokenExchange, env);
+        this.trips = new Trips(DimoEnvironment[env].Trips, env);
+        this.valuations = new Valuations(DimoEnvironment[env].Valuations, env);
+        this.vehiclesignaldecoding = new VehicleSignalDecoding(DimoEnvironment[env].VehicleSignalDecoding, env);
+    }
+    // Helper Function
+    async authenticate() {
+        let fs;
+        try {
+            // Dynamically import fs
+            if (typeof process !== 'undefined' && process.versions && process.versions.node) {
+                fs = await import('fs');
+            }
+            else {
+                // Optionally handle the case where 'fs' is not available, returns null
+                console.log('Not in Node.js environment; `fs` module is not available.');
+                return null;
+            }
+            if (!fs.existsSync('.credentials.json')) {
+                throw new DimoError({
+                    message: 'Credentials file does not exist'
+                });
+            }
+            const data = fs.readFileSync('.credentials.json', 'utf8');
+            const credentials = JSON.parse(data);
+            const authHeader = await this.auth.getToken({
+                client_id: credentials.client_id,
+                domain: credentials.redirect_uri,
+                private_key: credentials.private_key,
+            });
+            return authHeader;
+        }
+        catch (error) {
+            // Handle file not existing and other errors
+            console.error('Failed to authenticate:', error.message);
+            // Decide whether to throw the error or handle it differently
+            throw new DimoError({
+                message: 'Authentication failed'
+            });
+        }
+    }
+}