@ensdomains/ensjs 3.0.0-alpha.8 → 3.0.0-alpha.9

package/dist/cjs/functions/setRecord.d.ts

@@ -0,0 +1,18 @@
+import { ENSArgs } from '..';
+import { RecordInput, RecordTypes } from '../utils/recordHelpers';
+declare type BaseInput = {
+    resolverAddress?: string;
+};
+declare type ContentHashInput = {
+    record: RecordInput<'contentHash'>;
+    type: 'contentHash';
+};
+declare type AddrOrTextInput = {
+    record: RecordInput<'addr' | 'text'>;
+    type: 'addr' | 'text';
+};
+export default function <T extends RecordTypes>({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { record, type, resolverAddress, }: BaseInput & (ContentHashInput | AddrOrTextInput)): Promise<{
+    to: string;
+    data: string;
+}>;
+export {};

package/dist/cjs/functions/setRecord.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const normalise_1 = require("../utils/normalise");
+const recordHelpers_1 = require("../utils/recordHelpers");
+async function default_1({ contracts, provider, getResolver, signer, }, name, { record, type, resolverAddress, }) {
+    if (!name.includes('.')) {
+        throw new Error('Input is not an ENS name');
+    }
+    let resolverToUse;
+    if (resolverAddress) {
+        resolverToUse = resolverAddress;
+    }
+    else {
+        resolverToUse = await getResolver(name);
+    }
+    if (!resolverToUse) {
+        throw new Error('No resolver found for input address');
+    }
+    const resolver = (await contracts?.getPublicResolver(provider, resolverToUse))?.connect(signer);
+    const hash = (0, normalise_1.namehash)(name);
+    const call = (0, recordHelpers_1.generateSingleRecordCall)(hash, resolver, type)(record);
+    return {
+        to: resolver.address,
+        data: call,
+    };
+}
+exports.default = default_1;

package/dist/cjs/index.d.ts

@@ -7,6 +7,7 @@ import type burnFuses from './functions/burnFuses';
 import type createSubname from './functions/createSubname';
 import type deleteSubname from './functions/deleteSubname';
 import type setName from './functions/setName';
+import type setRecord from './functions/setRecord';
 import type setRecords from './functions/setRecords';
 import type setResolver from './functions/setResolver';
 import type transferName from './functions/transferName';
@@ -457,6 +458,7 @@ export declare class ENS {
     }>;
     setName: WriteFunction<typeof setName>;
     setRecords: WriteFunction<typeof setRecords>;
+    setRecord: WriteFunction<typeof setRecord>;
     setResolver: WriteFunction<typeof setResolver>;
     transferName: WriteFunction<typeof transferName>;
     wrapName: WriteFunction<typeof wrapName>;

package/dist/cjs/index.js

@@ -225,6 +225,11 @@ class ENS {
         'contracts',
     ]);
     setRecords = this.generateWriteFunction('setRecords', ['contracts', 'provider', 'getResolver']);
