diff --git a/README.md b/README.md
index 75c4050..c57a98c 100644
--- a/README.md
+++ b/README.md
@@ -232,8 +232,8 @@ const hash = sha256(message);
 const recipient = new HashLockFT(hash);
 
 // create p2pkh from a utxo
-// NOTE: You can not use BSV20V1P2PKH.getLatestInstance for bsv20, it only works for NFT
-const p2pkh = BSV20V1P2PKH.fromUTXO(`your utxo`);
+// NOTE: You can not use BSV20P2PKH.getLatestInstance for bsv20, it only works for NFT
+const p2pkh = BSV20P2PKH.fromUTXO(`your utxo`);
 
 await p2pkh.connect(getDefaultSigner());
 
@@ -243,7 +243,7 @@ const { tx: transferTx } = await p2pkh.methods.unlock(
   {
     transfer: recipient,
     pubKeyOrAddrToSign: `yourPubKey`,
-  } as OrdiMethodCallOptions<BSV20V1P2PKH>
+  } as OrdiMethodCallOptions<BSV20P2PKH>
 );
 
 console.log("Transferred FT: ", transferTx.id);
@@ -261,13 +261,13 @@ const hash = sha256(message);
 const recipient = new HashLockFT(hash);
 
 // create p2pkh from a utxo
