@toruslabs/metadata-helpers/dist/lib.esm/MetadataStorageLayer.js

Helper methods for metadata

import _objectSpread from '@babel/runtime/helpers/objectSpread2';
import _defineProperty from '@babel/runtime/helpers/defineProperty';
import { secp256k1 } from '@noble/curves/secp256k1.js';
import { keccak_256 } from '@noble/hashes/sha3.js';
import { setAPIKey, setEmbedHost, post } from '@toruslabs/http-helpers';
import stringify from 'json-stable-stringify';
import { utf8ToBytes, bytesToBase64 } from './helpers/bytes.js';
import { getPublicKeyCoords, toEthereumSignature } from './helpers/utils.js';
import { bytesToHex } from '@noble/curves/utils.js';

class MetadataStorageLayer {
  // ms

  constructor(metadataHost = "https://metadata.tor.us", serverTimeOffset = 0) {
    _defineProperty(this, "metadataHost", void 0);
    _defineProperty(this, "serverTimeOffset", void 0);
    this.metadataHost = metadataHost;
    this.serverTimeOffset = serverTimeOffset;
  }
  static setAPIKey(apiKey) {
    setAPIKey(apiKey);
  }
  static setEmbedHost(embedHost) {
    setEmbedHost(embedHost);
  }
  generateMetadataParams(message, privateKeyBytes) {
    const {
      x,
      y
    } = getPublicKeyCoords(privateKeyBytes);
    const setData = {
      data: message,
      timestamp: Math.floor(this.serverTimeOffset + Date.now() / 1000).toString(16)
    };
    const msgHash = keccak_256(utf8ToBytes(stringify(setData)));
    const sigBytes = secp256k1.sign(msgHash, privateKeyBytes, {
      prehash: false,
      format: "recovered",
      lowS: false
    });
    return {
      pub_key_X: x,
      pub_key_Y: y,
      set_data: setData,
      signature: bytesToBase64(toEthereumSignature(sigBytes))
    };
  }
  generatePubKeyParams(privateKeyBytes) {
    const {
      x,
      y
    } = getPublicKeyCoords(privateKeyBytes);
    return {
      pub_key_X: x,
      pub_key_Y: y
    };
  }
  async setMetadata(data, namespace, options) {
    const pubKeyHex = {
      pub_key_X: bytesToHex(data.pub_key_X),
      pub_key_Y: bytesToHex(data.pub_key_Y)
    };
    const params = namespace !== null ? _objectSpread(_objectSpread(_objectSpread({}, data), pubKeyHex), {}, {
      namespace
    }) : _objectSpread(_objectSpread({}, data), pubKeyHex);
    const metadataResponse = await post(`${this.metadataHost}/set`, params, options, {
      useAPIKey: true
    });
    return metadataResponse.message;
  }
  async getMetadata(pubKey, namespace, options) {
    const pubKeyHex = {
      pub_key_X: bytesToHex(pubKey.pub_key_X),
      pub_key_Y: bytesToHex(pubKey.pub_key_Y)
    };
    const params = namespace !== null ? _objectSpread(_objectSpread({}, pubKeyHex), {}, {
      namespace
    }) : pubKeyHex;
    const metadataResponse = await post(`${this.metadataHost}/get`, params, options, {
      useAPIKey: true
    });
    return metadataResponse.message;
  }
}

export { MetadataStorageLayer };