+    setRecord = this.generateWriteFunction('setRecord', [
+        'contracts',
+        'provider',
+        'getResolver',
+    ]);
     setResolver = this.generateWriteFunction('setResolver', ['contracts']);
     transferName = this.generateWriteFunction('transferName', ['contracts']);
     wrapName = this.generateWriteFunction('wrapName', [

package/dist/cjs/utils/recordHelpers.d.ts

@@ -9,5 +9,8 @@ export declare type RecordOptions = {
     coinTypes?: RecordItem[];
 };
 export declare const generateSetAddr: (namehash: string, coinType: string, address: string, resolver: PublicResolver) => string;
+export declare type RecordTypes = 'contentHash' | 'text' | 'addr';
+export declare type RecordInput<T extends RecordTypes> = T extends 'contentHash' ? string : RecordItem;
+export declare function generateSingleRecordCall<T extends RecordTypes>(namehash: string, resolver: PublicResolver, type: T): (record: RecordInput<T>) => string;
 export declare const generateRecordCallArray: (namehash: string, records: RecordOptions, resolver: PublicResolver) => string[];
 export {};

package/dist/cjs/utils/recordHelpers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRecordCallArray = exports.generateSetAddr = void 0;
+exports.generateRecordCallArray = exports.generateSingleRecordCall = exports.generateSetAddr = void 0;
 const address_encoder_1 = require("@ensdomains/address-encoder");
 const contentHash_1 = require("./contentHash");
 const generateSetAddr = (namehash, coinType, address, resolver) => {
@@ -16,28 +16,55 @@ const generateSetAddr = (namehash, coinType, address, resolver) => {
     return resolver?.interface.encodeFunctionData('setAddr(bytes32,uint256,bytes)', [namehash, inputCoinType, encodedAddress]);
 };
 exports.generateSetAddr = generateSetAddr;
+function generateSingleRecordCall(namehash, resolver, type) {
+    if (type === 'contentHash') {
+        return (_r) => {
+            const record = _r;
+            let _contentHash = '';
+            if (record !== _contentHash) {
+                const encoded = (0, contentHash_1.encodeContenthash)(record);
+                if (encoded.error)
+                    throw new Error(encoded.error);
+                _contentHash = encoded.encoded;
+            }
+            return resolver.interface.encodeFunctionData('setContenthash', [
+                namehash,
+                _contentHash,
+            ]);
+        };
+    }
+    else {
+        return (_r) => {
+            const record = _r;
+            if (type === 'text') {
+                return resolver.interface.encodeFunctionData('setText', [
+                    namehash,
+                    record.key,
+                    record.value,
+                ]);
+            }
+            else {
+                return (0, exports.generateSetAddr)(namehash, record.key, record.value, resolver);
+            }
+        };
+    }
+}
+exports.generateSingleRecordCall = generateSingleRecordCall;
 const generateRecordCallArray = (namehash, records, resolver) => {
     const calls = [];
     if (records.contentHash) {
-        const contentHash = records.contentHash === '' ? '' : (0, contentHash_1.encodeContenthash)(records.contentHash);
-        const data = resolver?.interface.encodeFunctionData('setContenthash', [namehash, contentHash]);
+        const data = generateSingleRecordCall(namehash, resolver, 'contentHash')(records.contentHash);
         data && calls.push(data);
     }
     if (records.texts && records.texts.length > 0) {
-        records.texts.forEach(({ key, value }) => {
-            const data = resolver?.interface.encodeFunctionData('setText', [
-                namehash,
-                key,
-                value,
-            ]);
-            data && calls.push(data);
-        });
+        records.texts
+            .map(generateSingleRecordCall(namehash, resolver, 'text'))
+            .forEach((call) => calls.push(call));
     }
     if (records.coinTypes && records.coinTypes.length > 0) {
-        records.coinTypes.forEach(({ key, value }) => {
-            const data = (0, exports.generateSetAddr)(namehash, key, value, resolver);
-            data && calls.push(data);
-        });
+        records.coinTypes
+            .map(generateSingleRecordCall(namehash, resolver, 'addr'))
+            .forEach((call) => calls.push(call));
     }
     return calls;
 };

package/dist/esm/functions/setRecord.d.ts

@@ -0,0 +1,18 @@
+import { ENSArgs } from '..';
+import { RecordInput, RecordTypes } from '../utils/recordHelpers';
+declare type BaseInput = {
+    resolverAddress?: string;
+};
+declare type ContentHashInput = {
+    record: RecordInput<'contentHash'>;
+    type: 'contentHash';
+};
+declare type AddrOrTextInput = {
+    record: RecordInput<'addr' | 'text'>;
+    type: 'addr' | 'text';
+};
+export default function <T extends RecordTypes>({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { record, type, resolverAddress, }: BaseInput & (ContentHashInput | AddrOrTextInput)): Promise<{
+    to: string;
+    data: string;
+}>;
+export {};

package/dist/esm/functions/setRecord.js

@@ -0,0 +1,24 @@
+import { namehash } from '../utils/normalise';
+import { generateSingleRecordCall, } from '../utils/recordHelpers';
+export default async function ({ contracts, provider, getResolver, signer, }, name, { record, type, resolverAddress, }) {
+    if (!name.includes('.')) {
+        throw new Error('Input is not an ENS name');
+    }
+    let resolverToUse;
+    if (resolverAddress) {
+        resolverToUse = resolverAddress;
+    }
+    else {
+        resolverToUse = await getResolver(name);
+    }
+    if (!resolverToUse) {
+        throw new Error('No resolver found for input address');
+    }
+    const resolver = (await contracts?.getPublicResolver(provider, resolverToUse))?.connect(signer);
+    const hash = namehash(name);
+    const call = generateSingleRecordCall(hash, resolver, type)(record);
+    return {
+        to: resolver.address,
+        data: call,
+    };
+}

package/dist/esm/index.d.ts

@@ -7,6 +7,7 @@ import type burnFuses from './functions/burnFuses';
 import type createSubname from './functions/createSubname';
 import type deleteSubname from './functions/deleteSubname';
 import type setName from './functions/setName';
+import type setRecord from './functions/setRecord';
 import type setRecords from './functions/setRecords';
 import type setResolver from './functions/setResolver';
 import type transferName from './functions/transferName';
@@ -457,6 +458,7 @@ export declare class ENS {
     }>;
     setName: WriteFunction<typeof setName>;
     setRecords: WriteFunction<typeof setRecords>;
+    setRecord: WriteFunction<typeof setRecord>;
     setResolver: WriteFunction<typeof setResolver>;
     transferName: WriteFunction<typeof transferName>;
     wrapName: WriteFunction<typeof wrapName>;

package/dist/esm/index.js

@@ -188,6 +188,11 @@ export class ENS {
             'contracts',
         ]);
         this.setRecords = this.generateWriteFunction('setRecords', ['contracts', 'provider', 'getResolver']);
+        this.setRecord = this.generateWriteFunction('setRecord', [
+            'contracts',
+            'provider',
+            'getResolver',
+        ]);
         this.setResolver = this.generateWriteFunction('setResolver', ['contracts']);
         this.transferName = this.generateWriteFunction('transferName', ['contracts']);
         this.wrapName = this.generateWriteFunction('wrapName', [

package/dist/esm/utils/recordHelpers.d.ts

@@ -9,5 +9,8 @@ export declare type RecordOptions = {
     coinTypes?: RecordItem[];
 };
 export declare const generateSetAddr: (namehash: string, coinType: string, address: string, resolver: PublicResolver) => string;
+export declare type RecordTypes = 'contentHash' | 'text' | 'addr';
+export declare type RecordInput<T extends RecordTypes> = T extends 'contentHash' ? string : RecordItem;
+export declare function generateSingleRecordCall<T extends RecordTypes>(namehash: string, resolver: PublicResolver, type: T): (record: RecordInput<T>) => string;
 export declare const generateRecordCallArray: (namehash: string, records: RecordOptions, resolver: PublicResolver) => string[];
 export {};

package/dist/esm/utils/recordHelpers.js

@@ -12,28 +12,54 @@ export const generateSetAddr = (namehash, coinType, address, resolver) => {
     const encodedAddress = coinTypeInstance.decoder(address);
     return resolver?.interface.encodeFunctionData('setAddr(bytes32,uint256,bytes)', [namehash, inputCoinType, encodedAddress]);
 };
+export function generateSingleRecordCall(namehash, resolver, type) {
+    if (type === 'contentHash') {
+        return (_r) => {
+            const record = _r;
+            let _contentHash = '';
+            if (record !== _contentHash) {
+                const encoded = encodeContenthash(record);
+                if (encoded.error)
+                    throw new Error(encoded.error);
+                _contentHash = encoded.encoded;
+            }
+            return resolver.interface.encodeFunctionData('setContenthash', [
+                namehash,
+                _contentHash,
+            ]);
+        };
+    }
+    else {
+        return (_r) => {
+            const record = _r;
+            if (type === 'text') {
+                return resolver.interface.encodeFunctionData('setText', [
+                    namehash,
+                    record.key,
+                    record.value,
+                ]);
+            }
+            else {
+                return generateSetAddr(namehash, record.key, record.value, resolver);
+            }
+        };
+    }
+}
 export const generateRecordCallArray = (namehash, records, resolver) => {
     const calls = [];
     if (records.contentHash) {
-        const contentHash = records.contentHash === '' ? '' : encodeContenthash(records.contentHash);
-        const data = resolver?.interface.encodeFunctionData('setContenthash', [namehash, contentHash]);
+        const data = generateSingleRecordCall(namehash, resolver, 'contentHash')(records.contentHash);
         data && calls.push(data);
     }
     if (records.texts && records.texts.length > 0) {
-        records.texts.forEach(({ key, value }) => {
-            const data = resolver?.interface.encodeFunctionData('setText', [
-                namehash,
-                key,
-                value,
-            ]);
-            data && calls.push(data);
-        });
+        records.texts
+            .map(generateSingleRecordCall(namehash, resolver, 'text'))
+            .forEach((call) => calls.push(call));
     }
     if (records.coinTypes && records.coinTypes.length > 0) {
-        records.coinTypes.forEach(({ key, value }) => {
-            const data = generateSetAddr(namehash, key, value, resolver);
-            data && calls.push(data);
-        });
+        records.coinTypes
+            .map(generateSingleRecordCall(namehash, resolver, 'addr'))
+            .forEach((call) => calls.push(call));
     }
     return calls;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.8",
+  "version": "3.0.0-alpha.9",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "types": "./dist/cjs/index.d.ts",
@@ -83,5 +83,5 @@
   "peerDependencies": {
     "ethers": "*"
   },
-  "stableVersion": "3.0.0-alpha.7"
+  "stableVersion": "3.0.0-alpha.8"
 }

package/src/functions/setRecord.test.ts

@@ -0,0 +1,100 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { decodeContenthash } from '../utils/contentHash'
+import { hexEncodeName } from '../utils/hexEncodedName'
+import { namehash } from '../utils/normalise'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert } = await setup())
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('setRecord', () => {
+  it('should allow a text record set', async () => {
+    const tx = await ENSInstance.setRecord('parthtejpal.eth', {
+      type: 'text',
+      record: { key: 'foo', value: 'bar' },
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
+    const encodedText = await universalResolver.resolve(
+      hexEncodeName('parthtejpal.eth'),
+      publicResolver.interface.encodeFunctionData('text', [
+        namehash('parthtejpal.eth'),
+        'foo',
+      ]),
+    )
+    const [resultText] = publicResolver.interface.decodeFunctionResult(
+      'text',
+      encodedText[0],
+    )
+    expect(resultText).toBe('bar')
+  })
+  it('should allow an address record set', async () => {
+    const tx = await ENSInstance.setRecord('parthtejpal.eth', {
+      type: 'addr',
+      record: {
+        key: 'ETC',
+        value: '0x42D63ae25990889E35F215bC95884039Ba354115',
+      },
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
+    const encodedAddr = await universalResolver.resolve(
+      hexEncodeName('parthtejpal.eth'),
+      publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
+        namehash('parthtejpal.eth'),
+        '61',
+      ]),
+    )
+    const [resultAddr] = publicResolver.interface.decodeFunctionResult(
+      'addr(bytes32,uint256)',
+      encodedAddr[0],
+    )
+    expect(resultAddr).toBe(
+      '0x42D63ae25990889E35F215bC95884039Ba354115'.toLowerCase(),
+    )
+  })
+  it('should allow a contenthash record set', async () => {
+    const tx = await ENSInstance.setRecord('parthtejpal.eth', {
+      type: 'contentHash',
+      record:
+        'ipns://k51qzi5uqu5dgox2z23r6e99oqency055a6xt92xzmyvpz8mwz5ycjavm0u150',
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
+    const encodedContent = await universalResolver.resolve(
+      hexEncodeName('parthtejpal.eth'),
+      publicResolver.interface.encodeFunctionData('contenthash', [
+        namehash('parthtejpal.eth'),
+      ]),
+    )
+    const [resultContent] = publicResolver.interface.decodeFunctionResult(
+      'contenthash',
+      encodedContent[0],
+    )
+    const content = decodeContenthash(resultContent)
+    expect(content.decoded).toBe(
+      'k51qzi5uqu5dgox2z23r6e99oqency055a6xt92xzmyvpz8mwz5ycjavm0u150',
+    )
+    expect(content.protocolType).toBe('ipns')
+  })
+})

package/src/functions/setRecord.ts

@@ -0,0 +1,63 @@
+import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+import {
+  generateSingleRecordCall,
+  RecordInput,
+  RecordTypes,
+} from '../utils/recordHelpers'
+
+type BaseInput = {
+  resolverAddress?: string
+}
+
+type ContentHashInput = {
+  record: RecordInput<'contentHash'>
+  type: 'contentHash'
+}
+
+type AddrOrTextInput = {
+  record: RecordInput<'addr' | 'text'>
+  type: 'addr' | 'text'
+}
+
+export default async function <T extends RecordTypes>(
+  {
+    contracts,
+    provider,
+    getResolver,
+    signer,
+  }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>,
+  name: string,
+  {
+    record,
+    type,
+    resolverAddress,
+  }: BaseInput & (ContentHashInput | AddrOrTextInput),
+) {
+  if (!name.includes('.')) {
+    throw new Error('Input is not an ENS name')
+  }
+
+  let resolverToUse: string
+  if (resolverAddress) {
+    resolverToUse = resolverAddress
+  } else {
+    resolverToUse = await getResolver(name)
+  }
+
+  if (!resolverToUse) {
+    throw new Error('No resolver found for input address')
+  }
+
+  const resolver = (
+    await contracts?.getPublicResolver(provider, resolverToUse)
+  )?.connect(signer)!
+  const hash = namehash(name)
+
+  const call = generateSingleRecordCall(hash, resolver, type)(record)
+
+  return {
+    to: resolver.address,
+    data: call,
+  }
+}

package/src/functions/setRecords.test.ts

@@ -32,7 +32,7 @@ describe('setRecords', () => {
     const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
     const encodedText = await universalResolver.resolve(
       hexEncodeName('parthtejpal.eth'),
-      publicResolver.interface.encodeFunctionData('text(bytes32,string)', [
+      publicResolver.interface.encodeFunctionData('text', [
         namehash('parthtejpal.eth'),
         'foo',
       ]),
@@ -45,7 +45,7 @@ describe('setRecords', () => {
       ]),
     )
     const [resultText] = publicResolver.interface.decodeFunctionResult(
-      'text(bytes32,string)',
+      'text',
       encodedText[0],
     )
     const [resultAddr] = publicResolver.interface.decodeFunctionResult(

package/src/index.ts

@@ -37,6 +37,7 @@ import type {
 } from './functions/getSpecificRecord'
 import type getSubnames from './functions/getSubnames'
 import type setName from './functions/setName'
+import type setRecord from './functions/setRecord'
 import type setRecords from './functions/setRecords'
 import type setResolver from './functions/setResolver'
 import type transferName from './functions/transferName'
@@ -543,6 +544,12 @@ export class ENS {
     ['contracts', 'provider', 'getResolver'],
   )
 
+  public setRecord = this.generateWriteFunction<typeof setRecord>('setRecord', [
+    'contracts',
+    'provider',
+    'getResolver',
+  ])
+
   public setResolver = this.generateWriteFunction<typeof setResolver>(
     'setResolver',
     ['contracts'],

package/src/utils/recordHelpers.ts

@@ -33,6 +33,47 @@ export const generateSetAddr = (
   )
 }
 
+export type RecordTypes = 'contentHash' | 'text' | 'addr'
+
+export type RecordInput<T extends RecordTypes> = T extends 'contentHash'
+  ? string
+  : RecordItem
+
+export function generateSingleRecordCall<T extends RecordTypes>(
+  namehash: string,
+  resolver: PublicResolver,
+  type: T,
+): (record: RecordInput<T>) => string {
+  if (type === 'contentHash') {
+    return (_r: RecordInput<T>) => {
+      const record = _r as string
+      let _contentHash = ''
+      if (record !== _contentHash) {
+        const encoded = encodeContenthash(record)
+        if (encoded.error) throw new Error(encoded.error)
+        _contentHash = encoded.encoded as string
+      }
+      return resolver.interface.encodeFunctionData('setContenthash', [
+        namehash,
+        _contentHash,
+      ])
+    }
+  } else {
+    return (_r: RecordInput<T>) => {
+      const record = _r as RecordItem
+      if (type === 'text') {
+        return resolver.interface.encodeFunctionData('setText', [
+          namehash,
+          record.key,
+          record.value,
+        ])
+      } else {
+        return generateSetAddr(namehash, record.key, record.value, resolver)
+      }
+    }
+  }
+}
+
 export const generateRecordCallArray = (
   namehash: string,
   records: RecordOptions,
@@ -41,31 +82,24 @@ export const generateRecordCallArray = (
   const calls: string[] = []
 
   if (records.contentHash) {
-    const contentHash =
-      records.contentHash === '' ? '' : encodeContenthash(records.contentHash)
-    const data = (resolver?.interface.encodeFunctionData as any)(
-      'setContenthash',
-      [namehash, contentHash],
-    )
+    const data = generateSingleRecordCall(
+      namehash,
+      resolver,
+      'contentHash',
+    )(records.contentHash)
     data && calls.push(data)
   }
 
   if (records.texts && records.texts.length > 0) {
-    records.texts.forEach(({ key, value }: RecordItem) => {
-      const data = resolver?.interface.encodeFunctionData('setText', [
-        namehash,
-        key,
-        value,
-      ])
-      data && calls.push(data)
-    })
+    records.texts
+      .map(generateSingleRecordCall(namehash, resolver, 'text'))
+      .forEach((call) => calls.push(call))
   }
 
   if (records.coinTypes && records.coinTypes.length > 0) {
-    records.coinTypes.forEach(({ key, value }: RecordItem) => {
-      const data = generateSetAddr(namehash, key, value, resolver!)
-      data && calls.push(data)
-    })
+    records.coinTypes
+      .map(generateSingleRecordCall(namehash, resolver, 'addr'))
+      .forEach((call) => calls.push(call))
   }
 
   return calls