-// NOTE: you can not use BSV20V1P2PKH.getLatestInstance for bsv20, it only works for NFT
-const bsv20V1P2PKHs = await BSV20V1P2PKH.getBSV20(
+// NOTE: you can not use BSV20P2PKH.getLatestInstance for bsv20, it only works for NFT
+const bsv20P2PKHs = await BSV20P2PKH.getBSV20(
   "DOGE",
   `your ordinal address`
 );
 
-await Promise.all(bsv20V1P2PKHs.map((p) => p.connect(signer)));
+await Promise.all(bsv20P2PKHs.map((p) => p.connect(signer)));
 const recipients: Array<FTReceiver> = [
   {
     instance: new HashLockFT(tick, max, lim, dec, sha256(message)),
@@ -275,8 +275,8 @@ const recipients: Array<FTReceiver> = [
   },
 ];
 
-const { tx, nexts } = await BSV20V1P2PKH.transfer(
-  bsv20V1P2PKHs,
+const { tx, nexts } = await BSV20P2PKH.transfer(
+  bsv20P2PKHs,
   signer,
   recipients
 );
diff --git a/src/1satApis.ts b/src/1satApis.ts
index cb9c572..ab11f63 100644
--- a/src/1satApis.ts
+++ b/src/1satApis.ts
@@ -1,7 +1,7 @@
 import { UTXO, bsv } from 'scrypt-ts'
 
 import superagent from 'superagent'
-import { handlerApiError, isBSV20v2 } from './utils'
+import { handlerApiError, isBSV21 } from './utils'
 
 export class OneSatApis {
     private static apiBase(network: bsv.Networks.Network) {
@@ -82,7 +82,7 @@ export class OneSatApis {
         tick: string
     ): Promise<Array<UTXO>> {
         const network = bsv.Address.fromString(address).network
-        const url = isBSV20v2(tick)
+        const url = isBSV21(tick)
             ? `${this.apiBase(
                   network || bsv.Networks.mainnet
               )}/bsv20/${address}/id/${tick}`
diff --git a/src/contracts/bsv20V1.ts b/src/contracts/bsv20.ts
similarity index 93%
rename from src/contracts/bsv20V1.ts
rename to src/contracts/bsv20.ts
index 667880e..932c750 100644
--- a/src/contracts/bsv20V1.ts
+++ b/src/contracts/bsv20.ts
@@ -22,11 +22,11 @@ import { fromByteString } from '../utils'
 import { OrdiMethodCallOptions, FTReceiver, Inscription } from '../types'
 
 /**
- * A base class implementing the bsv20 v1 protocol
+ * A base class implementing the bsv20 protocol
  */
-export abstract class BSV20V1 extends SmartContract {
+export abstract class BSV20 extends SmartContract {
     @prop(true)
-    isBSV20V1: boolean
+    isBSV20: boolean
     /** Ticker: 4 letter identifier of the bsv-20 */
     @prop()
     readonly tick: ByteString
@@ -49,7 +49,7 @@ export abstract class BSV20V1 extends SmartContract {
         this.max = max
         this.lim = lim
         this.dec = dec
-        this.isBSV20V1 = true
+        this.isBSV20 = true
         assert(this.max <= 18446744073709551615n)
         assert(this.dec <= 18)
     }
@@ -57,7 +57,7 @@ export abstract class BSV20V1 extends SmartContract {
     @method()
     buildStateOutputFT(amt: bigint): ByteString {
         const stateScript =
-            BSV20V1.createTransferInsciption(this.tick, amt) +
+            BSV20.createTransferInsciption(this.tick, amt) +
             Ordinal.removeInsciption(this.getStateScript())
         return Utils.buildOutput(stateScript, 1n)
     }
@@ -68,7 +68,7 @@ export abstract class BSV20V1 extends SmartContract {
         tick: ByteString,
         amt: bigint
     ): ByteString {
-        const transferScript = BSV20V1.buildTransferScript(address, tick, amt)
+        const transferScript = BSV20.buildTransferScript(address, tick, amt)
         return Utils.buildOutput(transferScript, 1n)
     }
 
@@ -79,7 +79,7 @@ export abstract class BSV20V1 extends SmartContract {
         amt: bigint
     ): ByteString {
         return (
-            BSV20V1.createTransferInsciption(tick, amt) +
+            BSV20.createTransferInsciption(tick, amt) +
             Utils.buildPublicKeyHashScript(address)
         )
     }
@@ -191,8 +191,8 @@ export abstract class BSV20V1 extends SmartContract {
         methodName: string
     ): MethodCallTxBuilder<T> {
         return async function (
-            current: BSV20V1,
-            options: OrdiMethodCallOptions<BSV20V1>,
+            current: BSV20,
+            options: OrdiMethodCallOptions<BSV20>,
             ...args: any[]
         ): Promise<ContractTransaction> {
             const recipients = (options.transfer || []) as
@@ -217,7 +217,7 @@ export abstract class BSV20V1 extends SmartContract {
             tx.addInput(current.buildContractInput())
 
             function addReceiver(receiver: FTReceiver) {
-                if (receiver.instance instanceof BSV20V1) {
+                if (receiver.instance instanceof BSV20) {
                     receiver.instance.setAmt(receiver.amt)
                 } else {
                     throw new Error('unsupport receiver!')
@@ -251,8 +251,8 @@ export abstract class BSV20V1 extends SmartContract {
                     : await current.signer.getDefaultAddress()
 
                 // eslint-disable-next-line @typescript-eslint/no-var-requires
-                const { BSV20V1P2PKH } = require('./bsv20V1P2PKH')
-                const p2pkh = new BSV20V1P2PKH(
+                const { BSV20P2PKH } = require('./bsv20P2PKH')
+                const p2pkh = new BSV20P2PKH(
                     current.tick,
                     current.max,
                     current.lim,
@@ -324,7 +324,7 @@ export abstract class BSV20V1 extends SmartContract {
     }
 
     /**
-     * recover a `BSV20V1` instance from the transaction
+     * recover a `BSV20` instance from the transaction
      * if the contract contains onchain properties of type `HashedMap` or `HashedSet`
      * it's required to pass all their offchain raw data at this transaction moment
      * @param tx transaction
diff --git a/src/contracts/bsv20V1P2PKH.ts b/src/contracts/bsv20P2PKH.ts
similarity index 91%
rename from src/contracts/bsv20V1P2PKH.ts
rename to src/contracts/bsv20P2PKH.ts
index 0091672..1c92468 100644
--- a/src/contracts/bsv20V1P2PKH.ts
+++ b/src/contracts/bsv20P2PKH.ts
@@ -24,12 +24,12 @@ import {
 
 import { Ordinal } from './ordinal'
 import { OneSatApis } from '../1satApis'
-import { BSV20V1 } from './bsv20V1'
-import { BSV20V1_JSON, FTReceiver, OrdiMethodCallOptions } from '../types'
+import { BSV20 } from './bsv20'
+import { BSV20_JSON, FTReceiver, OrdiMethodCallOptions } from '../types'
 
 const P2PKHScriptLen = 50
 
-export class BSV20V1P2PKH extends BSV20V1 {
+export class BSV20P2PKH extends BSV20 {
     // Address of the recipient.
     @prop()
     readonly addr: Addr
@@ -127,7 +127,7 @@ export class BSV20V1P2PKH extends BSV20V1 {
         const bsv20 = Ordinal.getBsv20(
             bsv.Script.fromHex(script),
             true
-        ) as BSV20V1_JSON
+        ) as BSV20_JSON
 
         // recreate instance
         const args = delegateInstance.ctorArgs().map((arg) => {
@@ -160,7 +160,7 @@ export class BSV20V1P2PKH extends BSV20V1 {
             throw new Error('invalid ordinal p2pkh utxo')
         }
 
-        const instance = BSV20V1P2PKH.fromLockingScript(utxo.script) as T
+        const instance = BSV20P2PKH.fromLockingScript(utxo.script) as T
         instance.from = utxo
         return instance
     }
@@ -168,12 +168,12 @@ export class BSV20V1P2PKH extends BSV20V1 {
     static async fromOutPoint(
         outPoint: string,
         network?: bsv.Networks.Network
-    ): Promise<BSV20V1P2PKH> {
+    ): Promise<BSV20P2PKH> {
         const utxo = await OneSatApis.fetchUTXOByOutpoint(outPoint, network)
         if (utxo === null) {
             throw new Error(`no utxo found for outPoint: ${outPoint}`)
         }
-        return BSV20V1P2PKH.fromUTXO(utxo)
+        return BSV20P2PKH.fromUTXO(utxo)
     }
 
     /**
@@ -185,22 +185,22 @@ export class BSV20V1P2PKH extends BSV20V1 {
     static async getBSV20(
         tick: string,
         address: string
-    ): Promise<Array<BSV20V1P2PKH>> {
+    ): Promise<Array<BSV20P2PKH>> {
         const bsv20Utxos = await OneSatApis.fetchBSV20Utxos(address, tick)
-        return bsv20Utxos.map((utxo) => BSV20V1P2PKH.fromUTXO(utxo))
+        return bsv20Utxos.map((utxo) => BSV20P2PKH.fromUTXO(utxo))
     }
 
     /**
-     * Transfer BSV20 tokens which held by multiple BSV20V1P2PKH instances
-     * @param senders BSV20V1P2PKH instances
+     * Transfer BSV20 tokens which held by multiple BSV20P2PKH instances
+     * @param senders BSV20P2PKH instances
      * @param feeSigner used to sign UTXOs that pay transaction fees
      * @param receivers token receiving contract
      * @param tokenChangeAddress Token change address
-     * @param sendersPubkey The sender’s public key. By default, the default public key of the Signer connected to BSV20V1P2PKH is used.
+     * @param sendersPubkey The sender’s public key. By default, the default public key of the Signer connected to BSV20P2PKH is used.
      * @returns
      */
     static async transfer(
-        senders: Array<BSV20V1P2PKH>,
+        senders: Array<BSV20P2PKH>,
         feeSigner: Signer,
         receivers: Array<FTReceiver>,
         tokenChangeAddress: bsv.Address,
@@ -235,7 +235,7 @@ export class BSV20V1P2PKH extends BSV20V1 {
         for (let i = 0; i < receivers.length; i++) {
             const receiver = receivers[i]
 
-            if (receiver.instance instanceof BSV20V1) {
+            if (receiver.instance instanceof BSV20) {
                 receiver.instance.setAmt(receiver.amt)
             } else {
                 throw new Error('unsupport receiver, only BSV20!')
@@ -291,8 +291,8 @@ export class BSV20V1P2PKH extends BSV20V1 {
             p2pkh.bindTxBuilder(
                 'unlock',
                 async (
-                    current: BSV20V1P2PKH,
-                    options: MethodCallOptions<BSV20V1P2PKH>
+                    current: BSV20P2PKH,
+                    options: MethodCallOptions<BSV20P2PKH>
                 ): Promise<ContractTransaction> => {
                     if (options.partialContractTx?.tx) {
                         const tx = options.partialContractTx.tx
@@ -323,7 +323,7 @@ export class BSV20V1P2PKH extends BSV20V1 {
                     },
                     pubKeyOrAddrToSign: pubkey,
                     multiContractCall: true,
-                } as OrdiMethodCallOptions<BSV20V1P2PKH>
+                } as OrdiMethodCallOptions<BSV20P2PKH>
             )
         }
 
@@ -341,7 +341,7 @@ export class BSV20V1P2PKH extends BSV20V1 {
 const desc = {
     version: 9,
     compilerVersion: '1.19.0+commit.72eaeba',
-    contract: 'BSV20V1P2PKH',
+    contract: 'BSV20P2PKH',
     md5: '0c046dfb1f1a91cf72b9a852537bdfe1',
     structs: [],
     library: [],
@@ -379,4 +379,4 @@ const desc = {
     sourceMapFile: '',
 }
 
-BSV20V1P2PKH.loadArtifact(desc)
+BSV20P2PKH.loadArtifact(desc)
diff --git a/src/contracts/bsv20V2.ts b/src/contracts/bsv21.ts
similarity index 92%
rename from src/contracts/bsv20V2.ts
rename to src/contracts/bsv21.ts
index 53b9616..718cbf6 100644
--- a/src/contracts/bsv20V2.ts
+++ b/src/contracts/bsv21.ts
@@ -19,12 +19,12 @@ import {
 
 import { Ordinal } from './ordinal'
 import { fromByteString } from '../utils'
-import { OrdiMethodCallOptions, FTReceiver, BSV20V2_JSON } from '../types'
+import { OrdiMethodCallOptions, FTReceiver, BSV21_JSON } from '../types'
 
 /**
- * A base class implementing the bsv20 v2 protocol
+ * A base class implementing the bsv21 protocol
  */
-export abstract class BSV20V2 extends SmartContract {
+export abstract class BSV21 extends SmartContract {
     /** Ticker: identifier of the bsv-20 */
     @prop(true)
     id: ByteString
@@ -58,7 +58,7 @@ export abstract class BSV20V2 extends SmartContract {
         }
 
         const stateScript =
-            BSV20V2.createTransferInsciption(this.id, amt) +
+            BSV21.createTransferInsciption(this.id, amt) +
             Ordinal.removeInsciption(this.getStateScript())
         return Utils.buildOutput(stateScript, 1n)
     }
@@ -74,7 +74,7 @@ export abstract class BSV20V2 extends SmartContract {
         id: ByteString,
         amt: bigint
     ): ByteString {
-        const transferScript = BSV20V2.buildTransferScript(address, id, amt)
+        const transferScript = BSV21.buildTransferScript(address, id, amt)
         return Utils.buildOutput(transferScript, 1n)
     }
 
@@ -85,7 +85,7 @@ export abstract class BSV20V2 extends SmartContract {
         amt: bigint
     ): ByteString {
         return (
-            BSV20V2.createTransferInsciption(id, amt) +
+            BSV21.createTransferInsciption(id, amt) +
             Utils.buildPublicKeyHashScript(address)
         )
     }
@@ -121,7 +121,7 @@ export abstract class BSV20V2 extends SmartContract {
         const nop = this.getPrependNOPScript()
 
         if (nop) {
-            const bsv20 = Ordinal.getBsv20(nop, false) as BSV20V2_JSON
+            const bsv20 = Ordinal.getBsv20(nop, false) as BSV21_JSON
 
             if (bsv20.op === 'deploy+mint') {
                 return `${this.utxo.txId}_${this.utxo.outputIndex}`
@@ -179,8 +179,8 @@ export abstract class BSV20V2 extends SmartContract {
         methodName: string
     ): MethodCallTxBuilder<T> {
         return async function (
-            current: BSV20V2,
-            options: OrdiMethodCallOptions<BSV20V2>,
+            current: BSV21,
+            options: OrdiMethodCallOptions<BSV21>,
             ...args: any[]
         ): Promise<ContractTransaction> {
             const recipients = (options.transfer || []) as
@@ -205,7 +205,7 @@ export abstract class BSV20V2 extends SmartContract {
             tx.addInput(current.buildContractInput())
 
             function addReceiver(receiver: FTReceiver) {
-                if (receiver.instance instanceof BSV20V2) {
+                if (receiver.instance instanceof BSV21) {
                     receiver.instance.setAmt(receiver.amt)
                 } else {
                     throw new Error('unsupport receiver!')
@@ -239,8 +239,8 @@ export abstract class BSV20V2 extends SmartContract {
                     : await current.signer.getDefaultAddress()
 
                 // eslint-disable-next-line @typescript-eslint/no-var-requires
-                const { BSV20V2P2PKH } = require('./bsv20V2P2PKH')
-                const p2pkh = new BSV20V2P2PKH(
+                const { BSV21P2PKH } = require('./bsv21P2PKH')
+                const p2pkh = new BSV21P2PKH(
                     toByteString(current.getTokenId(), true),
                     current.sym,
                     current.max,
@@ -318,7 +318,7 @@ export abstract class BSV20V2 extends SmartContract {
     }
 
     /**
-     * recover a `BSV20V2` instance from the transaction
+     * recover a `BSV21` instance from the transaction
      * if the contract contains onchain properties of type `HashedMap` or `HashedSet`
      * it's required to pass all their offchain raw data at this transaction moment
      * @param tx transaction
diff --git a/src/contracts/bsv20V2P2PKH.ts b/src/contracts/bsv21P2PKH.ts
similarity index 90%
rename from src/contracts/bsv20V2P2PKH.ts
rename to src/contracts/bsv21P2PKH.ts
index 8020887..c6278ed 100644
--- a/src/contracts/bsv20V2P2PKH.ts
+++ b/src/contracts/bsv21P2PKH.ts
@@ -26,17 +26,17 @@ import {
 import { Ordinal } from './ordinal'
 import { OneSatApis } from '../1satApis'
 import {
-    BSV20V1_JSON,
-    BSV20V2_JSON,
-    BSV20V2_TRANSFER_JSON,
+    BSV20_JSON,
+    BSV21_JSON,
+    BSV21_TRANSFER_JSON,
     FTReceiver,
     OrdiMethodCallOptions,
 } from '../types'
-import { BSV20V2 } from './bsv20V2'
+import { BSV21 } from './bsv21'
 
 const P2PKHScriptLen = 50
 
-export class BSV20V2P2PKH extends BSV20V2 {
+export class BSV21P2PKH extends BSV21 {
     // Address of the recipient.
     @prop()
     readonly addr: Addr
@@ -112,7 +112,7 @@ export class BSV20V2P2PKH extends BSV20V2 {
         const nop = this.getNopScript()
 
         if (nop) {
-            const bsv20 = Ordinal.getBsv20(nop, false) as BSV20V2_JSON
+            const bsv20 = Ordinal.getBsv20(nop, false) as BSV21_JSON
 
             if (bsv20.op === 'deploy+mint') {
                 return `${this.utxo.txId}_${this.utxo.outputIndex}`
@@ -154,7 +154,7 @@ export class BSV20V2P2PKH extends BSV20V2 {
         const bsv20 = Ordinal.getBsv20(
             bsv.Script.fromHex(script),
             false
-        ) as BSV20V2_TRANSFER_JSON
+        ) as BSV21_TRANSFER_JSON
 
         // recreate instance
         const args = delegateInstance.ctorArgs().map((arg) => {
@@ -187,7 +187,7 @@ export class BSV20V2P2PKH extends BSV20V2 {
             throw new Error('invalid ordinal p2pkh utxo')
         }
 
-        const instance = BSV20V2P2PKH.fromLockingScript(utxo.script) as T
+        const instance = BSV21P2PKH.fromLockingScript(utxo.script) as T
         instance.from = utxo
         return instance
     }
@@ -195,12 +195,12 @@ export class BSV20V2P2PKH extends BSV20V2 {
     static async fromOutPoint(
         outPoint: string,
         network?: bsv.Networks.Network
-    ): Promise<BSV20V2P2PKH> {
+    ): Promise<BSV21P2PKH> {
         const utxo = await OneSatApis.fetchUTXOByOutpoint(outPoint, network)
         if (utxo === null) {
             throw new Error(`no utxo found for outPoint: ${outPoint}`)
         }
-        return BSV20V2P2PKH.fromUTXO(utxo)
+        return BSV21P2PKH.fromUTXO(utxo)
     }
 
     /**
@@ -212,22 +212,22 @@ export class BSV20V2P2PKH extends BSV20V2 {
     static async getBSV20(
         id: string,
         address: string
-    ): Promise<Array<BSV20V2P2PKH>> {
+    ): Promise<Array<BSV21P2PKH>> {
         const bsv20Utxos = await OneSatApis.fetchBSV20Utxos(address, id)
-        return bsv20Utxos.map((utxo) => BSV20V2P2PKH.fromUTXO(utxo))
+        return bsv20Utxos.map((utxo) => BSV21P2PKH.fromUTXO(utxo))
     }
 
     /**
-     * Transfer BSV20 tokens which held by multiple BSV20V2P2PKH instances
-     * @param senders BSV20V2P2PKH instances
+     * Transfer BSV20 tokens which held by multiple BSV21P2PKH instances
+     * @param senders BSV21P2PKH instances
      * @param feeSigner used to sign UTXOs that pay transaction fees
      * @param receivers token receiving contract
      * @param tokenChangeAddress Token change address
-     * @param sendersPubkey The sender’s public key. By default, the default public key of the Signer connected to BSV20V2P2PKH is used.
+     * @param sendersPubkey The sender’s public key. By default, the default public key of the Signer connected to BSV21P2PKH is used.
      * @returns
      */
     static async transfer(
-        senders: Array<BSV20V2P2PKH>,
+        senders: Array<BSV21P2PKH>,
         feeSigner: Signer,
         receivers: Array<FTReceiver>,
         tokenChangeAddress: bsv.Address,
@@ -268,10 +268,10 @@ export class BSV20V2P2PKH extends BSV20V2 {
         for (let i = 0; i < receivers.length; i++) {
             const receiver = receivers[i]
 
-            if (receiver.instance instanceof BSV20V2) {
+            if (receiver.instance instanceof BSV21) {
                 receiver.instance.setAmt(receiver.amt)
             } else {
-                throw new Error('unsupport receiver, only BSV20!')
+                throw new Error('unsupport receiver, only BSV21!')
             }
 
             tx.addOutput(
@@ -289,7 +289,7 @@ export class BSV20V2P2PKH extends BSV20V2 {
         }
 
         if (tokenChangeAmt > 0n) {
-            const p2pkh = new BSV20V2P2PKH(
+            const p2pkh = new BSV21P2PKH(
                 toByteString(id, true),
                 sym,
                 senders[0].max,
@@ -323,8 +323,8 @@ export class BSV20V2P2PKH extends BSV20V2 {
             p2pkh.bindTxBuilder(
                 'unlock',
                 async (
-                    current: BSV20V2P2PKH,
-                    options: MethodCallOptions<BSV20V2P2PKH>
+                    current: BSV21P2PKH,
+                    options: MethodCallOptions<BSV21P2PKH>
                 ): Promise<ContractTransaction> => {
                     if (options.partialContractTx?.tx) {
                         const tx = options.partialContractTx.tx
@@ -355,7 +355,7 @@ export class BSV20V2P2PKH extends BSV20V2 {
                     },
                     pubKeyOrAddrToSign: pubkey,
                     multiContractCall: true,
-                } as OrdiMethodCallOptions<BSV20V2P2PKH>
+                } as OrdiMethodCallOptions<BSV21P2PKH>
             )
         }
 
@@ -373,7 +373,7 @@ export class BSV20V2P2PKH extends BSV20V2 {
 const desc = {
     version: 9,
     compilerVersion: '1.19.0+commit.72eaeba',
-    contract: 'BSV20V2P2PKH',
+    contract: 'BSV21P2PKH',
     md5: '0c046dfb1f1a91cf72b9a852537bdfe1',
     structs: [],
     library: [],
@@ -411,4 +411,4 @@ const desc = {
     sourceMapFile: '',
 }
 
-BSV20V2P2PKH.loadArtifact(desc)
+BSV21P2PKH.loadArtifact(desc)
diff --git a/src/contracts/ordinal.ts b/src/contracts/ordinal.ts
index 51ba928..672f277 100644
--- a/src/contracts/ordinal.ts
+++ b/src/contracts/ordinal.ts
@@ -16,10 +16,10 @@ import {
 } from 'scrypt-ts'
 import { Shift10 } from 'scrypt-ts-lib'
 import {
-    BSV20V1_JSON,
-    BSV20V2_JSON,
-    BSV20V2_TRANSFER_JSON,
     BSV20_JSON,
+    BSV21_JSON,
+    BSV21_TRANSFER_JSON,
+    FT_JSON,
     Inscription,
 } from '../types'
 import { fromByteString } from '../utils'
@@ -374,7 +374,7 @@ export class Ordinal extends SmartContractLib {
         )
     }
 
-    static getBsv20v1Json(content: string, contentType: string): BSV20V1_JSON {
+    static getBsv20v1Json(content: string, contentType: string): BSV20_JSON {
         if (contentType !== ContentType.BSV20) {
             throw new Error(`invalid bsv20 contentType: ${contentType}`)
         }
@@ -408,10 +408,10 @@ export class Ordinal extends SmartContractLib {
             return bsv20
         }
 
-        throw new Error(`invalid bsv20 v1 json, ${content}`)
+        throw new Error(`invalid bsv20 json, ${content}`)
     }
 
-    static getBsv20v2Json(content: string, contentType: string): BSV20V1_JSON {
+    static getBsv20v2Json(content: string, contentType: string): BSV20_JSON {
         if (contentType !== ContentType.BSV20) {
             throw new Error(`invalid bsv20 contentType: ${contentType}`)
         }
@@ -436,10 +436,10 @@ export class Ordinal extends SmartContractLib {
             return bsv20
         }
 
-        throw new Error(`invalid bsv20 v2 json, ${content}`)
+        throw new Error(`invalid bsv21 json, ${content}`)
     }
 
-    static getBsv20(script: bsv.Script, v1: boolean): BSV20_JSON {
+    static getBsv20(script: bsv.Script, v1: boolean): FT_JSON {
         const [content, contentType] = Ordinal.isOrdinalContract(script)
             ? [
                   fromByteString(toHex(script.chunks[6].buf)),
@@ -461,7 +461,7 @@ export class Ordinal extends SmartContractLib {
     }
 
     static getAmt(script: bsv.Script, tick?: string): bigint {
-        const bsv20 = Ordinal.getBsv20(script, true) as BSV20V1_JSON
+        const bsv20 = Ordinal.getBsv20(script, true) as BSV20_JSON
         if (typeof tick === 'string' && bsv20.tick !== tick) {
             throw new Error(`invalid bsv20 tick, expected ${tick}`)
         }
@@ -474,17 +474,17 @@ export class Ordinal extends SmartContractLib {
     }
 
     static getAmtV2(script: bsv.Script): bigint {
-        const bsv20 = Ordinal.getBsv20(script, false) as BSV20V2_JSON
+        const bsv20 = Ordinal.getBsv20(script, false) as BSV21_JSON
         return BigInt(bsv20.amt)
     }
 
     static getTokenId(script: bsv.Script): string {
-        const bsv20 = Ordinal.getBsv20(script, false) as BSV20V2_TRANSFER_JSON
+        const bsv20 = Ordinal.getBsv20(script, false) as BSV21_TRANSFER_JSON
         return bsv20.id
     }
 
     static getTick(script: bsv.Script): string {
-        const bsv20 = Ordinal.getBsv20(script, true) as BSV20V1_JSON
+        const bsv20 = Ordinal.getBsv20(script, true) as BSV20_JSON
 
         if (bsv20.op === 'mint' || bsv20.op === 'transfer') {
             return bsv20.tick
diff --git a/src/index.ts b/src/index.ts
index f6555f4..0b36523 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,9 +1,9 @@
-export * from './contracts/bsv20V1'
-export * from './contracts/bsv20V2'
+export * from './contracts/bsv20'
+export * from './contracts/bsv21'
 export * from './contracts/ordinalNFT'
 export * from './contracts/ordiNFTP2PKH'
-export * from './contracts/bsv20V1P2PKH'
-export * from './contracts/bsv20V2P2PKH'
+export * from './contracts/bsv20P2PKH'
+export * from './contracts/bsv21P2PKH'
 export * from './types'
 export * from './contracts/ordinal'
 export * from './utils'
diff --git a/src/types.ts b/src/types.ts
index a59c46a..d39bd78 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -8,7 +8,7 @@ export type Inscription = {
     contentType: string
 }
 
-export type BSV20V1_DEPLOY_JSON = {
+export type BSV20_DEPLOY_JSON = {
     p: 'bsv-20'
     op: 'deploy'
     tick: string
@@ -17,42 +17,42 @@ export type BSV20V1_DEPLOY_JSON = {
     dec?: string
 }
 
-export type BSV20V1_MINT_JSON = {
+export type BSV20_MINT_JSON = {
     p: 'bsv-20'
     op: 'mint'
     tick: string
     amt: string
 }
 
-export type BSV20V1_TRANSFER_JSON = {
+export type BSV20_TRANSFER_JSON = {
     p: 'bsv-20'
     op: 'transfer'
     tick: string
     amt: string
 }
 
-export type BSV20V1_JSON =
-    | BSV20V1_DEPLOY_JSON
-    | BSV20V1_MINT_JSON
-    | BSV20V1_TRANSFER_JSON
+export type BSV20_JSON =
+    | BSV20_DEPLOY_JSON
+    | BSV20_MINT_JSON
+    | BSV20_TRANSFER_JSON
 
-export type BSV20V2_DEPLOY_MINT_JSON = {
+export type BSV21_DEPLOY_MINT_JSON = {
     p: 'bsv-20'
     op: 'deploy+mint'
     amt: string
     dec?: string
 }
 
-export type BSV20V2_TRANSFER_JSON = {
+export type BSV21_TRANSFER_JSON = {
     p: 'bsv-20'
     op: 'transfer'
     id: string
     amt: string
 }
 
-export type BSV20V2_JSON = BSV20V2_DEPLOY_MINT_JSON | BSV20V2_TRANSFER_JSON
+export type BSV21_JSON = BSV21_DEPLOY_MINT_JSON | BSV21_TRANSFER_JSON
 
-export type BSV20_JSON = BSV20V1_JSON | BSV20V2_JSON
+export type FT_JSON = BSV20_JSON | BSV21_JSON
 
 export interface FTReceiver {
     instance: SmartContract
diff --git a/src/utils.ts b/src/utils.ts
index 2d599bd..f5be837 100644
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -17,6 +17,6 @@ export function handlerApiError(e: Error) {
     throw new Error(message)
 }
 
-export function isBSV20v2(tick: string) {
+export function isBSV21(tick: string) {
     return /^[a-fA-F0-9]{64}_\d+$/.test(tick)
 }
diff --git a/tests/contracts/counterFT.ts b/tests/contracts/counterBSV20.ts
similarity index 89%
rename from tests/contracts/counterFT.ts
rename to tests/contracts/counterBSV20.ts
index 0c3afea..1f6f4a0 100644
--- a/tests/contracts/counterFT.ts
+++ b/tests/contracts/counterBSV20.ts
@@ -1,7 +1,7 @@
 import { method, prop, assert, SigHash, hash256, ByteString } from 'scrypt-ts'
-import { BSV20V1 } from '../scrypt-ord'
+import { BSV20 } from '../scrypt-ord'
 
-export class CounterFT extends BSV20V1 {
+export class CounterBSV20 extends BSV20 {
     @prop(true)
     counter: bigint
 
diff --git a/tests/contracts/counterFTV2.ts b/tests/contracts/counterBSV21.ts
similarity index 89%
rename from tests/contracts/counterFTV2.ts
rename to tests/contracts/counterBSV21.ts
index 0f31cd0..dd647de 100644
--- a/tests/contracts/counterFTV2.ts
+++ b/tests/contracts/counterBSV21.ts
@@ -1,7 +1,7 @@
 import { method, prop, assert, SigHash, hash256, ByteString } from 'scrypt-ts'
-import { BSV20V2 } from '../scrypt-ord'
+import { BSV21 } from '../scrypt-ord'
 
-export class CounterFTV2 extends BSV20V2 {
+export class CounterBSV21 extends BSV21 {
     @prop(true)
     counter: bigint
 
diff --git a/tests/contracts/hashLockFT.ts b/tests/contracts/hashLockBSV20.ts
similarity index 85%
rename from tests/contracts/hashLockFT.ts
rename to tests/contracts/hashLockBSV20.ts
index 1db4621..bcd89c1 100644
--- a/tests/contracts/hashLockFT.ts
+++ b/tests/contracts/hashLockBSV20.ts
@@ -1,8 +1,8 @@
 import { method, prop, assert, ByteString, sha256, Sha256 } from 'scrypt-ts'
 
-import { BSV20V1 } from '../scrypt-ord'
+import { BSV20 } from '../scrypt-ord'
 
-export class HashLockFT extends BSV20V1 {
+export class HashLockBSV20 extends BSV20 {
     @prop()
     hash: Sha256
 
diff --git a/tests/contracts/hashLockFTV2.ts b/tests/contracts/hashLockBSV21.ts
similarity index 84%
rename from tests/contracts/hashLockFTV2.ts
rename to tests/contracts/hashLockBSV21.ts
index 7376529..4860e78 100644
--- a/tests/contracts/hashLockFTV2.ts
+++ b/tests/contracts/hashLockBSV21.ts
@@ -1,8 +1,8 @@
 import { method, prop, assert, ByteString, sha256, Sha256 } from 'scrypt-ts'
 
-import { BSV20V2 } from '../scrypt-ord'
+import { BSV21 } from '../scrypt-ord'
 
-export class HashLockFTV2 extends BSV20V2 {
+export class HashLockBSV21 extends BSV21 {
     @prop()
     hash: Sha256
 
diff --git a/tests/contracts/permissionedFT.ts b/tests/contracts/permissionedBSV20.ts
similarity index 94%
rename from tests/contracts/permissionedFT.ts
rename to tests/contracts/permissionedBSV20.ts
index 8798b84..46570e5 100644
--- a/tests/contracts/permissionedFT.ts
+++ b/tests/contracts/permissionedBSV20.ts
@@ -12,9 +12,9 @@ import {
     toHex,
 } from 'scrypt-ts'
 
-import { BSV20V1, OrdiMethodCallOptions } from '../scrypt-ord'
+import { BSV20, OrdiMethodCallOptions } from '../scrypt-ord'
 
-export class PermissionedFT extends BSV20V1 {
+export class PermissionedBSV20 extends BSV20 {
     @prop()
     readonly issuer: PubKey
 
@@ -80,8 +80,8 @@ export class PermissionedFT extends BSV20V1 {
     }
 
     static async buildTxForTransfer(
-        current: PermissionedFT,
-        options: OrdiMethodCallOptions<PermissionedFT>,
+        current: PermissionedBSV20,
+        options: OrdiMethodCallOptions<PermissionedBSV20>,
         recipient: PubKey,
         tokenTransferAmount: bigint,
         tokenChangeAmount: bigint
diff --git a/tests/contracts/permissionedFTV2.ts b/tests/contracts/permissionedBSV21.ts
similarity index 94%
rename from tests/contracts/permissionedFTV2.ts
rename to tests/contracts/permissionedBSV21.ts
index 08cbe4e..5c2323d 100644
--- a/tests/contracts/permissionedFTV2.ts
+++ b/tests/contracts/permissionedBSV21.ts
@@ -12,9 +12,9 @@ import {
     toHex,
 } from 'scrypt-ts'
 
-import { BSV20V2, OrdiMethodCallOptions } from '../scrypt-ord'
+import { BSV21, OrdiMethodCallOptions } from '../scrypt-ord'
 
-export class PermissionedFTV2 extends BSV20V2 {
+export class PermissionedBSV21 extends BSV21 {
     @prop()
     readonly issuer: PubKey
 
@@ -80,8 +80,8 @@ export class PermissionedFTV2 extends BSV20V2 {
     }
 
     static async buildTxForTransfer(
-        current: PermissionedFTV2,
-        options: OrdiMethodCallOptions<PermissionedFTV2>,
+        current: PermissionedBSV21,
+        options: OrdiMethodCallOptions<PermissionedBSV21>,
         recipient: PubKey,
         tokenTransferAmount: bigint,
         tokenChangeAmount: bigint
diff --git a/tests/examples/deployBSV20.ts b/tests/examples/deployBSV20.ts
index d0ad1fc..cd6fbfb 100644
--- a/tests/examples/deployBSV20.ts
+++ b/tests/examples/deployBSV20.ts
@@ -1,12 +1,12 @@
 import { bsv, TestWallet, toByteString, Addr } from 'scrypt-ts'
 import { myAddress, myPrivateKey } from '../utils/privateKey'
 import {
-    BSV20V1P2PKH,
+    BSV20P2PKH,
     OrdiProvider,
     OrdiMethodCallOptions,
     FTReceiver,
 } from '../scrypt-ord'
-import { HashLockFT } from '../contracts/hashLockFT'
+import { HashLockBSV20 } from '../contracts/hashLockBSV20'
 /**
  * @returns mainnet signer
  */
@@ -15,7 +15,7 @@ function getSigner() {
 }
 
 async function main() {
-    HashLockFT.loadArtifact('tests/artifacts/contracts/hashLockFT.json')
+    HashLockBSV20.loadArtifact('tests/artifacts/contracts/hashLockFT.json')
 
     const tick = toByteString('KKK1', true)
     const max = 21000000n
@@ -31,12 +31,12 @@ async function main() {
         '28d249bc839a44585891148292635753e620fd68e71cd2939a2dd5188ca2c9ae'
     )
 
-    const hashLock = HashLockFT.fromTx(mintTx as bsv.Transaction, 0)
+    const hashLock = HashLockBSV20.fromTx(mintTx as bsv.Transaction, 0)
 
     await hashLock.connect(signer)
 
     const receiver: FTReceiver = {
-        instance: new BSV20V1P2PKH(
+        instance: new BSV20P2PKH(
             tick,
             max,
             lim,
@@ -48,7 +48,7 @@ async function main() {
 
     const { tx } = await hashLock.methods.unlock(message, {
         transfer: receiver,
-    } as OrdiMethodCallOptions<HashLockFT>)
+    } as OrdiMethodCallOptions<HashLockBSV20>)
 
     console.log(`Transfer tx: ${tx.id}`)
 }
diff --git a/tests/examples/deployBSV20P2PKH.ts b/tests/examples/deployBSV20P2PKH.ts
index 1df06d0..368c439 100644
--- a/tests/examples/deployBSV20P2PKH.ts
+++ b/tests/examples/deployBSV20P2PKH.ts
@@ -1,7 +1,7 @@
 import { TestWallet, toByteString, Addr, findSig, PubKey } from 'scrypt-ts'
 import { myAddress, myPrivateKey, myPublicKey } from '../utils/privateKey'
 import {
-    BSV20V1P2PKH,
+    BSV20P2PKH,
     OrdiProvider,
     OrdiMethodCallOptions,
 } from '../scrypt-ord'
@@ -20,7 +20,7 @@ async function main() {
 
     const signer = getSigner()
 
-    const p2pkh = new BSV20V1P2PKH(
+    const p2pkh = new BSV20P2PKH(
         tick,
         max,
         lim,
@@ -34,7 +34,7 @@ async function main() {
     console.log(`mint: ${mintTx.id}`)
 
     const receiver = {
-        instance: new BSV20V1P2PKH(
+        instance: new BSV20P2PKH(
             tick,
             max,
             lim,
@@ -50,7 +50,7 @@ async function main() {
         {
             transfer: receiver,
             pubKeyOrAddrToSign: myPublicKey,
-        } as OrdiMethodCallOptions<BSV20V1P2PKH>
+        } as OrdiMethodCallOptions<BSV20P2PKH>
     )
 
     console.log(`Transfer tx: ${transferTx.id}`)
diff --git a/tests/examples/mintBSV20.ts b/tests/examples/mintBSV20.ts
index 4b42b40..d9ccf0a 100644
--- a/tests/examples/mintBSV20.ts
+++ b/tests/examples/mintBSV20.ts
@@ -1,8 +1,8 @@
 import { TestWallet, toByteString, sha256, Addr } from 'scrypt-ts'
 import { myAddress, myPrivateKey } from '../utils/privateKey'
-import { HashLockFT } from '../contracts/hashLockFT'
+import { HashLockBSV20 } from '../contracts/hashLockBSV20'
 import {
-    BSV20V1P2PKH,
+    BSV20P2PKH,
     OrdiProvider,
     OrdiMethodCallOptions,
 } from '../scrypt-ord'
@@ -15,7 +15,7 @@ function getSigner() {
 }
 
 async function main() {
-    HashLockFT.loadArtifact('tests/artifacts/contracts/hashLockFT.json')
+    HashLockBSV20.loadArtifact('tests/artifacts/contracts/hashLockFT.json')
 
     // BSV20 fields
     const tick = toByteString('HELLO', true)
@@ -26,7 +26,7 @@ async function main() {
     // create contract instance
     const message = toByteString('Hello sCrypt', true)
     const hash = sha256(message)
-    const hashLock = new HashLockFT(tick, max, lim, dec, hash)
+    const hashLock = new HashLockBSV20(tick, max, lim, dec, hash)
     await hashLock.connect(getSigner())
 
     // deploy the new BSV20 token $HELLO
@@ -40,9 +40,9 @@ async function main() {
     // for now, the contract instance holds the BSV20 token
     // this token can be transferred only when the hash lock is solved
     const addressAlice = Addr(myAddress.toByteString())
-    const alice = new BSV20V1P2PKH(tick, max, lim, dec, addressAlice)
+    const alice = new BSV20P2PKH(tick, max, lim, dec, addressAlice)
     const addressBob = Addr(myAddress.toByteString())
-    const bob = new BSV20V1P2PKH(tick, max, lim, dec, addressBob)
+    const bob = new BSV20P2PKH(tick, max, lim, dec, addressBob)
 
     const { tx: transferTx } = await hashLock.methods.unlock(message, {
         transfer: [
@@ -55,7 +55,7 @@ async function main() {
                 amt: 5n,
             },
         ],
-    } as OrdiMethodCallOptions<HashLockFT>)
+    } as OrdiMethodCallOptions<HashLockBSV20>)
     console.log(`Transfer tx: ${transferTx.id}`)
 }
 
diff --git a/tests/examples/mintBSV20V2.ts b/tests/examples/mintBSV21.ts
similarity index 76%
rename from tests/examples/mintBSV20V2.ts
rename to tests/examples/mintBSV21.ts
index 45aa4ce..72fbb73 100644
--- a/tests/examples/mintBSV20V2.ts
+++ b/tests/examples/mintBSV21.ts
@@ -1,8 +1,8 @@
 import { TestWallet, toByteString, sha256, Addr } from 'scrypt-ts'
 import { myAddress, myPrivateKey } from '../utils/privateKey'
-import { HashLockFTV2 } from '../contracts/hashLockFTV2'
+import { HashLockBSV21 } from '../contracts/hashLockBSV21'
 import {
-    BSV20V2P2PKH,
+    BSV21P2PKH,
     OrdiProvider,
     OrdiMethodCallOptions,
 } from '../scrypt-ord'
@@ -15,7 +15,7 @@ function getSigner() {
 }
 
 async function main() {
-    HashLockFTV2.loadArtifact('./artifacts/contracts/hashLockFTV2.json')
+    HashLockBSV21.loadArtifact('./artifacts/contracts/hashLockFTV2.json')
 
     // BSV20 fields
     const max = 10000n
@@ -25,19 +25,19 @@ async function main() {
     // create contract instance
     const message = toByteString('Hello sCrypt', true)
     const hash = sha256(message)
-    const hashLock = new HashLockFTV2(toByteString(''), sym, max, dec, hash)
+    const hashLock = new HashLockBSV21(toByteString(''), sym, max, dec, hash)
     await hashLock.connect(getSigner())
 
-    // deploy the new BSV20V2 token
+    // deploy the new BSV21 token
     const tokenId = await hashLock.deployToken({
         name: 'MEME TOKEN',
     })
     console.log(`tokenId: ${tokenId}`)
 
-    // for now, the contract instance holds the BSV20V2 token
+    // for now, the contract instance holds the BSV21 token
     // this token can be transferred only when the hash lock is solved
     const addressAlice = Addr(myAddress.toByteString())
-    const alice = new BSV20V2P2PKH(
+    const alice = new BSV21P2PKH(
         toByteString(tokenId, true),
         sym,
         max,
@@ -45,7 +45,7 @@ async function main() {
         addressAlice
     )
     const addressBob = Addr(myAddress.toByteString())
-    const bob = new BSV20V2P2PKH(
+    const bob = new BSV21P2PKH(
         toByteString(tokenId, true),
         sym,
         max,
@@ -64,7 +64,7 @@ async function main() {
                 amt: 5n,
             },
         ],
-    } as OrdiMethodCallOptions<HashLockFTV2>)
+    } as OrdiMethodCallOptions<HashLockBSV21>)
     console.log(`Transfer tx: ${transferTx.id}`)
 }
 
diff --git a/tests/examples/transferBSV20.ts b/tests/examples/transferBSV20.ts
index ec6e1e2..a11f32b 100644
--- a/tests/examples/transferBSV20.ts
+++ b/tests/examples/transferBSV20.ts
@@ -1,6 +1,6 @@
 import { TestWallet } from 'scrypt-ts'
 import { myPrivateKey } from '../utils/privateKey'
-import { BSV20V1P2PKH, OrdiProvider } from '../scrypt-ord'
+import { BSV20P2PKH, OrdiProvider } from '../scrypt-ord'
 
 /**
  * @returns mainnet signer
@@ -22,9 +22,9 @@ async function main() {
 
     const address = await signer.getDefaultAddress()
 
-    const p2pkhs = await BSV20V1P2PKH.getBSV20('VIVO', address.toString())
+    const p2pkhs = await BSV20P2PKH.getBSV20('VIVO', address.toString())
 
-    const { tx } = await BSV20V1P2PKH.transfer(p2pkhs, signer, [])
+    const { tx } = await BSV20P2PKH.transfer(p2pkhs, signer, [])
 
     console.log(`Transfer tx: ${tx.id}`)
 }
diff --git a/tests/examples/transferBSV20V2.ts b/tests/examples/transferBSV21.ts
similarity index 77%
rename from tests/examples/transferBSV20V2.ts
rename to tests/examples/transferBSV21.ts
index 8842ce2..5a25c1e 100644
--- a/tests/examples/transferBSV20V2.ts
+++ b/tests/examples/transferBSV21.ts
@@ -1,11 +1,11 @@
 import { TestWallet, toByteString, Addr, sha256 } from 'scrypt-ts'
 import { myAddress, myPrivateKey } from '../utils/privateKey'
 import {
-    BSV20V2P2PKH,
+    BSV21P2PKH,
     OrdiProvider,
     OrdiMethodCallOptions,
 } from '../scrypt-ord'
-import { HashLockFTV2 } from '../contracts/hashLockFTV2'
+import { HashLockBSV21 } from '../contracts/hashLockBSV21'
 /**
  * @returns mainnet signer
  */
@@ -14,7 +14,7 @@ function getSigner() {
 }
 
 async function main() {
-    HashLockFTV2.loadArtifact('tests/artifacts/contracts/hashLockFTV2.json')
+    HashLockBSV21.loadArtifact('tests/artifacts/contracts/hashLockFTV2.json')
 
     // BSV20 fields
     const max = 21000000n
@@ -25,13 +25,13 @@ async function main() {
 
     const message = toByteString('Hello sCrypt', true)
     const hash = sha256(message)
-    const hashLock = new HashLockFTV2(toByteString(''), sym, max, dec, hash)
+    const hashLock = new HashLockBSV21(toByteString(''), sym, max, dec, hash)
     await hashLock.connect(signer)
     const tokenId = await hashLock.deployToken()
 
     console.log(`tokenId: ${tokenId}`)
     const receiver = {
-        instance: new BSV20V2P2PKH(
+        instance: new BSV21P2PKH(
             toByteString(tokenId, true),
             sym,
             max,
@@ -42,7 +42,7 @@ async function main() {
     }
     const { tx } = await hashLock.methods.unlock(message, {
         transfer: receiver,
-    } as OrdiMethodCallOptions<HashLockFTV2>)
+    } as OrdiMethodCallOptions<HashLockBSV21>)
     console.log(`Transfer tx: ${tx.id}`)
 }
 
diff --git a/tests/examples/transferBSV20V2P2PKH.ts b/tests/examples/transferBSV21P2PKH.ts
similarity index 80%
rename from tests/examples/transferBSV20V2P2PKH.ts
rename to tests/examples/transferBSV21P2PKH.ts
index b2eb810..f3c0971 100644
--- a/tests/examples/transferBSV20V2P2PKH.ts
+++ b/tests/examples/transferBSV21P2PKH.ts
@@ -1,7 +1,7 @@
 import { TestWallet, toByteString, Addr, findSig, PubKey } from 'scrypt-ts'
 import { myPrivateKey, myPublicKey } from '../utils/privateKey'
 import {
-    BSV20V2P2PKH,
+    BSV21P2PKH,
     OrdiProvider,
     OrdiMethodCallOptions,
 } from '../scrypt-ord'
@@ -19,7 +19,7 @@ async function main() {
 
     await signer.connect()
     const address = await signer.getDefaultAddress()
-    const p2pkh = new BSV20V2P2PKH(
+    const p2pkh = new BSV21P2PKH(
         toByteString(''),
         sym,
         10000000n,
@@ -29,8 +29,8 @@ async function main() {
     await p2pkh.connect(signer)
     const tokenId = await p2pkh.deployToken()
     console.log(`tokenId: ${tokenId}`)
-    // const p2pkhs = await BSV20V2P2PKH.getBSV20(tokenId, address.toString())
-    // const {tx} = await BSV20V2P2PKH.transfer(p2pkhs, signer, [])
+    // const p2pkhs = await BSV21P2PKH.getBSV20(tokenId, address.toString())
+    // const {tx} = await BSV21P2PKH.transfer(p2pkhs, signer, [])
 
     const { tx } = await p2pkh.methods.unlock(
         (sigResponses) => findSig(sigResponses, myPublicKey),
@@ -38,7 +38,7 @@ async function main() {
         {
             transfer: [],
             pubKeyOrAddrToSign: myPublicKey,
-        } as OrdiMethodCallOptions<BSV20V2P2PKH>
+        } as OrdiMethodCallOptions<BSV21P2PKH>
     )
 
     console.log(`Transfer tx: ${tx.id}`)
diff --git a/tests/specs/bsv20V1P2PKH.spec.ts b/tests/specs/bsv20P2PKH.spec.ts
similarity index 90%
rename from tests/specs/bsv20V1P2PKH.spec.ts
rename to tests/specs/bsv20P2PKH.spec.ts
index 2a83aa3..45ce085 100644
--- a/tests/specs/bsv20V1P2PKH.spec.ts
+++ b/tests/specs/bsv20P2PKH.spec.ts
@@ -1,12 +1,12 @@
 import { expect, use } from 'chai'
 import { getDefaultSigner } from '../utils/txHelper'
 import chaiAsPromised from 'chai-as-promised'
-import { BSV20V1P2PKH } from '../scrypt-ord'
+import { BSV20P2PKH } from '../scrypt-ord'
 import { PubKey, findSig, Addr, toByteString } from 'scrypt-ts'
 import { dummyBSV20 } from './utils'
 use(chaiAsPromised)
 
-describe('Test SmartContract `BSV20V1P2PKH`', () => {
+describe('Test SmartContract `BSV20P2PKH`', () => {
     const tick = toByteString('DOGE', true)
     const max = 100000n
     const lim = max / 10n
@@ -15,11 +15,11 @@ describe('Test SmartContract `BSV20V1P2PKH`', () => {
     describe('hold bsv20', () => {
         const amt = 1000n
 
-        let instance: BSV20V1P2PKH
+        let instance: BSV20P2PKH
         const signer = getDefaultSigner()
         before(async () => {
             const address = await signer.getDefaultAddress()
-            instance = new BSV20V1P2PKH(
+            instance = new BSV20P2PKH(
                 tick,
                 max,
                 lim,
@@ -38,7 +38,7 @@ describe('Test SmartContract `BSV20V1P2PKH`', () => {
 
                 const recipients = [
                     {
-                        instance: new BSV20V1P2PKH(
+                        instance: new BSV20P2PKH(
                             tick,
                             max,
                             lim,
@@ -69,12 +69,12 @@ describe('Test SmartContract `BSV20V1P2PKH`', () => {
     })
 
     describe('from v1 utxo', () => {
-        let instance: BSV20V1P2PKH
+        let instance: BSV20P2PKH
         const signer = getDefaultSigner()
         before(async () => {
             const addr = await signer.getDefaultAddress()
             // put bsv20 inscription script at the end of locking script
-            instance = BSV20V1P2PKH.fromUTXO(
+            instance = BSV20P2PKH.fromUTXO(
                 dummyBSV20(addr, 'OOO1', 1n, false)
             )
 
@@ -88,7 +88,7 @@ describe('Test SmartContract `BSV20V1P2PKH`', () => {
                 const ordPubKey = await signer.getDefaultPubKey()
                 const recipients = [
                     {
-                        instance: new BSV20V1P2PKH(
+                        instance: new BSV20P2PKH(
                             tick,
                             max,
                             lim,
@@ -108,7 +108,7 @@ describe('Test SmartContract `BSV20V1P2PKH`', () => {
                 )
 
                 console.log('transfer tx: ', tx.id)
-                const receiver = recipients[0].instance as BSV20V1P2PKH
+                const receiver = recipients[0].instance as BSV20P2PKH
 
                 expect(receiver.getAmt()).to.equal(1n)
             }
@@ -118,11 +118,11 @@ describe('Test SmartContract `BSV20V1P2PKH`', () => {
     })
 
     describe('from v2 utxo', () => {
-        let instance: BSV20V1P2PKH
+        let instance: BSV20P2PKH
         const signer = getDefaultSigner()
         before(async () => {
             const addr = await signer.getDefaultAddress()
-            instance = BSV20V1P2PKH.fromUTXO(dummyBSV20(addr, tick, 6n))
+            instance = BSV20P2PKH.fromUTXO(dummyBSV20(addr, tick, 6n))
 
             await instance.connect(signer)
         })
@@ -132,7 +132,7 @@ describe('Test SmartContract `BSV20V1P2PKH`', () => {
                 const address = await signer.getDefaultAddress()
                 const recipients = [
                     {
-                        instance: new BSV20V1P2PKH(
+                        instance: new BSV20P2PKH(
                             tick,
                             max,
                             lim,
@@ -153,7 +153,7 @@ describe('Test SmartContract `BSV20V1P2PKH`', () => {
                 )
 
                 console.log('transfer tx: ', tx.id)
-                const receiver = recipients[0].instance as BSV20V1P2PKH
+                const receiver = recipients[0].instance as BSV20P2PKH
 
                 expect(receiver.getAmt()).to.equal(2n)
             }
diff --git a/tests/specs/bsv20V2P2PKH.spec.ts b/tests/specs/bsv21P2PKH.spec.ts
similarity index 78%
rename from tests/specs/bsv20V2P2PKH.spec.ts
rename to tests/specs/bsv21P2PKH.spec.ts
index 670f258..30f3a8f 100644
--- a/tests/specs/bsv20V2P2PKH.spec.ts
+++ b/tests/specs/bsv21P2PKH.spec.ts
@@ -1,7 +1,7 @@
 import { expect, use } from 'chai'
 import { getDefaultSigner } from '../utils/txHelper'
 import chaiAsPromised from 'chai-as-promised'
-import { BSV20V2P2PKH } from '../scrypt-ord'
+import { BSV21P2PKH } from '../scrypt-ord'
 import {
     PubKey,
     findSig,
@@ -10,29 +10,29 @@ import {
     fromByteString,
     ByteString,
 } from 'scrypt-ts'
-import { dummyBSV20V2 } from './utils'
+import { dummyBSV21 } from './utils'
 use(chaiAsPromised)
 
-describe('Test SmartContract `BSV20V2P2PKH`', () => {
+describe('Test SmartContract `BSV21P2PKH`', () => {
     let tokenId: ByteString
     const sym: ByteString = toByteString('1SAT', true)
     const max = 100000n
     const dec = 0n
 
     describe('hold bsv20', () => {
-        let bsv20V2P2PKH: BSV20V2P2PKH
+        let bsv21P2PKH: BSV21P2PKH
         const signer = getDefaultSigner()
         before(async () => {
             const address = await signer.getDefaultAddress()
-            bsv20V2P2PKH = new BSV20V2P2PKH(
+            bsv21P2PKH = new BSV21P2PKH(
                 toByteString(''),
                 sym,
                 max,
                 dec,
                 Addr(address.toByteString())
             )
-            await bsv20V2P2PKH.connect(getDefaultSigner())
-            const tokenIdStr = await bsv20V2P2PKH.deployToken()
+            await bsv21P2PKH.connect(getDefaultSigner())
+            const tokenIdStr = await bsv21P2PKH.deployToken()
             tokenId = toByteString(tokenIdStr, true)
         })
 
@@ -43,7 +43,7 @@ describe('Test SmartContract `BSV20V2P2PKH`', () => {
 
                 const recipients = [
                     {
-                        instance: new BSV20V2P2PKH(
+                        instance: new BSV21P2PKH(
                             tokenId,
                             sym,
                             max,
@@ -53,7 +53,7 @@ describe('Test SmartContract `BSV20V2P2PKH`', () => {
                         amt: 100n,
                     },
                 ]
-                const { tx } = await bsv20V2P2PKH.methods.unlock(
+                const { tx } = await bsv21P2PKH.methods.unlock(
                     (sigResps) => findSig(sigResps, ordPubKey),
                     PubKey(ordPubKey.toByteString()),
                     {
@@ -74,16 +74,16 @@ describe('Test SmartContract `BSV20V2P2PKH`', () => {
     })
 
     describe('from v1 utxo', () => {
-        let bsv20V2P2PKH: BSV20V2P2PKH
+        let bsv21P2PKH: BSV21P2PKH
         const signer = getDefaultSigner()
         before(async () => {
             const addr = await signer.getDefaultAddress()
             // put bsv20 inscription script at the end of locking script
-            bsv20V2P2PKH = BSV20V2P2PKH.fromUTXO(
-                dummyBSV20V2(addr, fromByteString(tokenId), 1n, false)
+            bsv21P2PKH = BSV21P2PKH.fromUTXO(
+                dummyBSV21(addr, fromByteString(tokenId), 1n, false)
             )
 
-            await bsv20V2P2PKH.connect(signer)
+            await bsv21P2PKH.connect(signer)
         })
 
         it('transfer should pass.', async () => {
@@ -93,7 +93,7 @@ describe('Test SmartContract `BSV20V2P2PKH`', () => {
                 const ordPubKey = await signer.getDefaultPubKey()
                 const recipients = [
                     {
-                        instance: new BSV20V2P2PKH(
+                        instance: new BSV21P2PKH(
                             tokenId,
                             sym,
                             max,
@@ -103,7 +103,7 @@ describe('Test SmartContract `BSV20V2P2PKH`', () => {
                         amt: 1n,
                     },
                 ]
-                const { tx } = await bsv20V2P2PKH.methods.unlock(
+                const { tx } = await bsv21P2PKH.methods.unlock(
                     (sigResps) => findSig(sigResps, ordPubKey),
                     PubKey(ordPubKey.toByteString()),
                     {
@@ -113,7 +113,7 @@ describe('Test SmartContract `BSV20V2P2PKH`', () => {
                 )
 
                 console.log('transfer tx: ', tx.id)
-                const receiver = recipients[0].instance as BSV20V2P2PKH
+                const receiver = recipients[0].instance as BSV21P2PKH
 
                 expect(receiver.getAmt()).to.equal(1n)
             }
@@ -123,15 +123,15 @@ describe('Test SmartContract `BSV20V2P2PKH`', () => {
     })
 
     describe('from v2 utxo', () => {
-        let BSV20V1P2PKH: BSV20V2P2PKH
+        let BSV20P2PKH: BSV21P2PKH
         const signer = getDefaultSigner()
         before(async () => {
             const addr = await signer.getDefaultAddress()
-            BSV20V1P2PKH = BSV20V2P2PKH.fromUTXO(
-                dummyBSV20V2(addr, fromByteString(tokenId), 6n)
+            BSV20P2PKH = BSV21P2PKH.fromUTXO(
+                dummyBSV21(addr, fromByteString(tokenId), 6n)
             )
 
-            await BSV20V1P2PKH.connect(signer)
+            await BSV20P2PKH.connect(signer)
         })
 
         it('transfer should pass.', async () => {
@@ -139,7 +139,7 @@ describe('Test SmartContract `BSV20V2P2PKH`', () => {
                 const address = await signer.getDefaultAddress()
                 const recipients = [
                     {
-                        instance: new BSV20V2P2PKH(
+                        instance: new BSV21P2PKH(
                             tokenId,
                             sym,
                             max,
@@ -150,7 +150,7 @@ describe('Test SmartContract `BSV20V2P2PKH`', () => {
                     },
                 ]
                 const ordPubKey = await signer.getDefaultPubKey()
-                const { tx } = await BSV20V1P2PKH.methods.unlock(
+                const { tx } = await BSV20P2PKH.methods.unlock(
                     (sigResps) => findSig(sigResps, ordPubKey),
                     PubKey(ordPubKey.toByteString()),
                     {
@@ -160,7 +160,7 @@ describe('Test SmartContract `BSV20V2P2PKH`', () => {
                 )
 
                 console.log('transfer tx: ', tx.id)
-                const receiver = recipients[0].instance as BSV20V2P2PKH
+                const receiver = recipients[0].instance as BSV21P2PKH
 
                 expect(receiver.getAmt()).to.equal(2n)
             }
diff --git a/tests/specs/chainFT.spec.ts b/tests/specs/chainBSV20.spec.ts
similarity index 78%
rename from tests/specs/chainFT.spec.ts
rename to tests/specs/chainBSV20.spec.ts
index f877b14..d728a0d 100644
--- a/tests/specs/chainFT.spec.ts
+++ b/tests/specs/chainBSV20.spec.ts
@@ -7,21 +7,21 @@ import {
     fromByteString,
     Addr,
 } from 'scrypt-ts'
-import { HashLockFT } from '../contracts/hashLockFT'
+import { HashLockBSV20 } from '../contracts/hashLockBSV20'
 import { getDefaultSigner } from '../utils/txHelper'
 import chaiAsPromised from 'chai-as-promised'
-import { BSV20V1P2PKH, OrdiMethodCallOptions } from '../scrypt-ord'
+import { BSV20P2PKH, OrdiMethodCallOptions } from '../scrypt-ord'
 import { dummyBSV20 } from './utils'
 import { myAddress, myPublicKey } from '../utils/privateKey'
-import { CounterFT } from '../contracts/counterFT'
+import { CounterBSV20 } from '../contracts/counterBSV20'
 use(chaiAsPromised)
 
 const chain = 'P2PKH -> HashLock -> Counter -> Counter -> HashLock -> P2PKH'
 
 describe(`Chain FT Test: ${chain}`, () => {
     before(async () => {
-        HashLockFT.loadArtifact()
-        CounterFT.loadArtifact()
+        HashLockBSV20.loadArtifact()
+        CounterBSV20.loadArtifact()
     })
 
     const text = 'Hello sCrypt!'
@@ -39,20 +39,20 @@ describe(`Chain FT Test: ${chain}`, () => {
     const tokenToHashLockAgain = 300n
     const tokenToP2PKH = 120n
 
-    async function createP2PKH(): Promise<BSV20V1P2PKH> {
-        const p2pkh = BSV20V1P2PKH.fromUTXO(
+    async function createP2PKH(): Promise<BSV20P2PKH> {
+        const p2pkh = BSV20P2PKH.fromUTXO(
             dummyBSV20(myAddress, fromByteString(tick), tokenInP2PKH)
         )
         await p2pkh.connect(getDefaultSigner())
         return p2pkh
     }
 
-    async function toHashLock(p2pkh: BSV20V1P2PKH): Promise<HashLockFT> {
+    async function toHashLock(p2pkh: BSV20P2PKH): Promise<HashLockBSV20> {
         const totalAmount = tokenInP2PKH
         const transferAmount = tokenToHashLock
         const changeAmount = totalAmount - transferAmount
 
-        const hashLock = new HashLockFT(tick, max, lim, dec, hash)
+        const hashLock = new HashLockBSV20(tick, max, lim, dec, hash)
         await hashLock.connect(getDefaultSigner())
 
         const { tx, nexts } = await p2pkh.methods.unlock(
@@ -64,7 +64,7 @@ describe(`Chain FT Test: ${chain}`, () => {
                     amt: transferAmount,
                 },
                 pubKeyOrAddrToSign: myPublicKey,
-            } as OrdiMethodCallOptions<BSV20V1P2PKH>
+            } as OrdiMethodCallOptions<BSV20P2PKH>
         )
         console.log('[1] P2PKH -> HashLock:', tx.id)
 
@@ -72,18 +72,18 @@ describe(`Chain FT Test: ${chain}`, () => {
 
         expect(hashLock.getAmt()).to.equal(transferAmount)
 
-        const tokenChange = nexts[1].instance as BSV20V1P2PKH
+        const tokenChange = nexts[1].instance as BSV20P2PKH
         expect(tokenChange.getAmt()).to.equal(changeAmount)
 
         return hashLock
     }
 
-    async function toCounter(hashLock: HashLockFT): Promise<CounterFT> {
+    async function toCounter(hashLock: HashLockBSV20): Promise<CounterBSV20> {
         const totalAmount = tokenToHashLock
         const transferAmount = tokenToCounter
         const changeAmount = totalAmount - transferAmount
 
-        const counter = new CounterFT(tick, max, lim, dec, 0n)
+        const counter = new CounterBSV20(tick, max, lim, dec, 0n)
         await counter.connect(getDefaultSigner())
 
         const { tx, nexts } = await hashLock.methods.unlock(
@@ -93,7 +93,7 @@ describe(`Chain FT Test: ${chain}`, () => {
                     instance: counter,
                     amt: transferAmount,
                 },
-            } as OrdiMethodCallOptions<HashLockFT>
+            } as OrdiMethodCallOptions<HashLockBSV20>
         )
         console.log('[2] HashLock -> Counter:', tx.id)
 
@@ -101,13 +101,13 @@ describe(`Chain FT Test: ${chain}`, () => {
 
         expect(counter.getAmt()).to.equal(transferAmount)
 
-        const tokenChange = nexts[1].instance as BSV20V1P2PKH
+        const tokenChange = nexts[1].instance as BSV20P2PKH
         expect(tokenChange.getAmt()).to.equal(changeAmount)
 
         return counter
     }
 
-    async function toCounterAgain(counter: CounterFT): Promise<CounterFT> {
+    async function toCounterAgain(counter: CounterBSV20): Promise<CounterBSV20> {
         const totalAmount = tokenToCounter
         const transferAmount = tokenToCounterAgain
         const changeAmount = totalAmount - transferAmount
@@ -120,20 +120,20 @@ describe(`Chain FT Test: ${chain}`, () => {
                 instance: nextInstance,
                 amt: transferAmount,
             },
-        } as OrdiMethodCallOptions<CounterFT>)
+        } as OrdiMethodCallOptions<CounterBSV20>)
         console.log('[3] Counter -> Counter:', tx.id)
 
         expect(nexts.length).to.equal(2)
 
         expect(nextInstance.getAmt()).to.equal(transferAmount)
 
-        const tokenChange = nexts[1].instance as BSV20V1P2PKH
+        const tokenChange = nexts[1].instance as BSV20P2PKH
         expect(tokenChange.getAmt()).to.equal(changeAmount)
 
         return nextInstance
     }
 
-    async function toHashLockAgain(counter: CounterFT): Promise<HashLockFT> {
+    async function toHashLockAgain(counter: CounterBSV20): Promise<HashLockBSV20> {
         const totalAmount = tokenToCounterAgain
         const hashLockAmount = tokenToHashLockAgain
         const counterAmount = 100n
@@ -142,7 +142,7 @@ describe(`Chain FT Test: ${chain}`, () => {
         const nextInstance = counter.next()
         nextInstance.incCounter()
 
-        const hashLock = new HashLockFT(tick, max, lim, dec, hash)
+        const hashLock = new HashLockBSV20(tick, max, lim, dec, hash)
         await hashLock.connect(getDefaultSigner())
 
         const { tx, nexts } = await counter.methods.inc(counterAmount, {
@@ -156,7 +156,7 @@ describe(`Chain FT Test: ${chain}`, () => {
                     amt: hashLockAmount,
                 },
             ],
-        } as OrdiMethodCallOptions<CounterFT>)
+        } as OrdiMethodCallOptions<CounterBSV20>)
         console.log('[4] Counter -> HashLock:', tx.id)
 
         expect(nexts.length).to.equal(3)
@@ -164,14 +164,14 @@ describe(`Chain FT Test: ${chain}`, () => {
         expect(nextInstance.getAmt()).to.equal(counterAmount)
         expect(hashLock.getAmt()).to.equal(hashLockAmount)
 
-        const tokenChange = nexts[2].instance as BSV20V1P2PKH
+        const tokenChange = nexts[2].instance as BSV20P2PKH
         expect(tokenChange.getAmt()).to.equal(changeAmount)
 
         return hashLock
     }
 
-    async function toP2PKH(hashLock: HashLockFT) {
-        const p2pkh = new BSV20V1P2PKH(
+    async function toP2PKH(hashLock: HashLockBSV20) {
+        const p2pkh = new BSV20P2PKH(
             tick,
             max,
             lim,
@@ -188,7 +188,7 @@ describe(`Chain FT Test: ${chain}`, () => {
                     amt: tokenToP2PKH,
                 },
                 skipTokenChange: true,
-            } as OrdiMethodCallOptions<HashLockFT>
+            } as OrdiMethodCallOptions<HashLockBSV20>
         )
         console.log('[5] HashLock -> P2PKH:', tx.id)
 
diff --git a/tests/specs/counterFT.spec.ts b/tests/specs/counterBSV20.spec.ts
similarity index 80%
rename from tests/specs/counterFT.spec.ts
rename to tests/specs/counterBSV20.spec.ts
index 1bf28da..752080b 100644
--- a/tests/specs/counterFT.spec.ts
+++ b/tests/specs/counterBSV20.spec.ts
@@ -1,23 +1,23 @@
 import { expect, use } from 'chai'
 import { toByteString } from 'scrypt-ts'
-import { CounterFT } from '../contracts/counterFT'
+import { CounterBSV20 } from '../contracts/counterBSV20'
 import { getDefaultSigner } from '../utils/txHelper'
 import chaiAsPromised from 'chai-as-promised'
-import { BSV20V1P2PKH, OrdiMethodCallOptions } from '../scrypt-ord'
+import { BSV20P2PKH, OrdiMethodCallOptions } from '../scrypt-ord'
 use(chaiAsPromised)
 
-describe('Test SmartContract `CounterFT`', () => {
-    let instance: CounterFT
+describe('Test SmartContract `CounterBSV20`', () => {
+    let instance: CounterBSV20
 
     before(async () => {
-        CounterFT.loadArtifact()
+        CounterBSV20.loadArtifact()
 
         const tick = 'DOGE'
         const max = 100000n
         const lim = max / 10n
         const amt = lim
         const dec = 0n
-        instance = new CounterFT(toByteString(tick, true), max, lim, dec, 0n)
+        instance = new CounterBSV20(toByteString(tick, true), max, lim, dec, 0n)
         await instance.connect(getDefaultSigner())
 
         await instance.deployToken()
@@ -46,12 +46,12 @@ describe('Test SmartContract `CounterFT`', () => {
                             instance: nextInstance,
                             amt: transferAmount,
                         },
-                    } as OrdiMethodCallOptions<CounterFT>
+                    } as OrdiMethodCallOptions<CounterBSV20>
                 )
                 console.log('Contract CounterFT called: ', tx.id)
                 expect(nexts.length).to.equal(2)
                 expect(nextInstance.getAmt()).to.equal(transferAmount)
-                const tokenChange = nexts[1].instance as BSV20V1P2PKH
+                const tokenChange = nexts[1].instance as BSV20P2PKH
                 expect(tokenChange.getAmt()).to.equal(changeAmount)
             }
             await expect(callContract()).not.to.be.rejected
diff --git a/tests/specs/counterFTV2.spec.ts b/tests/specs/counterBSV21.spec.ts
similarity index 81%
rename from tests/specs/counterFTV2.spec.ts
rename to tests/specs/counterBSV21.spec.ts
index 781717e..48f21d6 100644
--- a/tests/specs/counterFTV2.spec.ts
+++ b/tests/specs/counterBSV21.spec.ts
@@ -1,22 +1,22 @@
 import { expect, use } from 'chai'
 import { toByteString } from 'scrypt-ts'
-import { CounterFTV2 } from '../contracts/counterFTV2'
+import { CounterBSV21 } from '../contracts/counterBSV21'
 import { getDefaultSigner } from '../utils/txHelper'
 import chaiAsPromised from 'chai-as-promised'
-import { BSV20V2P2PKH, OrdiMethodCallOptions } from '../scrypt-ord'
+import { BSV21P2PKH, OrdiMethodCallOptions } from '../scrypt-ord'
 use(chaiAsPromised)
 
-describe('Test SmartContract `CounterFTV2`', () => {
-    let instance: CounterFTV2
+describe('Test SmartContract `CounterBSV21`', () => {
+    let instance: CounterBSV21
 
     let tokenId: string
     const sym = toByteString('MEME', true)
     before(async () => {
-        CounterFTV2.loadArtifact()
+        CounterBSV21.loadArtifact()
 
         const max = 100000n
         const dec = 0n
-        instance = new CounterFTV2(toByteString(''), sym, max, dec, 0n)
+        instance = new CounterBSV21(toByteString(''), sym, max, dec, 0n)
         await instance.connect(getDefaultSigner())
         tokenId = await instance.deployToken()
     })
@@ -44,12 +44,12 @@ describe('Test SmartContract `CounterFTV2`', () => {
                             instance: nextInstance,
                             amt: transferAmount,
                         },
-                    } as OrdiMethodCallOptions<CounterFTV2>
+                    } as OrdiMethodCallOptions<CounterBSV21>
                 )
                 console.log('Contract CounterFTV2 called: ', tx.id)
                 expect(nexts.length).to.equal(2)
                 expect(nextInstance.getAmt()).to.equal(transferAmount)
-                const tokenChange = nexts[1].instance as BSV20V2P2PKH
+                const tokenChange = nexts[1].instance as BSV21P2PKH
                 expect(tokenChange.getAmt()).to.equal(changeAmount)
             }
             await expect(callContract()).not.to.be.rejected
diff --git a/tests/specs/fromTx.spec.ts b/tests/specs/fromTx.spec.ts
index 9289190..b84d7f1 100644
--- a/tests/specs/fromTx.spec.ts
+++ b/tests/specs/fromTx.spec.ts
@@ -1,5 +1,5 @@
 import { Addr, PubKey, findSig, fromByteString, toByteString } from "scrypt-ts"
-import { BSV20V1P2PKH, BSV20V2P2PKH, Ordinal } from "../scrypt-ord"
+import { BSV20P2PKH, BSV21P2PKH, Ordinal } from "../scrypt-ord"
 import { myAddress, myPublicKey } from "../utils/privateKey"
 import { getDefaultSigner } from "../utils/txHelper"
 import { expect, use } from "chai"
@@ -8,19 +8,19 @@ use(chaiAsPromised)
 
 describe('Test `fromTx`', () => {
 
-    it('BSV20V1P2PKH', async () => {
+    it('BSV20P2PKH', async () => {
         const tick = toByteString('abcd', true)
         const max = 100n
         const lim = 10n
         const dec = 0n
         const addr = Addr(myAddress.toByteString())
         // mint token
-        const instance = new BSV20V1P2PKH(tick, max, lim, dec, addr)
+        const instance = new BSV20P2PKH(tick, max, lim, dec, addr)
         await instance.connect(getDefaultSigner())
         await instance.deployToken()
         const mintTx = await instance.mint(lim)
         // recover instance from the mint tx
-        const recoveredInstance = BSV20V1P2PKH.fromTx(mintTx, 0)
+        const recoveredInstance = BSV20P2PKH.fromTx(mintTx, 0)
         await recoveredInstance.connect(getDefaultSigner())
         // call
         const callContract = async () => recoveredInstance.methods.unlock(
@@ -29,7 +29,7 @@ describe('Test `fromTx`', () => {
             {
                 pubKeyOrAddrToSign: myPublicKey,
                 transfer: {
-                    instance: new BSV20V1P2PKH(tick, max, lim, dec, addr),
+                    instance: new BSV20P2PKH(tick, max, lim, dec, addr),
                     amt: 1n
                 }
             }
@@ -37,13 +37,13 @@ describe('Test `fromTx`', () => {
         return expect(callContract()).not.rejected
     })
 
-    it('BSV20V2P2PKH', async () => {
+    it('BSV21P2PKH', async () => {
         const sym = toByteString('abcd', true)
         const amt = 100n
         const dec = 0n
         const addr = Addr(myAddress.toByteString())
         // deploy token
-        const instance = new BSV20V2P2PKH(toByteString(''), sym, amt, dec, addr)
+        const instance = new BSV21P2PKH(toByteString(''), sym, amt, dec, addr)
         await instance.connect(getDefaultSigner())
         instance.prependNOPScript(Ordinal.createDeployV2(
             fromByteString(instance.sym),
@@ -53,7 +53,7 @@ describe('Test `fromTx`', () => {
         const deployTx = await instance.deploy(1)
         const tokenId = toByteString(`${deployTx.id}_0`, true)
         // recover instance from the deploy tx
-        const recoveredInstance = BSV20V2P2PKH.fromTx(deployTx, 0)
+        const recoveredInstance = BSV21P2PKH.fromTx(deployTx, 0)
         await recoveredInstance.connect(getDefaultSigner())
         // call
         const callContract = async () => recoveredInstance.methods.unlock(
@@ -62,7 +62,7 @@ describe('Test `fromTx`', () => {
             {
                 pubKeyOrAddrToSign: myPublicKey,
                 transfer: {
-                    instance: new BSV20V2P2PKH(tokenId, sym, amt, dec, addr),
+                    instance: new BSV21P2PKH(tokenId, sym, amt, dec, addr),
                     amt: 1n
                 }
             }
diff --git a/tests/specs/fromTxCounterFT.spec.ts b/tests/specs/fromTxCounterBSV20.spec.ts
similarity index 79%
rename from tests/specs/fromTxCounterFT.spec.ts
rename to tests/specs/fromTxCounterBSV20.spec.ts
index f639032..7310772 100644
--- a/tests/specs/fromTxCounterFT.spec.ts
+++ b/tests/specs/fromTxCounterBSV20.spec.ts
@@ -1,12 +1,12 @@
 import { expect, use } from 'chai'
 import { bsv, toByteString } from 'scrypt-ts'
-import { CounterFT } from '../contracts/counterFT'
+import { CounterBSV20 } from '../contracts/counterBSV20'
 import { getDefaultSigner } from '../utils/txHelper'
 import chaiAsPromised from 'chai-as-promised'
-import { BSV20V1P2PKH, OrdiMethodCallOptions } from '../scrypt-ord'
+import { BSV20P2PKH, OrdiMethodCallOptions } from '../scrypt-ord'
 use(chaiAsPromised)
 
-describe('Test fromTx for SmartContract `CounterFT`', () => {
+describe('Test fromTx for SmartContract `CounterBSV20`', () => {
     const tick = toByteString('DOGE', true)
     const max = 100000n
     const lim = max / 10n
@@ -15,8 +15,8 @@ describe('Test fromTx for SmartContract `CounterFT`', () => {
     let deployTx: bsv.Transaction
 
     before(async () => {
-        CounterFT.loadArtifact()
-        const counter = new CounterFT(tick, max, lim, dec, 0n)
+        CounterBSV20.loadArtifact()
+        const counter = new CounterBSV20(tick, max, lim, dec, 0n)
         await counter.connect(getDefaultSigner())
         await counter.deployToken()
         deployTx = await counter.mint(1000n)
@@ -27,7 +27,7 @@ describe('Test fromTx for SmartContract `CounterFT`', () => {
         outputIndex: number
     ): Promise<{ tx: bsv.Transaction; atOutputIndex: number }> {
         // create instance from tx
-        const instance = CounterFT.fromTx(tx, outputIndex)
+        const instance = CounterBSV20.fromTx(tx, outputIndex)
         await instance.connect(getDefaultSigner())
 
         const nextInstance = instance.next()
@@ -43,12 +43,12 @@ describe('Test fromTx for SmartContract `CounterFT`', () => {
                     instance: nextInstance,
                     amt: transferAmount,
                 },
-            } as OrdiMethodCallOptions<CounterFT>
+            } as OrdiMethodCallOptions<CounterBSV20>
         )
 
         expect(nexts.length).to.equal(2)
         expect(nextInstance.getAmt()).to.equal(transferAmount)
-        const tokenChange = nexts[1].instance as BSV20V1P2PKH
+        const tokenChange = nexts[1].instance as BSV20P2PKH
         expect(tokenChange.getAmt()).to.equal(changeAmount)
 
         return { tx: callTx, atOutputIndex: nexts[0]!.atOutputIndex }
diff --git a/tests/specs/fromTxHashLockFT.spec.ts b/tests/specs/fromTxHashLockBSV20.spec.ts
similarity index 74%
rename from tests/specs/fromTxHashLockFT.spec.ts
rename to tests/specs/fromTxHashLockBSV20.spec.ts
index 7517b9b..7747881 100644
--- a/tests/specs/fromTxHashLockFT.spec.ts
+++ b/tests/specs/fromTxHashLockBSV20.spec.ts
@@ -1,13 +1,13 @@
 import { expect, use } from 'chai'
 import { sha256, toByteString, bsv, Addr } from 'scrypt-ts'
-import { HashLockFT } from '../contracts/hashLockFT'
+import { HashLockBSV20 } from '../contracts/hashLockBSV20'
 import { getDefaultSigner } from '../utils/txHelper'
 import chaiAsPromised from 'chai-as-promised'
-import { BSV20V1P2PKH } from '../scrypt-ord'
+import { BSV20P2PKH } from '../scrypt-ord'
 import { myAddress } from '../utils/privateKey'
 use(chaiAsPromised)
 
-describe('Test fromTx for SmartContract `HashLockFT`', () => {
+describe('Test fromTx for SmartContract `HashLockBSV20`', () => {
     const tick = toByteString('DOGE', true)
     const max = 100000n
     const lim = max / 10n
@@ -19,9 +19,9 @@ describe('Test fromTx for SmartContract `HashLockFT`', () => {
     const deployOutputIndex = 0
 
     before(async () => {
-        HashLockFT.loadArtifact()
+        HashLockBSV20.loadArtifact()
         const hash = sha256(message)
-        const hashLock = new HashLockFT(tick, max, lim, dec, hash)
+        const hashLock = new HashLockBSV20(tick, max, lim, dec, hash)
         await hashLock.connect(getDefaultSigner())
         await hashLock.deployToken()
         deployTx = await hashLock.mint(100n)
@@ -29,11 +29,11 @@ describe('Test fromTx for SmartContract `HashLockFT`', () => {
 
     it('should unlock successfully after instance recovery', async () => {
         // create instance from deploy tx
-        const hashLock = HashLockFT.fromTx(deployTx, deployOutputIndex)
+        const hashLock = HashLockBSV20.fromTx(deployTx, deployOutputIndex)
         await hashLock.connect(getDefaultSigner())
 
         const addr = Addr(myAddress.toByteString())
-        const receiver = new BSV20V1P2PKH(tick, max, lim, dec, addr)
+        const receiver = new BSV20P2PKH(tick, max, lim, dec, addr)
         const call = async () =>
             await hashLock.methods.unlock(message, {
                 transfer: {
diff --git a/tests/specs/hashLockFT.spec.ts b/tests/specs/hashLockBSV20.spec.ts
similarity index 81%
rename from tests/specs/hashLockFT.spec.ts
rename to tests/specs/hashLockBSV20.spec.ts
index e5d3e5d..b7fa82d 100644
--- a/tests/specs/hashLockFT.spec.ts
+++ b/tests/specs/hashLockBSV20.spec.ts
@@ -1,22 +1,22 @@
 import { expect, use } from 'chai'
 import { sha256, toByteString } from 'scrypt-ts'
-import { HashLockFT } from '../contracts/hashLockFT'
+import { HashLockBSV20 } from '../contracts/hashLockBSV20'
 import { getDefaultSigner } from '../utils/txHelper'
 import chaiAsPromised from 'chai-as-promised'
-import { BSV20V1P2PKH, FTReceiver, OrdiMethodCallOptions } from '../scrypt-ord'
+import { BSV20P2PKH, FTReceiver, OrdiMethodCallOptions } from '../scrypt-ord'
 use(chaiAsPromised)
 
-describe('Test SmartContract `HashLockFT`', () => {
+describe('Test SmartContract `HashLockBSV20`', () => {
     const tick = toByteString('DOGE', true)
     const max = 100000n
     const lim = max / 10n
     const amt = 1000n
     const dec = 0n
 
-    let hashLock: HashLockFT
+    let hashLock: HashLockBSV20
     before(async () => {
-        HashLockFT.loadArtifact()
-        hashLock = new HashLockFT(
+        HashLockBSV20.loadArtifact()
+        hashLock = new HashLockBSV20(
             tick,
             max,
             lim,
@@ -32,7 +32,7 @@ describe('Test SmartContract `HashLockFT`', () => {
     it('transfer to an other hashLock.', async () => {
         const callContract = async () => {
             for (let i = 0; i < 3; i++) {
-                const receiver = new HashLockFT(
+                const receiver = new HashLockBSV20(
                     tick,
                     max,
                     lim,
@@ -54,7 +54,7 @@ describe('Test SmartContract `HashLockFT`', () => {
                     }
                 )
 
-                hashLock = recipients[0].instance as HashLockFT
+                hashLock = recipients[0].instance as HashLockBSV20
                 await hashLock.connect(getDefaultSigner())
 
                 console.log('transfer tx: ', tx.id)
@@ -66,7 +66,7 @@ describe('Test SmartContract `HashLockFT`', () => {
 
     it('transfer to an other hashLock with change.', async () => {
         const callContract = async () => {
-            const receiver = new HashLockFT(
+            const receiver = new HashLockBSV20(
                 tick,
                 max,
                 lim,
@@ -85,18 +85,18 @@ describe('Test SmartContract `HashLockFT`', () => {
                 toByteString(`hello, sCrypt!:3`, true),
                 {
                     transfer: recipients,
-                } as OrdiMethodCallOptions<HashLockFT>
+                } as OrdiMethodCallOptions<HashLockBSV20>
             )
 
             console.log('transfer tx: ', tx.id)
 
             expect(nexts.length === 2).to.be.true
 
-            const p2pkh = nexts[1].instance as BSV20V1P2PKH
+            const p2pkh = nexts[1].instance as BSV20P2PKH
 
             expect(p2pkh.getAmt()).to.be.equal(1n)
 
-            hashLock = recipients[0].instance as HashLockFT
+            hashLock = recipients[0].instance as HashLockBSV20
             await hashLock.connect(getDefaultSigner())
         }
 
@@ -105,7 +105,7 @@ describe('Test SmartContract `HashLockFT`', () => {
 
     it('transfer to an other hashLock without change.', async () => {
         const callContract = async () => {
-            const receiver = new HashLockFT(
+            const receiver = new HashLockBSV20(
                 tick,
                 max,
                 lim,
@@ -125,7 +125,7 @@ describe('Test SmartContract `HashLockFT`', () => {
                 {
                     transfer: recipients,
                     skipTokenChange: true,
-                } as OrdiMethodCallOptions<HashLockFT>
+                } as OrdiMethodCallOptions<HashLockBSV20>
             )
 
             console.log('transfer tx: ', tx.id)
@@ -142,14 +142,14 @@ describe('Test SmartContract `HashLockFT`', () => {
                 toByteString(`hello, sCrypt!`, true),
                 {
                     skipTokenChange: false,
-                } as OrdiMethodCallOptions<HashLockFT>
+                } as OrdiMethodCallOptions<HashLockBSV20>
             )
 
             console.log('transfer tx: ', tx.id)
 
             expect(nexts.length === 1).to.be.true
 
-            expect(nexts[0].instance instanceof BSV20V1P2PKH).to.be.true
+            expect(nexts[0].instance instanceof BSV20P2PKH).to.be.true
 
             expect(nexts[0].instance.getAmt() === 9n).to.be.true
         }
@@ -158,7 +158,7 @@ describe('Test SmartContract `HashLockFT`', () => {
     })
 
     it('should fail when passing incorrect message', async () => {
-        const receiver = new HashLockFT(
+        const receiver = new HashLockBSV20(
             tick,
             max,
             lim,
@@ -173,7 +173,7 @@ describe('Test SmartContract `HashLockFT`', () => {
                         instance: receiver,
                         amt: 9n,
                     },
-                } as OrdiMethodCallOptions<HashLockFT>
+                } as OrdiMethodCallOptions<HashLockBSV20>
             )
         await expect(call()).to.be.rejectedWith(/hashes are not equal/)
     })
diff --git a/tests/specs/hashLockFTV2.spec.ts b/tests/specs/hashLockBSV21.spec.ts
similarity index 83%
rename from tests/specs/hashLockFTV2.spec.ts
rename to tests/specs/hashLockBSV21.spec.ts
index 9ce4488..6a0de78 100644
--- a/tests/specs/hashLockFTV2.spec.ts
+++ b/tests/specs/hashLockBSV21.spec.ts
@@ -1,21 +1,21 @@
 import { expect, use } from 'chai'
 import { sha256, toByteString } from 'scrypt-ts'
-import { HashLockFTV2 } from '../contracts/hashLockFTV2'
+import { HashLockBSV21 } from '../contracts/hashLockBSV21'
 import { getDefaultSigner } from '../utils/txHelper'
 import chaiAsPromised from 'chai-as-promised'
-import { BSV20V2P2PKH, FTReceiver, OrdiMethodCallOptions } from '../scrypt-ord'
+import { BSV21P2PKH, FTReceiver, OrdiMethodCallOptions } from '../scrypt-ord'
 use(chaiAsPromised)
 
-describe('Test SmartContract `HashLockFTV2`', () => {
+describe('Test SmartContract `HashLockBSV21`', () => {
     const max = 100000n
     const dec = 0n
     const sym = toByteString('MEME', true)
 
-    let hashLock: HashLockFTV2
+    let hashLock: HashLockBSV21
     let tokenId: string
     before(async () => {
-        HashLockFTV2.loadArtifact()
-        hashLock = new HashLockFTV2(
+        HashLockBSV21.loadArtifact()
+        hashLock = new HashLockBSV21(
             toByteString(''),
             sym,
             max,
@@ -31,7 +31,7 @@ describe('Test SmartContract `HashLockFTV2`', () => {
     it('transfer to an other hashLock.', async () => {
         const callContract = async () => {
             for (let i = 0; i < 3; i++) {
-                const receiver = new HashLockFTV2(
+                const receiver = new HashLockBSV21(
                     toByteString(tokenId, true),
                     sym,
                     max,
@@ -53,7 +53,7 @@ describe('Test SmartContract `HashLockFTV2`', () => {
                     }
                 )
 
-                hashLock = recipients[0].instance as unknown as HashLockFTV2
+                hashLock = recipients[0].instance as unknown as HashLockBSV21
                 await hashLock.connect(getDefaultSigner())
 
                 console.log('transfer tx: ', tx.id)
@@ -65,7 +65,7 @@ describe('Test SmartContract `HashLockFTV2`', () => {
 
     it('transfer to an other hashLock with change.', async () => {
         const callContract = async () => {
-            const receiver = new HashLockFTV2(
+            const receiver = new HashLockBSV21(
                 toByteString(tokenId, true),
                 sym,
                 max,
@@ -84,18 +84,18 @@ describe('Test SmartContract `HashLockFTV2`', () => {
                 toByteString(`hello, sCrypt!:3`, true),
                 {
                     transfer: recipients,
-                } as OrdiMethodCallOptions<HashLockFTV2>
+                } as OrdiMethodCallOptions<HashLockBSV21>
             )
 
             console.log('transfer tx: ', tx.id)
 
             expect(nexts.length === 2).to.be.true
 
-            const p2pkh = nexts[1].instance as BSV20V2P2PKH
+            const p2pkh = nexts[1].instance as BSV21P2PKH
 
             expect(p2pkh.getAmt()).to.be.equal(1n)
 
-            hashLock = recipients[0].instance as HashLockFTV2
+            hashLock = recipients[0].instance as HashLockBSV21
             await hashLock.connect(getDefaultSigner())
         }
 
@@ -104,7 +104,7 @@ describe('Test SmartContract `HashLockFTV2`', () => {
 
     it('transfer to an other hashLock without change.', async () => {
         const callContract = async () => {
-            const receiver = new HashLockFTV2(
+            const receiver = new HashLockBSV21(
                 toByteString(tokenId, true),
                 sym,
                 max,
@@ -124,7 +124,7 @@ describe('Test SmartContract `HashLockFTV2`', () => {
                 {
                     transfer: recipients,
                     skipTokenChange: true,
-                } as OrdiMethodCallOptions<HashLockFTV2>
+                } as OrdiMethodCallOptions<HashLockBSV21>
             )
 
             console.log('transfer tx: ', tx.id)
@@ -136,7 +136,7 @@ describe('Test SmartContract `HashLockFTV2`', () => {
     })
 
     it('should fail when passing incorrect message', async () => {
-        const receiver = new HashLockFTV2(
+        const receiver = new HashLockBSV21(
             toByteString(tokenId, true),
             sym,
             max,
@@ -151,7 +151,7 @@ describe('Test SmartContract `HashLockFTV2`', () => {
                         instance: receiver,
                         amt: 9n,
                     },
-                } as OrdiMethodCallOptions<HashLockFTV2>
+                } as OrdiMethodCallOptions<HashLockBSV21>
             )
         await expect(call()).to.be.rejectedWith(/hashes are not equal/)
     })
diff --git a/tests/specs/multiInput.spec.ts b/tests/specs/multiInputBSV20.spec.ts
similarity index 81%
rename from tests/specs/multiInput.spec.ts
rename to tests/specs/multiInputBSV20.spec.ts
index c2cf75b..33f5d17 100644
--- a/tests/specs/multiInput.spec.ts
+++ b/tests/specs/multiInputBSV20.spec.ts
@@ -11,15 +11,15 @@ import {
     sha256,
     toByteString,
 } from 'scrypt-ts'
-import { HashLockFT } from '../contracts/hashLockFT'
+import { HashLockBSV20 } from '../contracts/hashLockBSV20'
 import { getDefaultSigner, randomPrivateKey } from '../utils/txHelper'
 
 import chaiAsPromised from 'chai-as-promised'
 import {
-    BSV20V1P2PKH,
+    BSV20P2PKH,
     FTReceiver,
     fromByteString,
-    BSV20V1,
+    BSV20,
     OrdiMethodCallOptions,
 } from '../scrypt-ord'
 import { dummyBSV20 } from './utils'
@@ -32,24 +32,24 @@ describe('Test multi inputs and outputs', () => {
     const dec = 0n
 
     before(async () => {
-        HashLockFT.loadArtifact()
+        HashLockBSV20.loadArtifact()
     })
 
-    it('should transfer 2 BSV20V1P2PKH to 1 hashLock successfully.', async () => {
+    it('should transfer 2 BSV20P2PKH to 1 hashLock successfully.', async () => {
         const transferBSV20 = async () => {
             const signer = getDefaultSigner()
             const address = await signer.getDefaultAddress()
-            const bsv20V1P2PKHs = [
+            const bsv20P2PKHs = [
                 dummyBSV20(address, fromByteString(tick), 4n),
                 dummyBSV20(address, fromByteString(tick), 5n),
-            ].map((utxo) => BSV20V1P2PKH.fromUTXO(utxo))
+            ].map((utxo) => BSV20P2PKH.fromUTXO(utxo))
 
             const message = toByteString('hello, sCrypt!', true)
 
-            await Promise.all(bsv20V1P2PKHs.map((p) => p.connect(signer)))
+            await Promise.all(bsv20P2PKHs.map((p) => p.connect(signer)))
             const recipients: Array<FTReceiver> = [
                 {
-                    instance: new HashLockFT(
+                    instance: new HashLockBSV20(
                         tick,
                         max,
                         lim,
@@ -60,8 +60,8 @@ describe('Test multi inputs and outputs', () => {
                 },
             ]
 
-            const { tx } = await BSV20V1P2PKH.transfer(
-                bsv20V1P2PKHs,
+            const { tx } = await BSV20P2PKH.transfer(
+                bsv20P2PKHs,
                 signer,
                 recipients,
                 address
@@ -73,7 +73,7 @@ describe('Test multi inputs and outputs', () => {
         return expect(transferBSV20()).not.be.rejected
     })
 
-    it('should transfer 2 BSV20V1P2PKH to 1 hashLock successfully: with different signer', async () => {
+    it('should transfer 2 BSV20P2PKH to 1 hashLock successfully: with different signer', async () => {
         const transferBSV20 = async () => {
             const feeSigner = getDefaultSigner()
 
@@ -84,23 +84,23 @@ describe('Test multi inputs and outputs', () => {
             const bobSigner = getDefaultSigner(bobPrivateKey)
 
             const address = await feeSigner.getDefaultAddress()
-            const bsv20V1P2PKHs = [
+            const bsv20P2PKHs = [
                 dummyBSV20(
                     alicePrivateKey.toAddress(),
                     fromByteString(tick),
                     4n
                 ),
                 dummyBSV20(bobPrivateKey.toAddress(), fromByteString(tick), 5n),
-            ].map((utxo) => BSV20V1P2PKH.fromUTXO(utxo))
+            ].map((utxo) => BSV20P2PKH.fromUTXO(utxo))
 
             const message = toByteString('hello, sCrypt!', true)
 
-            await bsv20V1P2PKHs[0].connect(aliceSigner)
-            await bsv20V1P2PKHs[1].connect(bobSigner)
+            await bsv20P2PKHs[0].connect(aliceSigner)
+            await bsv20P2PKHs[1].connect(bobSigner)
 
             const recipients: Array<FTReceiver> = [
                 {
-                    instance: new HashLockFT(
+                    instance: new HashLockBSV20(
                         tick,
                         max,
                         lim,
@@ -111,8 +111,8 @@ describe('Test multi inputs and outputs', () => {
                 },
             ]
 
-            const { tx } = await BSV20V1P2PKH.transfer(
-                bsv20V1P2PKHs,
+            const { tx } = await BSV20P2PKH.transfer(
+                bsv20P2PKHs,
                 feeSigner,
                 recipients,
                 address
@@ -124,23 +124,23 @@ describe('Test multi inputs and outputs', () => {
         return expect(transferBSV20()).not.be.rejected
     })
 
-    it('should transfer 2 BSV20V1P2PKH to 2 hashLock successfully.', async () => {
+    it('should transfer 2 BSV20P2PKH to 2 hashLock successfully.', async () => {
         const transferBSV20 = async () => {
             const signer = getDefaultSigner()
             const address = await signer.getDefaultAddress()
-            const bsv20V1P2PKHs = [
+            const bsv20P2PKHs = [
                 dummyBSV20(address, fromByteString(tick), 4n),
                 dummyBSV20(address, fromByteString(tick), 5n),
-            ].map((utxo) => BSV20V1P2PKH.fromUTXO(utxo))
+            ].map((utxo) => BSV20P2PKH.fromUTXO(utxo))
 
-            await Promise.all(bsv20V1P2PKHs.map((p) => p.connect(signer)))
+            await Promise.all(bsv20P2PKHs.map((p) => p.connect(signer)))
 
             const message1 = toByteString('1:hello, sCrypt!', true)
             const message2 = toByteString('2:hello, sCrypt!', true)
 
             const recipients: Array<FTReceiver> = [
                 {
-                    instance: new HashLockFT(
+                    instance: new HashLockBSV20(
                         tick,
                         max,
                         lim,
@@ -150,7 +150,7 @@ describe('Test multi inputs and outputs', () => {
                     amt: 6n,
                 },
                 {
-                    instance: new HashLockFT(
+                    instance: new HashLockBSV20(
                         tick,
                         max,
                         lim,
@@ -161,8 +161,8 @@ describe('Test multi inputs and outputs', () => {
                 },
             ]
 
-            const { tx } = await BSV20V1P2PKH.transfer(
-                bsv20V1P2PKHs,
+            const { tx } = await BSV20P2PKH.transfer(
+                bsv20P2PKHs,
                 signer,
                 recipients,
                 address
@@ -174,20 +174,20 @@ describe('Test multi inputs and outputs', () => {
         return expect(transferBSV20()).not.be.rejected
     })
 
-    it('should transfer 1 BSV20V1P2PKH and 1 hashLock to 1 hashLock successfully.', async () => {
+    it('should transfer 1 BSV20P2PKH and 1 hashLock to 1 hashLock successfully.', async () => {
         const transferBSV20 = async () => {
             const message1 = toByteString('1:hello, sCrypt!', true)
             const message2 = toByteString('2:hello, sCrypt!', true)
 
             const signer = getDefaultSigner()
             const address = await signer.getDefaultAddress()
-            const sender0: BSV20V1P2PKH = BSV20V1P2PKH.fromUTXO(
+            const sender0: BSV20P2PKH = BSV20P2PKH.fromUTXO(
                 dummyBSV20(address, fromByteString(tick), 4n)
             )
 
             await sender0.connect(signer)
 
-            const sender1 = new HashLockFT(
+            const sender1 = new HashLockBSV20(
                 tick,
                 max,
                 lim,
@@ -199,7 +199,7 @@ describe('Test multi inputs and outputs', () => {
 
             const recipients: Array<FTReceiver> = [
                 {
-                    instance: new HashLockFT(
+                    instance: new HashLockBSV20(
                         tick,
                         max,
                         lim,
@@ -209,7 +209,7 @@ describe('Test multi inputs and outputs', () => {
                     amt: 6n,
                 },
                 {
-                    instance: new HashLockFT(
+                    instance: new HashLockBSV20(
                         tick,
                         max,
                         lim,
@@ -236,14 +236,14 @@ describe('Test multi inputs and outputs', () => {
 
             sender0.bindTxBuilder(
                 'unlock',
-                async (current: BSV20V1P2PKH): Promise<ContractTransaction> => {
+                async (current: BSV20P2PKH): Promise<ContractTransaction> => {
                     const tx = new bsv.Transaction()
                     const nexts: StatefulNext<SmartContract>[] = []
 
                     for (let i = 0; i < recipients.length; i++) {
                         const receiver = recipients[i]
 
-                        if (receiver.instance instanceof BSV20V1) {
+                        if (receiver.instance instanceof BSV20) {
                             receiver.instance.setAmt(receiver.amt)
                         } else {
                             throw new Error('unsupport receiver, only BSV20!')
@@ -264,7 +264,7 @@ describe('Test multi inputs and outputs', () => {
                     }
 
                     if (tokenChangeAmt > 0n) {
-                        const p2pkh = new BSV20V1P2PKH(
+                        const p2pkh = new BSV20P2PKH(
                             tick,
                             max,
                             lim,
@@ -307,14 +307,14 @@ describe('Test multi inputs and outputs', () => {
                     transfer: [],
                     pubKeyOrAddrToSign: ordPubKey,
                     multiContractCall: true,
-                } as OrdiMethodCallOptions<BSV20V1P2PKH>
+                } as OrdiMethodCallOptions<BSV20P2PKH>
             )
 
             sender1.bindTxBuilder(
                 'unlock',
                 async (
-                    current: HashLockFT,
-                    options: MethodCallOptions<HashLockFT>
+                    current: HashLockBSV20,
+                    options: MethodCallOptions<HashLockBSV20>
                 ): Promise<ContractTransaction> => {
                     if (options.partialContractTx) {
                         const tx = options.partialContractTx.tx
@@ -336,7 +336,7 @@ describe('Test multi inputs and outputs', () => {
                 transfer: recipients,
                 pubKeyOrAddrToSign: ordPubKey,
                 multiContractCall: true,
-            } as OrdiMethodCallOptions<BSV20V1P2PKH>)
+            } as OrdiMethodCallOptions<BSV20P2PKH>)
 
             const { tx } = await SmartContract.multiContractCall(
                 partialContractTx,
diff --git a/tests/specs/multiInputv2.spec.ts b/tests/specs/multiInputBSV21.spec.ts
similarity index 83%
rename from tests/specs/multiInputv2.spec.ts
rename to tests/specs/multiInputBSV21.spec.ts
index 6757fbc..00c3735 100644
--- a/tests/specs/multiInputv2.spec.ts
+++ b/tests/specs/multiInputBSV21.spec.ts
@@ -11,28 +11,28 @@ import {
     sha256,
     toByteString,
 } from 'scrypt-ts'
-import { HashLockFTV2 } from '../contracts/hashLockFTV2'
+import { HashLockBSV21 } from '../contracts/hashLockBSV21'
 import { getDefaultSigner, randomPrivateKey } from '../utils/txHelper'
 import chaiAsPromised from 'chai-as-promised'
 import {
-    BSV20V2,
-    BSV20V2P2PKH,
+    BSV21,
+    BSV21P2PKH,
     FTReceiver,
     OrdiMethodCallOptions,
 } from '../scrypt-ord'
-import { dummyBSV20V2 } from './utils'
+import { dummyBSV21 } from './utils'
 use(chaiAsPromised)
 
-describe('Test SmartContract `HashLockFTV2 multi inputs`', () => {
+describe('Test SmartContract `HashLockBSV21 multi inputs`', () => {
     const max = 100000n
     const dec = 0n
     const sym = toByteString('MEME', true)
 
-    let hashLock: HashLockFTV2
+    let hashLock: HashLockBSV21
     let tokenId: string
     before(async () => {
-        HashLockFTV2.loadArtifact()
-        hashLock = new HashLockFTV2(
+        HashLockBSV21.loadArtifact()
+        hashLock = new HashLockBSV21(
             toByteString(''),
             sym,
             max,
@@ -45,7 +45,7 @@ describe('Test SmartContract `HashLockFTV2 multi inputs`', () => {
         console.log('token id: ', tokenId)
     })
 
-    it('should transfer 2 BSV20V2P2PKH to 1 hashLock successfully: with different signer', async () => {
+    it('should transfer 2 BSV21P2PKH to 1 hashLock successfully: with different signer', async () => {
         const transferBSV20 = async () => {
             const feeSigner = getDefaultSigner()
 
@@ -56,19 +56,19 @@ describe('Test SmartContract `HashLockFTV2 multi inputs`', () => {
             const bobSigner = getDefaultSigner(bobPrivateKey)
 
             const address = await feeSigner.getDefaultAddress()
-            const bsv20V1P2PKHs = [
-                dummyBSV20V2(alicePrivateKey.toAddress(), tokenId, 4n),
-                dummyBSV20V2(bobPrivateKey.toAddress(), tokenId, 5n),
-            ].map((utxo) => BSV20V2P2PKH.fromUTXO(utxo))
+            const bsv20P2PKHs = [
+                dummyBSV21(alicePrivateKey.toAddress(), tokenId, 4n),
+                dummyBSV21(bobPrivateKey.toAddress(), tokenId, 5n),
+            ].map((utxo) => BSV21P2PKH.fromUTXO(utxo))
 
             const message = toByteString('hello, sCrypt!', true)
 
-            await bsv20V1P2PKHs[0].connect(aliceSigner)
-            await bsv20V1P2PKHs[1].connect(bobSigner)
+            await bsv20P2PKHs[0].connect(aliceSigner)
+            await bsv20P2PKHs[1].connect(bobSigner)
 
             const recipients: Array<FTReceiver> = [
                 {
-                    instance: new HashLockFTV2(
+                    instance: new HashLockBSV21(
                         toByteString(tokenId, true),
                         sym,
                         max,
@@ -79,8 +79,8 @@ describe('Test SmartContract `HashLockFTV2 multi inputs`', () => {
                 },
             ]
 
-            const { tx } = await BSV20V2P2PKH.transfer(
-                bsv20V1P2PKHs,
+            const { tx } = await BSV21P2PKH.transfer(
+                bsv20P2PKHs,
                 feeSigner,
                 recipients,
                 address
@@ -94,7 +94,7 @@ describe('Test SmartContract `HashLockFTV2 multi inputs`', () => {
 
     it('transfer to an other hashLock with change.', async () => {
         const callContract = async () => {
-            const receiver = new HashLockFTV2(
+            const receiver = new HashLockBSV21(
                 toByteString(tokenId, true),
                 sym,
                 max,
@@ -113,14 +113,14 @@ describe('Test SmartContract `HashLockFTV2 multi inputs`', () => {
                 toByteString(`hello, sCrypt!:0`, true),
                 {
                     transfer: recipients,
-                } as OrdiMethodCallOptions<HashLockFTV2>
+                } as OrdiMethodCallOptions<HashLockBSV21>
             )
 
             console.log('transfer tx: ', tx.id)
 
             expect(nexts.length === 2).to.be.true
 
-            const p2pkh = nexts[1].instance as BSV20V2P2PKH
+            const p2pkh = nexts[1].instance as BSV21P2PKH
 
             expect(p2pkh.getAmt()).to.be.equal(99000n)
 
@@ -144,14 +144,14 @@ describe('Test SmartContract `HashLockFTV2 multi inputs`', () => {
 
             sender0.bindTxBuilder(
                 'unlock',
-                async (current: HashLockFTV2): Promise<ContractTransaction> => {
+                async (current: HashLockBSV21): Promise<ContractTransaction> => {
                     const tx = new bsv.Transaction()
                     const nexts: StatefulNext<SmartContract>[] = []
 
                     for (let i = 0; i < recipients.length; i++) {
                         const receiver = recipients[i]
 
-                        if (receiver.instance instanceof BSV20V2) {
+                        if (receiver.instance instanceof BSV21) {
                             receiver.instance.setAmt(receiver.amt)
                         } else {
                             throw new Error('unsupport receiver, only BSV20!')
@@ -172,7 +172,7 @@ describe('Test SmartContract `HashLockFTV2 multi inputs`', () => {
                     }
 
                     if (tokenChangeAmt > 0n) {
-                        const p2pkh = new BSV20V2P2PKH(
+                        const p2pkh = new BSV21P2PKH(
                             toByteString(tokenId, true),
                             sym,
                             max,
@@ -219,14 +219,14 @@ describe('Test SmartContract `HashLockFTV2 multi inputs`', () => {
                     ],
                     pubKeyOrAddrToSign: ordPubKey,
                     multiContractCall: true,
-                } as OrdiMethodCallOptions<BSV20V2P2PKH>
+                } as OrdiMethodCallOptions<BSV21P2PKH>
             )
 
             sender1.bindTxBuilder(
                 'unlock',
                 async (
-                    current: HashLockFTV2,
-                    options: MethodCallOptions<HashLockFTV2>
+                    current: HashLockBSV21,
+                    options: MethodCallOptions<HashLockBSV21>
                 ): Promise<ContractTransaction> => {
                     if (options.partialContractTx) {
                         const tx = options.partialContractTx.tx
@@ -251,7 +251,7 @@ describe('Test SmartContract `HashLockFTV2 multi inputs`', () => {
                     transfer: recipients,
                     pubKeyOrAddrToSign: ordPubKey,
                     multiContractCall: true,
-                } as OrdiMethodCallOptions<BSV20V2P2PKH>
+                } as OrdiMethodCallOptions<BSV21P2PKH>
             )
 
             const { tx: finalTx } = await SmartContract.multiContractCall(
diff --git a/tests/specs/permissionedFT.spec.ts b/tests/specs/permissionedBSV20.spec.ts
similarity index 85%
rename from tests/specs/permissionedFT.spec.ts
rename to tests/specs/permissionedBSV20.spec.ts
index 65137b0..aaa58ae 100644
--- a/tests/specs/permissionedFT.spec.ts
+++ b/tests/specs/permissionedBSV20.spec.ts
@@ -1,13 +1,13 @@
 import { expect, use } from 'chai'
 import { PubKey, findSig, toByteString } from 'scrypt-ts'
-import { PermissionedFT } from '../contracts/permissionedFT'
+import { PermissionedBSV20 } from '../contracts/permissionedBSV20'
 import { getDefaultSigner, randomPrivateKey } from '../utils/txHelper'
 import chaiAsPromised from 'chai-as-promised'
 import { myPublicKey, myPrivateKey } from '../utils/privateKey'
 import { OrdiMethodCallOptions } from '../scrypt-ord'
 use(chaiAsPromised)
 
-describe('Test SmartContract `PermissionedFT`', () => {
+describe('Test SmartContract `PermissionedBSV20`', () => {
     const tick = 'DOGE'
     const max = 1000n
     const lim = max / 10n
@@ -16,16 +16,16 @@ describe('Test SmartContract `PermissionedFT`', () => {
     const tokenChangeAmount = amount / 10n // 10
     const tokenTransferAmount = amount - tokenChangeAmount // 90
 
-    let instance: PermissionedFT
+    let instance: PermissionedBSV20
 
     const issuerPublicKey = myPublicKey
     const [alicePrivateKey, alicePublicKey, ,] = randomPrivateKey()
     const [bobPrivateKey, bobPublicKey, ,] = randomPrivateKey()
 
     before(async () => {
-        PermissionedFT.loadArtifact()
+        PermissionedBSV20.loadArtifact()
 
-        instance = new PermissionedFT(
+        instance = new PermissionedBSV20(
             toByteString(tick, true),
             max,
             lim,
@@ -51,7 +51,7 @@ describe('Test SmartContract `PermissionedFT`', () => {
                 (sigResps) => findSig(sigResps, issuerPublicKey),
                 {
                     pubKeyOrAddrToSign: [alicePublicKey, issuerPublicKey],
-                } as OrdiMethodCallOptions<PermissionedFT>
+                } as OrdiMethodCallOptions<PermissionedBSV20>
             )
 
         await expect(call()).not.to.be.rejected
diff --git a/tests/specs/permissionedFTV2.spec.ts b/tests/specs/permissionedBSV21.spec.ts
similarity index 84%
rename from tests/specs/permissionedFTV2.spec.ts
rename to tests/specs/permissionedBSV21.spec.ts
index 6c8dab7..541b269 100644
--- a/tests/specs/permissionedFTV2.spec.ts
+++ b/tests/specs/permissionedBSV21.spec.ts
@@ -1,13 +1,13 @@
 import { expect, use } from 'chai'
 import { PubKey, findSig, toByteString, toHex } from 'scrypt-ts'
-import { PermissionedFTV2 } from '../contracts/permissionedFTV2'
+import { PermissionedBSV21 } from '../contracts/permissionedBSV21'
 import { getDefaultSigner, randomPrivateKey } from '../utils/txHelper'
 import chaiAsPromised from 'chai-as-promised'
 import { myPublicKey, myPrivateKey } from '../utils/privateKey'
 import { OrdiMethodCallOptions } from '../scrypt-ord'
 use(chaiAsPromised)
 
-describe('Test SmartContract `PermissionedFTV2`', () => {
+describe('Test SmartContract `PermissionedBSV21`', () => {
     const max = 1000n
     const sym = toByteString('MEME', true)
     const dec = 0n
@@ -15,16 +15,16 @@ describe('Test SmartContract `PermissionedFTV2`', () => {
     const tokenTransferAmount = 10n
     const tokenChangeAmount = amount - tokenTransferAmount
 
-    let instance: PermissionedFTV2
+    let instance: PermissionedBSV21
 
     const issuerPublicKey = myPublicKey
     const [alicePrivateKey, alicePublicKey, ,] = randomPrivateKey()
     const [bobPrivateKey, bobPublicKey, ,] = randomPrivateKey()
 
     before(async () => {
-        PermissionedFTV2.loadArtifact()
+        PermissionedBSV21.loadArtifact()
 
-        instance = new PermissionedFTV2(
+        instance = new PermissionedBSV21(
             toByteString(''),
             sym,
             max,
@@ -49,7 +49,7 @@ describe('Test SmartContract `PermissionedFTV2`', () => {
                 (sigResps) => findSig(sigResps, issuerPublicKey),
                 {
                     pubKeyOrAddrToSign: [alicePublicKey, issuerPublicKey],
-                } as OrdiMethodCallOptions<PermissionedFTV2>
+                } as OrdiMethodCallOptions<PermissionedBSV21>
             )
 
             console.log('tranfer tx:', tx.id)
diff --git a/tests/specs/send2CounterFT.spec.ts b/tests/specs/send2CounterBSV20.spec.ts
similarity index 81%
rename from tests/specs/send2CounterFT.spec.ts
rename to tests/specs/send2CounterBSV20.spec.ts
index 4f7d34c..3256433 100644
--- a/tests/specs/send2CounterFT.spec.ts
+++ b/tests/specs/send2CounterBSV20.spec.ts
@@ -3,16 +3,16 @@ import { Addr, PubKey, findSig, toByteString } from 'scrypt-ts'
 import { getDefaultSigner } from '../utils/txHelper'
 import chaiAsPromised from 'chai-as-promised'
 import {
-    BSV20V1P2PKH,
+    BSV20P2PKH,
     OrdiMethodCallOptions,
     fromByteString,
 } from '../scrypt-ord'
 import { dummyBSV20 } from './utils'
-import { CounterFT } from '../contracts/counterFT'
+import { CounterBSV20 } from '../contracts/counterBSV20'
 import { myAddress, myPublicKey } from '../utils/privateKey'
 use(chaiAsPromised)
 
-describe('Test SmartContract send FT to `CounterFT`', () => {
+describe('Test SmartContract send FT to `CounterBSV20`', () => {
     const tick = toByteString('DOGE', true)
     const max = 100000n
     const lim = max / 10n
@@ -23,11 +23,11 @@ describe('Test SmartContract send FT to `CounterFT`', () => {
     const tokenToP2PKH = 250n
 
     before(async () => {
-        CounterFT.loadArtifact()
+        CounterBSV20.loadArtifact()
     })
 
-    async function transferToCounter(p2pkh: BSV20V1P2PKH): Promise<CounterFT> {
-        const counter = new CounterFT(tick, max, lim, dec, 0n)
+    async function transferToCounter(p2pkh: BSV20P2PKH): Promise<CounterBSV20> {
+        const counter = new CounterBSV20(tick, max, lim, dec, 0n)
         await counter.connect(getDefaultSigner())
 
         const totalAmount = tokenInP2PKH
@@ -45,7 +45,7 @@ describe('Test SmartContract send FT to `CounterFT`', () => {
                     },
                 ],
                 pubKeyOrAddrToSign: myPublicKey,
-            } as OrdiMethodCallOptions<BSV20V1P2PKH>
+            } as OrdiMethodCallOptions<BSV20P2PKH>
         )
         console.log('transfer FT:', tx.id)
 
@@ -54,13 +54,13 @@ describe('Test SmartContract send FT to `CounterFT`', () => {
         // output #0, token receiver, counter instance
         expect(counter.getAmt()).to.equal(transferAmount)
         // output #1, token change, ordP2PKH instance
-        const tokenChange = nexts[1].instance as BSV20V1P2PKH
+        const tokenChange = nexts[1].instance as BSV20P2PKH
         expect(tokenChange.getAmt()).to.equal(changeAmount)
 
         return counter
     }
 
-    async function counterTransfer(counter: CounterFT) {
+    async function counterTransfer(counter: CounterBSV20) {
         const totalAmount = tokenToCounter
         const counterAmount = 10n
         const p2pkhAmount = tokenToP2PKH
@@ -69,7 +69,7 @@ describe('Test SmartContract send FT to `CounterFT`', () => {
         const nextInstance = counter.next()
         nextInstance.incCounter()
 
-        const p2pkh = new BSV20V1P2PKH(
+        const p2pkh = new BSV20P2PKH(
             tick,
             max,
             lim,
@@ -88,19 +88,19 @@ describe('Test SmartContract send FT to `CounterFT`', () => {
                     amt: p2pkhAmount,
                 },
             ],
-        } as OrdiMethodCallOptions<CounterFT>)
+        } as OrdiMethodCallOptions<CounterBSV20>)
         console.log('transfer FT: ', tx.id)
 
         expect(nexts.length).to.equal(3)
         expect(nextInstance.getAmt()).to.equal(counterAmount)
         expect(p2pkh.getAmt()).to.eq(p2pkhAmount)
 
-        const tokenChange = nexts[2].instance as BSV20V1P2PKH
+        const tokenChange = nexts[2].instance as BSV20P2PKH
         expect(tokenChange.getAmt()).to.equal(changeAmount)
     }
 
     it('P2PKH with inscription appended', async () => {
-        const p2pkh = BSV20V1P2PKH.fromUTXO(
+        const p2pkh = BSV20P2PKH.fromUTXO(
             dummyBSV20(myAddress, fromByteString(tick), tokenInP2PKH)
         )
         await p2pkh.connect(getDefaultSigner())
@@ -110,7 +110,7 @@ describe('Test SmartContract send FT to `CounterFT`', () => {
     })
 
     it('P2PKH with inscription prepended', async () => {
-        const p2pkh = BSV20V1P2PKH.fromUTXO(
+        const p2pkh = BSV20P2PKH.fromUTXO(
             dummyBSV20(myAddress, fromByteString(tick), tokenInP2PKH)
         )
         await p2pkh.connect(getDefaultSigner())
diff --git a/tests/specs/send2CounterFTV2.spec.ts b/tests/specs/send2CounterBSV21.spec.ts
similarity index 78%
rename from tests/specs/send2CounterFTV2.spec.ts
rename to tests/specs/send2CounterBSV21.spec.ts
index d034cfe..2d69e1b 100644
--- a/tests/specs/send2CounterFTV2.spec.ts
+++ b/tests/specs/send2CounterBSV21.spec.ts
@@ -3,16 +3,16 @@ import { Addr, PubKey, findSig, toByteString } from 'scrypt-ts'
 import { getDefaultSigner } from '../utils/txHelper'
 import chaiAsPromised from 'chai-as-promised'
 import {
-    BSV20V2P2PKH,
+    BSV21P2PKH,
     OrdiMethodCallOptions,
     fromByteString,
 } from '../scrypt-ord'
-import { dummyBSV20V2 } from './utils'
-import { CounterFTV2 } from '../contracts/counterFTV2'
+import { dummyBSV21 } from './utils'
+import { CounterBSV21 } from '../contracts/counterBSV21'
 import { myAddress, myPublicKey } from '../utils/privateKey'
 use(chaiAsPromised)
 
-describe('Test SmartContract send FT to `CounterFTV2`', () => {
+describe('Test SmartContract send FT to `CounterBSV21`', () => {
     const tokenId = toByteString(
         '71b08aff9e5017b71bffc66e57e858bb6225084142e36ff60ee40d6cf6d25cf3_0',
         true
@@ -26,13 +26,13 @@ describe('Test SmartContract send FT to `CounterFTV2`', () => {
     const tokenToP2PKH = 250n
 
     before(async () => {
-        CounterFTV2.loadArtifact()
+        CounterBSV21.loadArtifact()
     })
 
     async function transferToCounter(
-        p2pkh: BSV20V2P2PKH
-    ): Promise<CounterFTV2> {
-        const counter = new CounterFTV2(tokenId, sym, max, dec, 0n)
+        p2pkh: BSV21P2PKH
+    ): Promise<CounterBSV21> {
+        const counter = new CounterBSV21(tokenId, sym, max, dec, 0n)
         await counter.connect(getDefaultSigner())
 
         const totalAmount = tokenInP2PKH
@@ -50,7 +50,7 @@ describe('Test SmartContract send FT to `CounterFTV2`', () => {
                     },
                 ],
                 pubKeyOrAddrToSign: myPublicKey,
-            } as OrdiMethodCallOptions<BSV20V2P2PKH>
+            } as OrdiMethodCallOptions<BSV21P2PKH>
         )
         console.log('transfer FT:', tx.id)
 
@@ -59,13 +59,13 @@ describe('Test SmartContract send FT to `CounterFTV2`', () => {
         // output #0, token receiver, counter instance
         expect(counter.getAmt()).to.equal(transferAmount)
         // output #1, token change, ordP2PKH instance
-        const tokenChange = nexts[1].instance as BSV20V2P2PKH
+        const tokenChange = nexts[1].instance as BSV21P2PKH
         expect(tokenChange.getAmt()).to.equal(changeAmount)
 
         return counter
     }
 
-    async function counterTransfer(counter: CounterFTV2) {
+    async function counterTransfer(counter: CounterBSV21) {
         const totalAmount = tokenToCounter
         const counterAmount = 10n
         const p2pkhAmount = tokenToP2PKH
@@ -74,7 +74,7 @@ describe('Test SmartContract send FT to `CounterFTV2`', () => {
         const nextInstance = counter.next()
         nextInstance.incCounter()
 
-        const p2pkh = new BSV20V2P2PKH(
+        const p2pkh = new BSV21P2PKH(
             tokenId,
             sym,
             max,
@@ -93,20 +93,20 @@ describe('Test SmartContract send FT to `CounterFTV2`', () => {
                     amt: p2pkhAmount,
                 },
             ],
-        } as OrdiMethodCallOptions<CounterFTV2>)
+        } as OrdiMethodCallOptions<CounterBSV21>)
         console.log('transfer FT: ', tx.id)
 
         expect(nexts.length).to.equal(3)
         expect(nextInstance.getAmt()).to.equal(counterAmount)
         expect(p2pkh.getAmt()).to.eq(p2pkhAmount)
 
-        const tokenChange = nexts[2].instance as BSV20V2P2PKH
+        const tokenChange = nexts[2].instance as BSV21P2PKH
         expect(tokenChange.getAmt()).to.equal(changeAmount)
     }
 
     it('P2PKH with inscription appended', async () => {
-        const p2pkh = BSV20V2P2PKH.fromUTXO(
-            dummyBSV20V2(myAddress, fromByteString(tokenId), tokenInP2PKH)
+        const p2pkh = BSV21P2PKH.fromUTXO(
+            dummyBSV21(myAddress, fromByteString(tokenId), tokenInP2PKH)
         )
         await p2pkh.connect(getDefaultSigner())
 
@@ -115,8 +115,8 @@ describe('Test SmartContract send FT to `CounterFTV2`', () => {
     })
 
     it('P2PKH with inscription prepended', async () => {
-        const p2pkh = BSV20V2P2PKH.fromUTXO(
-            dummyBSV20V2(myAddress, fromByteString(tokenId), tokenInP2PKH)
+        const p2pkh = BSV21P2PKH.fromUTXO(
+            dummyBSV21(myAddress, fromByteString(tokenId), tokenInP2PKH)
         )
         await p2pkh.connect(getDefaultSigner())
 
diff --git a/tests/specs/send2hashLockFT.spec.ts b/tests/specs/send2hashLockBSV20.spec.ts
similarity index 85%
rename from tests/specs/send2hashLockFT.spec.ts
rename to tests/specs/send2hashLockBSV20.spec.ts
index 6d3aeca..b9ab57f 100644
--- a/tests/specs/send2hashLockFT.spec.ts
+++ b/tests/specs/send2hashLockBSV20.spec.ts
@@ -3,15 +3,15 @@ import { Addr, PubKey, findSig, sha256, toByteString } from 'scrypt-ts'
 import { getDefaultSigner, randomPrivateKey } from '../utils/txHelper'
 import chaiAsPromised from 'chai-as-promised'
 import {
-    BSV20V1P2PKH,
+    BSV20P2PKH,
     OrdiMethodCallOptions,
     fromByteString,
 } from '../scrypt-ord'
 import { dummyBSV20 } from './utils'
-import { HashLockFT } from '../contracts/hashLockFT'
+import { HashLockBSV20 } from '../contracts/hashLockBSV20'
 use(chaiAsPromised)
 
-describe('Test SmartContract send FT to `HashLockFT`', () => {
+describe('Test SmartContract send FT to `HashLockBSV20`', () => {
     describe('p2pkh with post FT', () => {
         const tick = toByteString('DOGE', true)
         const max = 100000n
@@ -22,20 +22,20 @@ describe('Test SmartContract send FT to `HashLockFT`', () => {
         const message = toByteString(text, true)
         const hash = sha256(message)
 
-        let recipient: HashLockFT
+        let recipient: HashLockBSV20
 
         const signer = getDefaultSigner()
 
         before(async () => {
-            HashLockFT.loadArtifact()
-            recipient = new HashLockFT(tick, max, lim, dec, hash)
+            HashLockBSV20.loadArtifact()
+            recipient = new HashLockBSV20(tick, max, lim, dec, hash)
         })
 
         it('transfer exist FT to a HashLock', async () => {
             const address = await getDefaultSigner().getDefaultAddress()
             const pubkey = await getDefaultSigner().getDefaultPubKey()
             // create p2pkh from a utxo
-            const p2pkh = BSV20V1P2PKH.fromUTXO(
+            const p2pkh = BSV20P2PKH.fromUTXO(
                 dummyBSV20(address, fromByteString(tick), 100n)
             )
 
@@ -52,7 +52,7 @@ describe('Test SmartContract send FT to `HashLockFT`', () => {
                         },
                     ],
                     pubKeyOrAddrToSign: pubkey,
-                } as OrdiMethodCallOptions<BSV20V1P2PKH>
+                } as OrdiMethodCallOptions<BSV20P2PKH>
             )
 
             console.log('transfer FT: ', transferTx.id)
@@ -60,7 +60,7 @@ describe('Test SmartContract send FT to `HashLockFT`', () => {
 
             expect(recipient.getAmt()).to.equal(15n)
 
-            const changeToken = nexts[1].instance as BSV20V1P2PKH
+            const changeToken = nexts[1].instance as BSV20P2PKH
 
             expect(changeToken.getAmt()).to.equal(85n)
         })
@@ -70,7 +70,7 @@ describe('Test SmartContract send FT to `HashLockFT`', () => {
 
             const address = await getDefaultSigner().getDefaultAddress()
             const pubkey = await getDefaultSigner().getDefaultPubKey()
-            const p2pkh = BSV20V1P2PKH.fromUTXO(
+            const p2pkh = BSV20P2PKH.fromUTXO(
                 dummyBSV20(address, fromByteString(tick), 100n)
             )
 
@@ -89,19 +89,19 @@ describe('Test SmartContract send FT to `HashLockFT`', () => {
                             },
                         ],
                         pubKeyOrAddrToSign: wrongPubKey,
-                    } as OrdiMethodCallOptions<BSV20V1P2PKH>
+                    } as OrdiMethodCallOptions<BSV20P2PKH>
                 )
             await expect(call()).to.be.rejectedWith(/signature check failed/)
         })
 
-        it('transfer FT to a BSV20V1P2PKH', async () => {
+        it('transfer FT to a BSV20P2PKH', async () => {
             await recipient.connect(signer)
             const ordAddress = await recipient.signer.getDefaultAddress()
             const call = async () => {
                 const { tx, nexts } = await recipient.methods.unlock(message, {
                     transfer: [
                         {
-                            instance: new BSV20V1P2PKH(
+                            instance: new BSV20P2PKH(
                                 tick,
                                 max,
                                 lim,
@@ -117,7 +117,7 @@ describe('Test SmartContract send FT to `HashLockFT`', () => {
                 // no token change
                 expect(nexts.length).to.equal(1)
 
-                const p2pkh = nexts[0].instance as BSV20V1P2PKH
+                const p2pkh = nexts[0].instance as BSV20P2PKH
 
                 expect(p2pkh.getAmt()).to.equal(15n)
             }
@@ -134,7 +134,7 @@ describe('Test SmartContract send FT to `HashLockFT`', () => {
                     {
                         transfer: [
                             {
-                                instance: new BSV20V1P2PKH(
+                                instance: new BSV20P2PKH(
                                     tick,
                                     max,
                                     lim,
@@ -159,13 +159,13 @@ describe('Test SmartContract send FT to `HashLockFT`', () => {
         const message = toByteString(text, true)
         const hash = sha256(message)
 
-        let recipient: HashLockFT
+        let recipient: HashLockBSV20
 
         const signer = getDefaultSigner()
 
         before(async () => {
-            HashLockFT.loadArtifact()
-            recipient = new HashLockFT(tick, max, lim, dec, hash)
+            HashLockBSV20.loadArtifact()
+            recipient = new HashLockBSV20(tick, max, lim, dec, hash)
             await recipient.connect(signer)
         })
 
@@ -173,7 +173,7 @@ describe('Test SmartContract send FT to `HashLockFT`', () => {
             const address = await getDefaultSigner().getDefaultAddress()
             const pubkey = await getDefaultSigner().getDefaultPubKey()
             // create p2pkh from a utxo
-            const p2pkh = BSV20V1P2PKH.fromUTXO(
+            const p2pkh = BSV20P2PKH.fromUTXO(
                 dummyBSV20(address, fromByteString(tick), 100n)
             )
 
@@ -190,19 +190,19 @@ describe('Test SmartContract send FT to `HashLockFT`', () => {
                         },
                     ],
                     pubKeyOrAddrToSign: pubkey,
-                } as OrdiMethodCallOptions<BSV20V1P2PKH>
+                } as OrdiMethodCallOptions<BSV20P2PKH>
             )
 
             console.log('transfer FT: ', transferTx.id)
         })
 
-        it('transfer FT to a BSV20V1P2PKH', async () => {
+        it('transfer FT to a BSV20P2PKH', async () => {
             const ordAddress = await recipient.signer.getDefaultAddress()
             const call = async () =>
                 await recipient.methods.unlock(message, {
                     transfer: [
                         {
-                            instance: new BSV20V1P2PKH(
+                            instance: new BSV20P2PKH(
                                 tick,
                                 max,
                                 lim,
diff --git a/tests/specs/send2hashLockFTV2.spec.ts b/tests/specs/send2hashLockBSV21.spec.ts
similarity index 82%
rename from tests/specs/send2hashLockFTV2.spec.ts
rename to tests/specs/send2hashLockBSV21.spec.ts
index 58eeaf9..59b2fde 100644
--- a/tests/specs/send2hashLockFTV2.spec.ts
+++ b/tests/specs/send2hashLockBSV21.spec.ts
@@ -3,15 +3,15 @@ import { Addr, PubKey, findSig, sha256, toByteString } from 'scrypt-ts'
 import { getDefaultSigner, randomPrivateKey } from '../utils/txHelper'
 import chaiAsPromised from 'chai-as-promised'
 import {
-    BSV20V2P2PKH,
+    BSV21P2PKH,
     OrdiMethodCallOptions,
     fromByteString,
 } from '../scrypt-ord'
-import { dummyBSV20V2 } from './utils'
-import { HashLockFTV2 } from '../contracts/hashLockFTV2'
+import { dummyBSV21 } from './utils'
+import { HashLockBSV21 } from '../contracts/hashLockBSV21'
 use(chaiAsPromised)
 
-describe('Test SmartContract send FT to `HashLockFTV2`', () => {
+describe('Test SmartContract send FT to `HashLockBSV21`', () => {
     describe('p2pkh with post FT', () => {
         const tokenId = toByteString(
             '71b08aff9e5017b71bffc66e57e858bb6225084142e36ff60ee40d6cf6d25cf3_0',
@@ -24,21 +24,21 @@ describe('Test SmartContract send FT to `HashLockFTV2`', () => {
         const message = toByteString(text, true)
         const hash = sha256(message)
 
-        let recipient: HashLockFTV2
+        let recipient: HashLockBSV21
 
         const signer = getDefaultSigner()
 
         before(async () => {
-            HashLockFTV2.loadArtifact()
-            recipient = new HashLockFTV2(tokenId, sym, max, dec, hash)
+            HashLockBSV21.loadArtifact()
+            recipient = new HashLockBSV21(tokenId, sym, max, dec, hash)
         })
 
         it('transfer exist FT to a HashLock', async () => {
             const address = await getDefaultSigner().getDefaultAddress()
             const pubkey = await getDefaultSigner().getDefaultPubKey()
             // create p2pkh from a utxo
-            const p2pkh = BSV20V2P2PKH.fromUTXO(
-                dummyBSV20V2(address, fromByteString(tokenId), 100n)
+            const p2pkh = BSV21P2PKH.fromUTXO(
+                dummyBSV21(address, fromByteString(tokenId), 100n)
             )
 
             await p2pkh.connect(signer)
@@ -54,7 +54,7 @@ describe('Test SmartContract send FT to `HashLockFTV2`', () => {
                         },
                     ],
                     pubKeyOrAddrToSign: pubkey,
-                } as OrdiMethodCallOptions<BSV20V2P2PKH>
+                } as OrdiMethodCallOptions<BSV21P2PKH>
             )
 
             console.log('transfer FT: ', transferTx.id)
@@ -62,7 +62,7 @@ describe('Test SmartContract send FT to `HashLockFTV2`', () => {
 
             expect(recipient.getAmt()).to.equal(15n)
 
-            const changeToken = nexts[1].instance as BSV20V2P2PKH
+            const changeToken = nexts[1].instance as BSV21P2PKH
 
             expect(changeToken.getAmt()).to.equal(85n)
         })
@@ -72,8 +72,8 @@ describe('Test SmartContract send FT to `HashLockFTV2`', () => {
 
             const address = await getDefaultSigner().getDefaultAddress()
             const pubkey = await getDefaultSigner().getDefaultPubKey()
-            const p2pkh = BSV20V2P2PKH.fromUTXO(
-                dummyBSV20V2(address, fromByteString(tokenId), 100n)
+            const p2pkh = BSV21P2PKH.fromUTXO(
+                dummyBSV21(address, fromByteString(tokenId), 100n)
             )
 
             signer.addPrivateKey(wrongPrivKey)
@@ -91,19 +91,19 @@ describe('Test SmartContract send FT to `HashLockFTV2`', () => {
                             },
                         ],
                         pubKeyOrAddrToSign: wrongPubKey,
-                    } as OrdiMethodCallOptions<BSV20V2P2PKH>
+                    } as OrdiMethodCallOptions<BSV21P2PKH>
                 )
             await expect(call()).to.be.rejectedWith(/signature check failed/)
         })
 
-        it('transfer FT to a BSV20V2P2PKH', async () => {
+        it('transfer FT to a BSV21P2PKH', async () => {
             await recipient.connect(signer)
             const ordAddress = await recipient.signer.getDefaultAddress()
             const call = async () => {
                 const { tx, nexts } = await recipient.methods.unlock(message, {
                     transfer: [
                         {
-                            instance: new BSV20V2P2PKH(
+                            instance: new BSV21P2PKH(
                                 tokenId,
                                 sym,
                                 max,
@@ -119,7 +119,7 @@ describe('Test SmartContract send FT to `HashLockFTV2`', () => {
                 // no token change
                 expect(nexts.length).to.equal(1)
 
-                const p2pkh = nexts[0].instance as BSV20V2P2PKH
+                const p2pkh = nexts[0].instance as BSV21P2PKH
 
                 expect(p2pkh.getAmt()).to.equal(15n)
             }
@@ -136,7 +136,7 @@ describe('Test SmartContract send FT to `HashLockFTV2`', () => {
                     {
                         transfer: [
                             {
-                                instance: new BSV20V2P2PKH(
+                                instance: new BSV21P2PKH(
                                     tokenId,
                                     sym,
                                     max,
@@ -164,21 +164,21 @@ describe('Test SmartContract send FT to `HashLockFTV2`', () => {
         const message = toByteString(text, true)
         const hash = sha256(message)
 
-        let recipient: HashLockFTV2
+        let recipient: HashLockBSV21
 
         const signer = getDefaultSigner()
 
         before(async () => {
-            HashLockFTV2.loadArtifact()
-            recipient = new HashLockFTV2(id, sym, max, dec, hash)
+            HashLockBSV21.loadArtifact()
+            recipient = new HashLockBSV21(id, sym, max, dec, hash)
         })
 
         it('transfer exist FT to a HashLock', async () => {
             const address = await getDefaultSigner().getDefaultAddress()
             const pubkey = await getDefaultSigner().getDefaultPubKey()
             // create p2pkh from a utxo
-            const p2pkh = BSV20V2P2PKH.fromUTXO(
-                dummyBSV20V2(address, fromByteString(id), 100n)
+            const p2pkh = BSV21P2PKH.fromUTXO(
+                dummyBSV21(address, fromByteString(id), 100n)
             )
 
             await p2pkh.connect(signer)
@@ -194,20 +194,20 @@ describe('Test SmartContract send FT to `HashLockFTV2`', () => {
                         },
                     ],
                     pubKeyOrAddrToSign: pubkey,
-                } as OrdiMethodCallOptions<BSV20V2P2PKH>
+                } as OrdiMethodCallOptions<BSV21P2PKH>
             )
 
             console.log('transfer FT: ', transferTx.id)
         })
 
-        it('transfer FT to a BSV20V2P2PKH', async () => {
+        it('transfer FT to a BSV21P2PKH', async () => {
             await recipient.connect(signer)
             const ordAddress = await recipient.signer.getDefaultAddress()
             const call = async () =>
                 await recipient.methods.unlock(message, {
                     transfer: [
                         {
-                            instance: new BSV20V2P2PKH(
+                            instance: new BSV21P2PKH(
                                 id,
                                 sym,
                                 max,
diff --git a/tests/specs/utils.ts b/tests/specs/utils.ts
index eaab85e..f3cbbf8 100644
--- a/tests/specs/utils.ts
+++ b/tests/specs/utils.ts
@@ -3,7 +3,7 @@ import { ContentType, Ordinal } from '../scrypt-ord'
 import { randomBytes } from 'crypto'
 
 /**
- * generate a dummy utxo contains a bsv20 v1 transfer inscription
+ * generate a dummy utxo contains a bsv20 transfer inscription
  * @param addr
  * @param tick
  * @param amt
@@ -37,14 +37,14 @@ export function dummyBSV20(
 }
 
 /**
- * generate a dummy utxo contains a bsv20 v2 transfer inscription
+ * generate a dummy utxo contains a bsv21 transfer inscription
  * @param addr
  * @param id
  * @param amt
  * @param prepend put bsv20 inscription at the front of the locking script if true
  * @returns
  */
-export function dummyBSV20V2(
+export function dummyBSV21(
     addr: bsv.Address,
     id: string,
     amt: bigint,