From 18c0fdaf8195874cb89de162d72ae2dd0276b60a Mon Sep 17 00:00:00 2001
From: IronLu233 <ironlu233.dev@outlook.com>
Date: Thu, 27 Apr 2023 14:34:13 +0800
Subject: [PATCH 01/11] fix(ownership-provider): add method  `isOwnedByWallet`

---
 package-lock.json                             | 12 ++++--
 packages/ownership-providers/package.json     |  6 ++-
 .../src/FullOwnershipProvider.ts              | 43 ++++++++++++++++++-
 3 files changed, 54 insertions(+), 7 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 088cdd17..fa5cc867 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9618,8 +9618,9 @@
     },
     "node_modules/@types/lodash.times": {
       "version": "4.3.7",
+      "resolved": "https://registry.npmjs.org/@types/lodash.times/-/lodash.times-4.3.7.tgz",
+      "integrity": "sha512-Jd7PPonqfO2zpNdwpF4dAH4DPSJ7hnsX35k8pFtkgNqSQWSWLINbi1HnTFAE/oOn6XXfXONahZWVVK3klTOIPg==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "@types/lodash": "*"
       }
@@ -23507,7 +23508,8 @@
     },
     "node_modules/lodash.times": {
       "version": "4.3.2",
-      "license": "MIT"
+      "resolved": "https://registry.npmjs.org/lodash.times/-/lodash.times-4.3.2.tgz",
+      "integrity": "sha512-FfaJzl0SA35CRPDh5SWe2BTght6y5KSK7yJv166qIp/8q7qOwBDCvuDZE2RUSMRpBkLF6rZKbLEUoTmaP3qg6A=="
     },
     "node_modules/lodash.union": {
       "version": "4.6.0",
@@ -37792,7 +37794,8 @@
       "dependencies": {
         "@nexus-wallet/protocol": "0.0.17",
         "@nexus-wallet/utils": "0.0.17",
-        "lodash.range": "3.2.0"
+        "lodash.range": "3.2.0",
+        "lodash.times": "4.3.2"
       },
       "devDependencies": {
         "@ckb-lumos/base": "0.20.0-alpha.2",
@@ -37801,7 +37804,8 @@
         "@ckb-lumos/common-scripts": "0.20.0-alpha.2",
         "@ckb-lumos/config-manager": "0.20.0-alpha.2",
         "@ckb-lumos/helpers": "0.20.0-alpha.2",
-        "@types/lodash.range": "3.2.7"
+        "@types/lodash.range": "3.2.7",
+        "@types/lodash.times": "4.3.7"
       },
       "peerDependencies": {
         "@ckb-lumos/base": "0.20.0-alpha.2",
diff --git a/packages/ownership-providers/package.json b/packages/ownership-providers/package.json
index 33df4978..f32eaa1d 100644
--- a/packages/ownership-providers/package.json
+++ b/packages/ownership-providers/package.json
@@ -33,7 +33,8 @@
   "dependencies": {
     "@nexus-wallet/protocol": "0.0.17",
     "@nexus-wallet/utils": "0.0.17",
-    "lodash.range": "3.2.0"
+    "lodash.range": "3.2.0",
+    "lodash.times": "4.3.2"
   },
   "devDependencies": {
     "@ckb-lumos/base": "0.20.0-alpha.2",
@@ -42,7 +43,8 @@
     "@ckb-lumos/common-scripts": "0.20.0-alpha.2",
     "@ckb-lumos/config-manager": "0.20.0-alpha.2",
     "@ckb-lumos/helpers": "0.20.0-alpha.2",
-    "@types/lodash.range": "3.2.7"
+    "@types/lodash.range": "3.2.7",
+    "@types/lodash.times": "4.3.7"
   },
   "peerDependencies": {
     "@ckb-lumos/base": "0.20.0-alpha.2",
diff --git a/packages/ownership-providers/src/FullOwnershipProvider.ts b/packages/ownership-providers/src/FullOwnershipProvider.ts
index 2efd0397..6ac0a74d 100644
--- a/packages/ownership-providers/src/FullOwnershipProvider.ts
+++ b/packages/ownership-providers/src/FullOwnershipProvider.ts
@@ -11,8 +11,9 @@ import { Address, blockchain, Cell, CellDep, HexString, Script, Transaction } fr
 import { bytes, PackParam } from '@ckb-lumos/codec';
 import { secp256k1Blake160 } from '@ckb-lumos/common-scripts';
 import { Config as LumosConfig, getConfig as getLumosConfig, ScriptConfig } from '@ckb-lumos/config-manager';
+import times from 'lodash.times';
 import { Uint8ArrayCodec } from '@ckb-lumos/codec/lib/base';
-import { OutputValidator } from '@nexus-wallet/protocol/lib/base';
+import { OutputValidator, Paginate } from '@nexus-wallet/protocol/lib/base';
 
 function equalPack<C extends Uint8ArrayCodec>(codec: C, a: PackParam<C>, b: PackParam<C>): boolean {
   return bytes.equal(codec.pack(a), codec.pack(b));
@@ -389,6 +390,46 @@ export class FullOwnershipProvider {
     });
   }
 
+  private async isOwnedByWallet(locks: Script[]): Promise<boolean[]> {
+    function stringifyLock(lock: Script) {
+      return bytes.hexify(blockchain.Script.pack(lock));
+    }
+    if (locks.length === 0) return [];
+
+    const offChainLockSet = new Set(
+      (
+        await Promise.all([
+          this.getOffChainLocks({ change: 'external' }),
+          this.getOffChainLocks({ change: 'internal' }),
+        ])
+      )
+        .flat()
+        .map(stringifyLock),
+    );
+    const result = times(locks.length, () => false);
+
+    locks.forEach((lock, index) => {
+      result[index] = offChainLockSet.has(bytes.hexify(blockchain.Script.pack(lock)));
+    });
+
+    for (const change of ['external', 'external'] as const) {
+      let cursor: string | undefined = undefined;
+
+      let page: Paginate<Script>;
+
+      do {
+        page = await this.getOnChainLocks({ change, cursor });
+        cursor = page.cursor;
+        const onChainLockSet = new Set(page.objects.map(stringifyLock));
+        locks.forEach((lock, index) => {
+          result[index] = result[index] || onChainLockSet.has(bytes.hexify(blockchain.Script.pack(lock)));
+        });
+      } while (page.objects.length > 0);
+    }
+
+    return result;
+  }
+
   private async getSecp256k1Blake160CellDep(): Promise<CellDep> {
     const config = await this.getSecp256k1Blake160Config();
     return { depType: config.DEP_TYPE, outPoint: { txHash: config.TX_HASH, index: config.INDEX } };

From 438715d9141964d210c52059db2d263ebac39865 Mon Sep 17 00:00:00 2001
From: IronLu233 <ironlu233.dev@outlook.com>
Date: Thu, 27 Apr 2023 15:20:40 +0800
Subject: [PATCH 02/11] fix(ownership-provider): support unsigned transaction

---
 package-lock.json                             |  6 +-
 packages/ownership-providers/package.json     |  6 +-
 .../src/FullOwnershipProvider.ts              | 74 +++++++++++++++----
 3 files changed, 65 insertions(+), 21 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index fa5cc867..f4743059 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -37794,8 +37794,7 @@
       "dependencies": {
         "@nexus-wallet/protocol": "0.0.17",
         "@nexus-wallet/utils": "0.0.17",
-        "lodash.range": "3.2.0",
-        "lodash.times": "4.3.2"
+        "lodash.range": "3.2.0"
       },
       "devDependencies": {
         "@ckb-lumos/base": "0.20.0-alpha.2",
@@ -37804,8 +37803,7 @@
         "@ckb-lumos/common-scripts": "0.20.0-alpha.2",
         "@ckb-lumos/config-manager": "0.20.0-alpha.2",
         "@ckb-lumos/helpers": "0.20.0-alpha.2",
-        "@types/lodash.range": "3.2.7",
-        "@types/lodash.times": "4.3.7"
+        "@types/lodash.range": "3.2.7"
       },
       "peerDependencies": {
         "@ckb-lumos/base": "0.20.0-alpha.2",
diff --git a/packages/ownership-providers/package.json b/packages/ownership-providers/package.json
index f32eaa1d..33df4978 100644
--- a/packages/ownership-providers/package.json
+++ b/packages/ownership-providers/package.json
@@ -33,8 +33,7 @@
   "dependencies": {
     "@nexus-wallet/protocol": "0.0.17",
     "@nexus-wallet/utils": "0.0.17",
-    "lodash.range": "3.2.0",
-    "lodash.times": "4.3.2"
+    "lodash.range": "3.2.0"
   },
   "devDependencies": {
     "@ckb-lumos/base": "0.20.0-alpha.2",
@@ -43,8 +42,7 @@
     "@ckb-lumos/common-scripts": "0.20.0-alpha.2",
     "@ckb-lumos/config-manager": "0.20.0-alpha.2",
     "@ckb-lumos/helpers": "0.20.0-alpha.2",
-    "@types/lodash.range": "3.2.7",
-    "@types/lodash.times": "4.3.7"
+    "@types/lodash.range": "3.2.7"
   },
   "peerDependencies": {
     "@ckb-lumos/base": "0.20.0-alpha.2",
diff --git a/packages/ownership-providers/src/FullOwnershipProvider.ts b/packages/ownership-providers/src/FullOwnershipProvider.ts
index 6ac0a74d..3d90d348 100644
--- a/packages/ownership-providers/src/FullOwnershipProvider.ts
+++ b/packages/ownership-providers/src/FullOwnershipProvider.ts
@@ -11,7 +11,6 @@ import { Address, blockchain, Cell, CellDep, HexString, Script, Transaction } fr
 import { bytes, PackParam } from '@ckb-lumos/codec';
 import { secp256k1Blake160 } from '@ckb-lumos/common-scripts';
 import { Config as LumosConfig, getConfig as getLumosConfig, ScriptConfig } from '@ckb-lumos/config-manager';
-import times from 'lodash.times';
 import { Uint8ArrayCodec } from '@ckb-lumos/codec/lib/base';
 import { OutputValidator, Paginate } from '@nexus-wallet/protocol/lib/base';
 
@@ -82,6 +81,10 @@ function sumCapacity(cells: TransactionSkeletonType['inputs' | 'outputs']) {
   return cells.reduce((prev, cur) => prev.add(cur.cellOutput.capacity), BI.from(0));
 }
 
+function hexifyScript(script: Script) {
+  return bytes.hexify(blockchain.Script.pack(script));
+}
+
 export type FullOwnershipProviderConfig = {
   ckb: InjectedCkb<RpcMethods, Events>;
 };
@@ -384,17 +387,61 @@ export class FullOwnershipProvider {
    * @returns Transaction hash in CKB network
    */
   async sendTransaction(txSkeleton: TransactionSkeletonType, outputsValidator?: OutputValidator): Promise<HexString> {
+    // pay fee
+    const walletOwnedOutputs = await this.isOwnedByWallet(
+      txSkeleton.outputs.map((input) => input.cellOutput.lock).toArray(),
+    );
+    const byOutputIndex = [...walletOwnedOutputs.entries()].reduce(
+      (prev: number[], [, cur], index) => (cur ? [...prev, index] : prev),
+      [],
+    );
+    txSkeleton = await this.payFee(txSkeleton, { byOutputIndexes: byOutputIndex, autoInject: true });
+
+    // sign
+    const walletOwnedInputs = await this.isOwnedByWallet(
+      txSkeleton.inputs.map((input) => input.cellOutput.lock).toArray(),
+    );
+
+    if (walletOwnedInputs.size > txSkeleton.witnesses.size) {
+      throw new Error(
+        `Some witnesses are missing!, required: ${walletOwnedInputs.size} from inputs, got: ${txSkeleton.witnesses.size} from witnesses.`,
+      );
+    }
+
+    const visitedLocks = new Set<string>();
+    let requireSign = false;
+    let witnessIndex = 0;
+    for (const cell of txSkeleton.inputs) {
+      const lock = hexifyScript(cell.cellOutput.lock);
+      if (visitedLocks.has(lock)) {
+        continue;
+      } else {
+        visitedLocks.add(lock);
+      }
+      if (
+        walletOwnedInputs.get(lock) &&
+        txSkeleton.witnesses.get(witnessIndex) === SECP256K1_BLAKE160_WITNESS_PLACEHOLDER
+      ) {
+        requireSign = true;
+        break;
+      } else {
+        witnessIndex++;
+      }
+    }
+
+    if (requireSign) {
+      await this.signTransaction(txSkeleton);
+    }
+
     return await this.ckb.request({
       method: 'ckb_sendTransaction',
       params: { tx: createTransactionFromSkeleton(txSkeleton), outputsValidator: outputsValidator },
     });
   }
 
-  private async isOwnedByWallet(locks: Script[]): Promise<boolean[]> {
-    function stringifyLock(lock: Script) {
-      return bytes.hexify(blockchain.Script.pack(lock));
-    }
-    if (locks.length === 0) return [];
+  private async isOwnedByWallet(locks: Script[]): Promise<Map<string, boolean>> {
+    const result: Map<string, boolean> = new Map();
+    if (locks.length === 0) return result;
 
     const offChainLockSet = new Set(
       (
@@ -404,12 +451,12 @@ export class FullOwnershipProvider {
         ])
       )
         .flat()
-        .map(stringifyLock),
+        .map(hexifyScript),
     );
-    const result = times(locks.length, () => false);
 
-    locks.forEach((lock, index) => {
-      result[index] = offChainLockSet.has(bytes.hexify(blockchain.Script.pack(lock)));
+    locks.forEach((lock) => {
+      const key = bytes.hexify(blockchain.Script.pack(lock));
+      result.set(key, result.get(key) || offChainLockSet.has(key));
     });
 
     for (const change of ['external', 'external'] as const) {
@@ -420,9 +467,10 @@ export class FullOwnershipProvider {
       do {
         page = await this.getOnChainLocks({ change, cursor });
         cursor = page.cursor;
-        const onChainLockSet = new Set(page.objects.map(stringifyLock));
-        locks.forEach((lock, index) => {
-          result[index] = result[index] || onChainLockSet.has(bytes.hexify(blockchain.Script.pack(lock)));
+        const onChainLockSet = new Set(page.objects.map(hexifyScript));
+        locks.forEach((lock) => {
+          const key = bytes.hexify(blockchain.Script.pack(lock));
+          result.set(key, result.get(key) || onChainLockSet.has(key));
         });
       } while (page.objects.length > 0);
     }

From 80c1a44f6e398c28d4090ee5e7a38bb9664cfea3 Mon Sep 17 00:00:00 2001
From: IronLu233 <ironlu233.dev@outlook.com>
Date: Thu, 27 Apr 2023 20:34:32 +0800
Subject: [PATCH 03/11] feat(ownership-providers): support payFee and
 signTransaction in send transaction

---
 examples/transfer-with-provider/src/App.tsx   |  4 +-
 .../__tests__/FullOwnershipProvider.test.ts   | 38 ++++++++++---------
 .../src/FullOwnershipProvider.ts              | 27 +++++++------
 3 files changed, 38 insertions(+), 31 deletions(-)

diff --git a/examples/transfer-with-provider/src/App.tsx b/examples/transfer-with-provider/src/App.tsx
index 38cbec46..5a2c3800 100644
--- a/examples/transfer-with-provider/src/App.tsx
+++ b/examples/transfer-with-provider/src/App.tsx
@@ -5,6 +5,8 @@ import { createTransactionFromSkeleton, parseAddress, encodeToAddress, Transacti
 import { predefined } from '@ckb-lumos/config-manager';
 import { RPC, config } from '@ckb-lumos/lumos';
 import { useAsyncState } from './hooks/useAsyncState';
+import { blockchain } from '@ckb-lumos/base';
+import { bytes } from '@ckb-lumos/codec';
 
 config.initializeConfig(predefined.AGGRON4);
 
@@ -76,8 +78,6 @@ function Transfer() {
 
     try {
       txSkeleton = await provider.injectCapacity(txSkeleton, { amount: receiveShannon });
-      txSkeleton = await provider.payFee(txSkeleton, { autoInject: true });
-      txSkeleton = await provider.signTransaction(txSkeleton);
 
       setLastTxHash('');
       const txHash = await provider.sendTransaction(txSkeleton);
diff --git a/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts b/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts
index e1ca0492..22f73bbe 100644
--- a/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts
+++ b/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts
@@ -90,6 +90,23 @@ const mockProviderConfig: FullOwnershipProviderConfig = {
   } as any,
 };
 
+function initProviderWithCells(cells: Cell[], offChainLock = [offChainLock1], onChainLock = [onChainLocks1]) {
+  mockRpcRequest.mockImplementation(({ method, params }: { method: string; params: any }) => {
+    switch (method) {
+      case 'wallet_fullOwnership_getOffChainLocks':
+        return offChainLock;
+      case 'wallet_fullOwnership_getOnChainLocks':
+        return params.cursor ? [] : { objects: onChainLock, cursor: '25' };
+      case 'wallet_fullOwnership_getLiveCells':
+        const cursor = parseInt(params.cursor || 0);
+        return { objects: cells.slice(cursor, cursor + 1), cursor: cursor + 1 };
+    }
+  });
+  const provider = new FullOwnershipProvider(mockProviderConfig);
+
+  return provider;
+}
+
 describe('class FullOwnershipProvider', () => {
   beforeEach(() => {
     mockRpcRequest.mockReset();
@@ -108,21 +125,6 @@ describe('class FullOwnershipProvider', () => {
   describe('#injectCapacity', () => {
     const emptyTxSkeleton = TransactionSkeleton();
 
-    function initProviderWithCells(cells: Cell[], offChainLock = [offChainLock1]) {
-      mockRpcRequest.mockImplementation(({ method, params }: { method: string; params: any }) => {
-        switch (method) {
-          case 'wallet_fullOwnership_getOffChainLocks':
-            return offChainLock;
-          case 'wallet_fullOwnership_getLiveCells':
-            const cursor = parseInt(params.cursor || 0);
-            return { objects: cells.slice(cursor, cursor + 1), cursor: cursor + 1 };
-        }
-      });
-      const provider = new FullOwnershipProvider(mockProviderConfig);
-
-      return provider;
-    }
-
     it('Should throw error when all cells capacity is not enough', async () => {
       const provider = initProviderWithCells([createFakeCellWithCapacity(100 * 1e8), createFakeCellWithCapacity(200)]);
 
@@ -521,11 +523,13 @@ describe('class FullOwnershipProvider', () => {
   });
 
   describe('#sendTransaction', () => {
-    it('signed transaction', async () => {
+    it('signed transaction with fee paid and signed', async () => {
+      const signedWitness = '0xffffff';
       const provider = new FullOwnershipProvider(mockProviderConfig);
       const txSkeleton = TransactionSkeleton()
         .update('inputs', (inputs) => inputs.push(createFakeCellWithCapacity(1000, onChainLocks1)))
-        .update('outputs', (outputs) => outputs.push(createFakeCellWithCapacity(100, onChainLocks2)));
+        .update('outputs', (outputs) => outputs.push(createFakeCellWithCapacity(100, onChainLocks2)))
+        .update('witnesses', (witnesses) => witnesses.push(signedWitness));
 
       await provider.sendTransaction(txSkeleton);
       expect(mockProviderConfig.ckb.request).toBeCalledWith({
diff --git a/packages/ownership-providers/src/FullOwnershipProvider.ts b/packages/ownership-providers/src/FullOwnershipProvider.ts
index 3d90d348..97616368 100644
--- a/packages/ownership-providers/src/FullOwnershipProvider.ts
+++ b/packages/ownership-providers/src/FullOwnershipProvider.ts
@@ -13,11 +13,14 @@ import { secp256k1Blake160 } from '@ckb-lumos/common-scripts';
 import { Config as LumosConfig, getConfig as getLumosConfig, ScriptConfig } from '@ckb-lumos/config-manager';
 import { Uint8ArrayCodec } from '@ckb-lumos/codec/lib/base';
 import { OutputValidator, Paginate } from '@nexus-wallet/protocol/lib/base';
+import { createLogger } from '@nexus-wallet/utils';
 
 function equalPack<C extends Uint8ArrayCodec>(codec: C, a: PackParam<C>, b: PackParam<C>): boolean {
   return bytes.equal(codec.pack(a), codec.pack(b));
 }
 
+const logger = createLogger('FullOwnershipProvider');
+
 // util types for FullOwnership
 
 type Suffix<T extends string, P extends string> = T extends `${P}${infer S}` ? S : never;
@@ -141,6 +144,7 @@ export class FullOwnershipProvider {
     if (!changeLock) {
       errors.throwError('No change lock script found, it may be a internal bug');
     }
+    logger.info('offChainlocks', hexifyScript(changeLock));
 
     const changeCell: Cell = {
       cellOutput: {
@@ -260,6 +264,7 @@ export class FullOwnershipProvider {
       sumCapacity(txSkeleton.get('inputs')).sub(sumCapacity(txSkeleton.get('outputs'))),
     );
 
+    // if fee is enough, directly return origin txSkeleton
     if (requireFee.lte(0)) {
       return txSkeleton;
     }
@@ -381,7 +386,8 @@ export class FullOwnershipProvider {
 
   /**
    * Send the transaction to CKB network
-   *
+   * If the transaction fee is not paid, it will use wallet cell to pay the fee.
+   * Then if the transaction is not signed, it will request sign the transaction first
    * @param txSkeleton - transaction skeleton
    * @param outputsValidator - Validates the transaction outputs before entering the tx-pool {@link https://github.com/nervosnetwork/ckb/blob/develop/rpc/README.md#type-outputsvalidator | OutputValidator}
    * @returns Transaction hash in CKB network
@@ -397,17 +403,14 @@ export class FullOwnershipProvider {
     );
     txSkeleton = await this.payFee(txSkeleton, { byOutputIndexes: byOutputIndex, autoInject: true });
 
-    // sign
+    // if not signed, sign the transaction first
     const walletOwnedInputs = await this.isOwnedByWallet(
       txSkeleton.inputs.map((input) => input.cellOutput.lock).toArray(),
     );
-
-    if (walletOwnedInputs.size > txSkeleton.witnesses.size) {
-      throw new Error(
-        `Some witnesses are missing!, required: ${walletOwnedInputs.size} from inputs, got: ${txSkeleton.witnesses.size} from witnesses.`,
-      );
-    }
-
+    assert(
+      walletOwnedInputs.size <= txSkeleton.witnesses.size,
+      `Some witnesses are missing!, required: ${walletOwnedInputs.size} from inputs, got: ${txSkeleton.witnesses.size} from witnesses.`,
+    );
     const visitedLocks = new Set<string>();
     let requireSign = false;
     let witnessIndex = 0;
@@ -430,7 +433,7 @@ export class FullOwnershipProvider {
     }
 
     if (requireSign) {
-      await this.signTransaction(txSkeleton);
+      txSkeleton = await this.signTransaction(txSkeleton);
     }
 
     return await this.ckb.request({
@@ -446,8 +449,8 @@ export class FullOwnershipProvider {
     const offChainLockSet = new Set(
       (
         await Promise.all([
-          this.getOffChainLocks({ change: 'external' }),
           this.getOffChainLocks({ change: 'internal' }),
+          this.getOffChainLocks({ change: 'external' }),
         ])
       )
         .flat()
@@ -459,7 +462,7 @@ export class FullOwnershipProvider {
       result.set(key, result.get(key) || offChainLockSet.has(key));
     });
 
-    for (const change of ['external', 'external'] as const) {
+    for (const change of ['internal', 'external'] as const) {
       let cursor: string | undefined = undefined;
 
       let page: Paginate<Script>;

From 2030500f5523a6ad30818335dca571ee51f5ef7a Mon Sep 17 00:00:00 2001
From: IronLu233 <ironlu233.dev@outlook.com>
Date: Thu, 27 Apr 2023 21:43:53 +0800
Subject: [PATCH 04/11] refactor: Top-to-bottom implementation

---
 .../src/FullOwnershipProvider.ts              | 89 +++++++++++--------
 1 file changed, 50 insertions(+), 39 deletions(-)

diff --git a/packages/ownership-providers/src/FullOwnershipProvider.ts b/packages/ownership-providers/src/FullOwnershipProvider.ts
index 97616368..07f564b0 100644
--- a/packages/ownership-providers/src/FullOwnershipProvider.ts
+++ b/packages/ownership-providers/src/FullOwnershipProvider.ts
@@ -393,46 +393,19 @@ export class FullOwnershipProvider {
    * @returns Transaction hash in CKB network
    */
   async sendTransaction(txSkeleton: TransactionSkeletonType, outputsValidator?: OutputValidator): Promise<HexString> {
-    // pay fee
-    const walletOwnedOutputs = await this.isOwnedByWallet(
-      txSkeleton.outputs.map((input) => input.cellOutput.lock).toArray(),
-    );
-    const byOutputIndex = [...walletOwnedOutputs.entries()].reduce(
-      (prev: number[], [, cur], index) => (cur ? [...prev, index] : prev),
-      [],
-    );
-    txSkeleton = await this.payFee(txSkeleton, { byOutputIndexes: byOutputIndex, autoInject: true });
-
-    // if not signed, sign the transaction first
-    const walletOwnedInputs = await this.isOwnedByWallet(
-      txSkeleton.inputs.map((input) => input.cellOutput.lock).toArray(),
-    );
-    assert(
-      walletOwnedInputs.size <= txSkeleton.witnesses.size,
-      `Some witnesses are missing!, required: ${walletOwnedInputs.size} from inputs, got: ${txSkeleton.witnesses.size} from witnesses.`,
-    );
-    const visitedLocks = new Set<string>();
-    let requireSign = false;
-    let witnessIndex = 0;
-    for (const cell of txSkeleton.inputs) {
-      const lock = hexifyScript(cell.cellOutput.lock);
-      if (visitedLocks.has(lock)) {
-        continue;
-      } else {
-        visitedLocks.add(lock);
-      }
-      if (
-        walletOwnedInputs.get(lock) &&
-        txSkeleton.witnesses.get(witnessIndex) === SECP256K1_BLAKE160_WITNESS_PLACEHOLDER
-      ) {
-        requireSign = true;
-        break;
-      } else {
-        witnessIndex++;
-      }
+    if (!this.isTransactionFeePaid(txSkeleton)) {
+      const walletOwnedOutputs = await this.isOwnedLocks(
+        txSkeleton.outputs.map((input) => input.cellOutput.lock).toArray(),
+      );
+      const byOutputIndex = [...walletOwnedOutputs.values()].reduce(
+        (prev: number[], cur, index) => (cur ? [...prev, index] : prev),
+        [],
+      );
+      txSkeleton = await this.payFee(txSkeleton, { byOutputIndexes: byOutputIndex, autoInject: true });
     }
 
-    if (requireSign) {
+    // if not signed, sign the transaction first
+    if (!(await this.isSecp256k1Signed(txSkeleton))) {
       txSkeleton = await this.signTransaction(txSkeleton);
     }
 
@@ -442,7 +415,7 @@ export class FullOwnershipProvider {
     });
   }
 
-  private async isOwnedByWallet(locks: Script[]): Promise<Map<string, boolean>> {
+  private async isOwnedLocks(locks: Script[]): Promise<Map<string, boolean>> {
     const result: Map<string, boolean> = new Map();
     if (locks.length === 0) return result;
 
@@ -481,6 +454,44 @@ export class FullOwnershipProvider {
     return result;
   }
 
+  private async isSecp256k1Signed(txSkeleton: TransactionSkeletonType): Promise<boolean> {
+    const walletOwnedInputs = await this.isOwnedLocks(
+      txSkeleton.inputs.map((input) => input.cellOutput.lock).toArray(),
+    );
+    assert(
+      walletOwnedInputs.size <= txSkeleton.witnesses.size,
+      `Some witnesses are missing!, required: ${walletOwnedInputs.size} from inputs, got: ${txSkeleton.witnesses.size} from witnesses.`,
+    );
+    const visitedLocks = new Set<string>();
+    let requireSign = true;
+    let witnessIndex = 0;
+    for (const cell of txSkeleton.inputs) {
+      const lock = hexifyScript(cell.cellOutput.lock);
+      if (visitedLocks.has(lock)) {
+        continue;
+      } else {
+        visitedLocks.add(lock);
+      }
+      if (
+        walletOwnedInputs.get(lock) &&
+        txSkeleton.witnesses.get(witnessIndex) === SECP256K1_BLAKE160_WITNESS_PLACEHOLDER
+      ) {
+        requireSign = false;
+        break;
+      } else {
+        witnessIndex++;
+      }
+    }
+
+    return requireSign;
+  }
+
+  private isTransactionFeePaid(txSkeleton: TransactionSkeletonType, feeRate: BIish = 1000): boolean {
+    return calculateFeeCompatible(getTransactionSizeByTx(createTransactionFromSkeleton(txSkeleton)), feeRate)
+      .sub(sumCapacity(txSkeleton.get('inputs')).sub(sumCapacity(txSkeleton.get('outputs'))))
+      .lte(0);
+  }
+
   private async getSecp256k1Blake160CellDep(): Promise<CellDep> {
     const config = await this.getSecp256k1Blake160Config();
     return { depType: config.DEP_TYPE, outPoint: { txHash: config.TX_HASH, index: config.INDEX } };

From 976642f1585bfa8b170ace3810d17669bf4e3c9e Mon Sep 17 00:00:00 2001
From: IronLu233 <ironlu233.dev@outlook.com>
Date: Thu, 27 Apr 2023 23:06:17 +0800
Subject: [PATCH 05/11] fix: filter type script cell when pay fee

---
 .../src/FullOwnershipProvider.ts              | 56 +++++++++----------
 1 file changed, 28 insertions(+), 28 deletions(-)

diff --git a/packages/ownership-providers/src/FullOwnershipProvider.ts b/packages/ownership-providers/src/FullOwnershipProvider.ts
index 07f564b0..a501e59c 100644
--- a/packages/ownership-providers/src/FullOwnershipProvider.ts
+++ b/packages/ownership-providers/src/FullOwnershipProvider.ts
@@ -12,15 +12,12 @@ import { bytes, PackParam } from '@ckb-lumos/codec';
 import { secp256k1Blake160 } from '@ckb-lumos/common-scripts';
 import { Config as LumosConfig, getConfig as getLumosConfig, ScriptConfig } from '@ckb-lumos/config-manager';
 import { Uint8ArrayCodec } from '@ckb-lumos/codec/lib/base';
-import { OutputValidator, Paginate } from '@nexus-wallet/protocol/lib/base';
-import { createLogger } from '@nexus-wallet/utils';
+import { OutputValidator } from '@nexus-wallet/protocol/lib/base';
 
 function equalPack<C extends Uint8ArrayCodec>(codec: C, a: PackParam<C>, b: PackParam<C>): boolean {
   return bytes.equal(codec.pack(a), codec.pack(b));
 }
 
-const logger = createLogger('FullOwnershipProvider');
-
 // util types for FullOwnership
 
 type Suffix<T extends string, P extends string> = T extends `${P}${infer S}` ? S : never;
@@ -144,7 +141,6 @@ export class FullOwnershipProvider {
     if (!changeLock) {
       errors.throwError('No change lock script found, it may be a internal bug');
     }
-    logger.info('offChainlocks', hexifyScript(changeLock));
 
     const changeCell: Cell = {
       cellOutput: {
@@ -250,6 +246,9 @@ export class FullOwnershipProvider {
    * ```
    */
   async payFee(txSkeleton: TransactionSkeletonType, options: PayFeeOptions): Promise<TransactionSkeletonType> {
+    // TODO: dynamic byOutputIndexes default value
+    // options.byOutputIndexes = options.byOutputIndexes ?? (await this.getByOutputIndexesFromOriginal(txSkeleton));
+
     if (options.byOutputIndexes?.length === 0 && !options.autoInject) {
       errors.throwError('no byOutputIndexes is provided, but autoInject is `false`');
     }
@@ -394,14 +393,8 @@ export class FullOwnershipProvider {
    */
   async sendTransaction(txSkeleton: TransactionSkeletonType, outputsValidator?: OutputValidator): Promise<HexString> {
     if (!this.isTransactionFeePaid(txSkeleton)) {
-      const walletOwnedOutputs = await this.isOwnedLocks(
-        txSkeleton.outputs.map((input) => input.cellOutput.lock).toArray(),
-      );
-      const byOutputIndex = [...walletOwnedOutputs.values()].reduce(
-        (prev: number[], cur, index) => (cur ? [...prev, index] : prev),
-        [],
-      );
-      txSkeleton = await this.payFee(txSkeleton, { byOutputIndexes: byOutputIndex, autoInject: true });
+      const byOutputIndexes = await this.getByOutputIndexesFromOriginal(txSkeleton);
+      txSkeleton = await this.payFee(txSkeleton, { byOutputIndexes, autoInject: true });
     }
 
     // if not signed, sign the transaction first
@@ -415,7 +408,7 @@ export class FullOwnershipProvider {
     });
   }
 
-  private async isOwnedLocks(locks: Script[]): Promise<Map<string, boolean>> {
+  private async isOwnedLocks(locks: Script[], noTypeScript = false): Promise<Map<string, boolean>> {
     const result: Map<string, boolean> = new Map();
     if (locks.length === 0) return result;
 
@@ -435,22 +428,17 @@ export class FullOwnershipProvider {
       result.set(key, result.get(key) || offChainLockSet.has(key));
     });
 
-    for (const change of ['internal', 'external'] as const) {
-      let cursor: string | undefined = undefined;
-
-      let page: Paginate<Script>;
-
-      do {
-        page = await this.getOnChainLocks({ change, cursor });
-        cursor = page.cursor;
-        const onChainLockSet = new Set(page.objects.map(hexifyScript));
-        locks.forEach((lock) => {
-          const key = bytes.hexify(blockchain.Script.pack(lock));
-          result.set(key, result.get(key) || onChainLockSet.has(key));
-        });
-      } while (page.objects.length > 0);
+    const onChainLockSet = new Set();
+    for await (const cell of this.collector()) {
+      if (cell.cellOutput.type && noTypeScript) continue;
+      onChainLockSet.add(bytes.hexify(blockchain.Script.pack(cell.cellOutput.lock)));
     }
 
+    locks.forEach((lock) => {
+      const key = bytes.hexify(blockchain.Script.pack(lock));
+      result.set(key, result.get(key) || onChainLockSet.has(key));
+    });
+
     return result;
   }
 
@@ -492,6 +480,18 @@ export class FullOwnershipProvider {
       .lte(0);
   }
 
+  private async getByOutputIndexesFromOriginal(txSkeleton: TransactionSkeletonType): Promise<number[]> {
+    const walletOwnedOutputs = await this.isOwnedLocks(
+      txSkeleton.outputs.map((input) => input.cellOutput.lock).toArray(),
+      true,
+    );
+    const byOutputIndex = [...walletOwnedOutputs.values()].reduce(
+      (prev: number[], cur, index) => (cur ? [...prev, index] : prev),
+      [],
+    );
+    return byOutputIndex;
+  }
+
   private async getSecp256k1Blake160CellDep(): Promise<CellDep> {
     const config = await this.getSecp256k1Blake160Config();
     return { depType: config.DEP_TYPE, outPoint: { txHash: config.TX_HASH, index: config.INDEX } };

From 735bbdfc6f00fd6c3329a7c386a652fa043a4614 Mon Sep 17 00:00:00 2001
From: IronLu233 <ironlu233.dev@outlook.com>
Date: Fri, 28 Apr 2023 18:06:06 +0800
Subject: [PATCH 06/11] test: add unit test for send transaction

---
 .../__tests__/FullOwnershipProvider.test.ts   | 181 +++++++++++++++---
 .../src/FullOwnershipProvider.ts              |  75 ++------
 packages/ownership-providers/src/types.ts     |   1 +
 packages/ownership-providers/src/utils.ts     |  48 +++++
 4 files changed, 224 insertions(+), 81 deletions(-)
 create mode 100644 packages/ownership-providers/src/types.ts
 create mode 100644 packages/ownership-providers/src/utils.ts

diff --git a/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts b/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts
index 22f73bbe..84b24922 100644
--- a/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts
+++ b/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts
@@ -2,12 +2,13 @@
 import { BI, BIish, parseUnit } from '@ckb-lumos/bi';
 import { createTransactionFromSkeleton, TransactionSkeleton, TransactionSkeletonType } from '@ckb-lumos/helpers';
 import { common, secp256k1Blake160 } from '@ckb-lumos/common-scripts';
-import { Cell, Script } from '@nexus-wallet/protocol';
+import { Cell, GroupedSignature, Script } from '@nexus-wallet/protocol';
 import { predefined } from '@ckb-lumos/config-manager';
 import { FullOwnershipProvider } from '../src';
 import { WitnessArgs } from '@ckb-lumos/base/lib/blockchain';
 import { bytes } from '@ckb-lumos/codec';
 import { FullOwnershipProviderConfig } from '../src/FullOwnershipProvider';
+import { SECP256K1_BLAKE160_WITNESS_PLACEHOLDER, sumCapacity, WITNESS_LOCK_PLACEHOLDER } from '../src/utils';
 import { blockchain } from '@ckb-lumos/base';
 
 function getExpectedFee(txSkeleton: TransactionSkeletonType, feeRate = BI.from(1000)): BI {
@@ -17,8 +18,8 @@ function getExpectedFee(txSkeleton: TransactionSkeletonType, feeRate = BI.from(1
 }
 
 function getTxSkeletonFee(txSkeleton: TransactionSkeletonType): BI {
-  const inputsTotal = txSkeleton.get('inputs').reduce((acc, cur) => acc.add(cur.cellOutput.capacity), BI.from(0));
-  const outputsTotal = txSkeleton.get('outputs').reduce((acc, cur) => acc.add(cur.cellOutput.capacity), BI.from(0));
+  const inputsTotal = sumCapacity(txSkeleton.get('inputs'));
+  const outputsTotal = sumCapacity(txSkeleton.get('outputs'));
 
   return inputsTotal.sub(outputsTotal);
 }
@@ -29,7 +30,7 @@ const offChainLock1: Script = {
   args: '0x11223344',
 };
 
-function createOnchainLock(args: string): Script {
+function createScript(args: string): Script {
   return {
     codeHash: '0xe1e2dab12f5bff4b282f428876714be021155baee934312dd08d298e5bb09f97',
     hashType: 'type',
@@ -37,9 +38,9 @@ function createOnchainLock(args: string): Script {
   };
 }
 
-const onChainLocks1: Script = createOnchainLock('0x441509af');
-const onChainLocks2: Script = createOnchainLock('0x25061223');
-const onChainLocks3: Script = createOnchainLock('0x25061224');
+const onChainLocks1: Script = createScript('0x441509af');
+const onChainLocks2: Script = createScript('0x25061223');
+const onChainLocks3: Script = createScript('0x25061224');
 
 function parseCapacity(capacity: string): BI {
   if (/&\d+$/.test(capacity)) {
@@ -90,16 +91,28 @@ const mockProviderConfig: FullOwnershipProviderConfig = {
   } as any,
 };
 
-function initProviderWithCells(cells: Cell[], offChainLock = [offChainLock1], onChainLock = [onChainLocks1]) {
+function createFakeProvider({
+  cells,
+  offChainLocks = [offChainLock1],
+  onChainLocks = [onChainLocks1],
+  groupedSignature = [],
+}: {
+  cells: Cell[];
+  offChainLocks?: Script[];
+  onChainLocks?: Script[];
+  groupedSignature?: GroupedSignature;
+}) {
   mockRpcRequest.mockImplementation(({ method, params }: { method: string; params: any }) => {
     switch (method) {
       case 'wallet_fullOwnership_getOffChainLocks':
-        return offChainLock;
+        return offChainLocks;
       case 'wallet_fullOwnership_getOnChainLocks':
-        return params.cursor ? [] : { objects: onChainLock, cursor: '25' };
+        return params.cursor ? [] : { objects: onChainLocks, cursor: '25' };
       case 'wallet_fullOwnership_getLiveCells':
         const cursor = parseInt(params.cursor || 0);
         return { objects: cells.slice(cursor, cursor + 1), cursor: cursor + 1 };
+      case 'wallet_fullOwnership_signTransaction':
+        return groupedSignature;
     }
   });
   const provider = new FullOwnershipProvider(mockProviderConfig);
@@ -126,19 +139,23 @@ describe('class FullOwnershipProvider', () => {
     const emptyTxSkeleton = TransactionSkeleton();
 
     it('Should throw error when all cells capacity is not enough', async () => {
-      const provider = initProviderWithCells([createFakeCellWithCapacity(100 * 1e8), createFakeCellWithCapacity(200)]);
+      const provider = createFakeProvider({
+        cells: [createFakeCellWithCapacity(100 * 1e8), createFakeCellWithCapacity(200)],
+      });
 
       await expect(provider.injectCapacity(emptyTxSkeleton, { amount: 400 * 1e8 })).rejects.toThrowError(
         /No cell sufficient to inject/,
       );
     });
     it('Should pick lock-only cell', async () => {
-      const provider = initProviderWithCells([
-        createFakeCellWithCapacity(500000 * 1e8, offChainLock1, offChainLock1),
-        createFakeCellWithCapacity(500000 * 1e8, onChainLocks1, undefined, 0, '0x123321'),
-        createFakeCellWithCapacity(500 * 1e8, offChainLock1),
-        createFakeCellWithCapacity(200 * 1e8, onChainLocks2),
-      ]);
+      const provider = createFakeProvider({
+        cells: [
+          createFakeCellWithCapacity(500000 * 1e8, offChainLock1, offChainLock1),
+          createFakeCellWithCapacity(500000 * 1e8, onChainLocks1, undefined, 0, '0x123321'),
+          createFakeCellWithCapacity(500 * 1e8, offChainLock1),
+          createFakeCellWithCapacity(200 * 1e8, onChainLocks2),
+        ],
+      });
 
       const skeleton = await provider.injectCapacity(emptyTxSkeleton, { amount: 144 * 1e8 });
       expect(skeleton.get('inputs').size).toBe(1);
@@ -148,10 +165,9 @@ describe('class FullOwnershipProvider', () => {
     });
 
     it('Should pick one cell when capacity is enough', async () => {
-      const provider = initProviderWithCells([
-        createFakeCellWithCapacity(500 * 1e8),
-        createFakeCellWithCapacity(200 * 1e8),
-      ]);
+      const provider = createFakeProvider({
+        cells: [createFakeCellWithCapacity(500 * 1e8), createFakeCellWithCapacity(200 * 1e8)],
+      });
       const skeleton = await provider.injectCapacity(emptyTxSkeleton, { amount: 144 * 1e8 });
       expect(skeleton.get('inputs').size).toBe(1);
       expect(skeleton.get('inputs').get(0)?.cellOutput.capacity).toBe(BI.from(500 * 1e8).toHexString());
@@ -164,7 +180,7 @@ describe('class FullOwnershipProvider', () => {
       const cell2 = createFakeCellWithCapacity('100ckb', onChainLocks2, undefined, 1);
       const cell3 = createFakeCellWithCapacity('300ckb', onChainLocks1, undefined, 2);
 
-      const provider = initProviderWithCells([cell1, cell2, cell3]);
+      const provider = createFakeProvider({ cells: [cell1, cell2, cell3] });
 
       const injectAmount = parseUnit('250', 'ckb');
       const skeleton = await provider.injectCapacity(emptyTxSkeleton, { amount: injectAmount });
@@ -180,7 +196,7 @@ describe('class FullOwnershipProvider', () => {
       const cell3 = createFakeCellWithCapacity('100ckb', onChainLocks2, undefined, 2);
       const cell4 = createFakeCellWithCapacity('300ckb', onChainLocks2, undefined, 3);
 
-      const provider = initProviderWithCells([cell1, cell2, cell3, cell4]);
+      const provider = createFakeProvider({ cells: [cell1, cell2, cell3, cell4] });
 
       const injectAmount = parseUnit('550', 'ckb');
       const skeleton = await provider.injectCapacity(emptyTxSkeleton, { amount: injectAmount });
@@ -199,7 +215,7 @@ describe('class FullOwnershipProvider', () => {
     });
 
     it('Should throw error when changeLock is not found', async () => {
-      const provider = initProviderWithCells([], []);
+      const provider = createFakeProvider({ cells: [], offChainLocks: [] });
       // @ts-expect-error
       await expect(provider.injectCapacity()).rejects.toThrowError(
         'No change lock script found, it may be a internal bug',
@@ -524,18 +540,133 @@ describe('class FullOwnershipProvider', () => {
 
   describe('#sendTransaction', () => {
     it('signed transaction with fee paid and signed', async () => {
+      const provider = createFakeProvider({
+        cells: [createFakeCellWithCapacity(1000, onChainLocks1), createFakeCellWithCapacity(100, onChainLocks2)],
+      });
       const signedWitness = '0xffffff';
-      const provider = new FullOwnershipProvider(mockProviderConfig);
+
+      // input: 1000CKB
+      // output: 100CKB
+      // signedWitness: 0xffffff
       const txSkeleton = TransactionSkeleton()
         .update('inputs', (inputs) => inputs.push(createFakeCellWithCapacity(1000, onChainLocks1)))
         .update('outputs', (outputs) => outputs.push(createFakeCellWithCapacity(100, onChainLocks2)))
         .update('witnesses', (witnesses) => witnesses.push(signedWitness));
 
+      jest.spyOn(provider, 'payFee');
+      jest.spyOn(provider, 'signTransaction');
       await provider.sendTransaction(txSkeleton);
+      expect(provider.payFee).not.toHaveBeenCalled();
+      expect(provider.signTransaction).not.toHaveBeenCalled();
       expect(mockProviderConfig.ckb.request).toBeCalledWith({
         method: 'ckb_sendTransaction',
         params: { tx: createTransactionFromSkeleton(txSkeleton), outputsValidator: undefined },
       });
     });
+
+    it('Should fee paid transaction be signed and sent', async () => {
+      const provider = createFakeProvider({
+        cells: [
+          createFakeCellWithCapacity(1000 * 1e8, onChainLocks1),
+          createFakeCellWithCapacity(100 * 1e8, onChainLocks1),
+        ],
+        offChainLocks: [offChainLock1],
+        groupedSignature: [[onChainLocks1, WITNESS_LOCK_PLACEHOLDER]],
+      });
+
+      // input: 1000CKB
+      // output: 100CKB
+      // unsigned
+      const txSkeleton = TransactionSkeleton()
+        .update('inputs', (inputs) => inputs.push(createFakeCellWithCapacity(1000 * 1e8, onChainLocks1)))
+        .update('outputs', (outputs) =>
+          outputs.push(createFakeCellWithCapacity(100 * 1e8, onChainLocks1, undefined, 2)),
+        )
+        .update('witnesses', (witnesses) => witnesses.push(SECP256K1_BLAKE160_WITNESS_PLACEHOLDER));
+
+      jest.spyOn(provider, 'payFee');
+
+      await provider.sendTransaction(txSkeleton);
+
+      expect(provider.payFee).not.toHaveBeenCalled();
+      expect(mockProviderConfig.ckb.request).toBeCalledWith({
+        method: 'wallet_fullOwnership_signTransaction',
+        params: {
+          tx: createTransactionFromSkeleton(txSkeleton),
+        },
+      });
+    });
+
+    it('Should fee unpaid transaction be pay fee, sign and sent', async () => {
+      const provider = createFakeProvider({
+        cells: [
+          createFakeCellWithCapacity(1000 * 1e8, onChainLocks1, createScript('0x255')),
+          createFakeCellWithCapacity(1000 * 1e8, onChainLocks2, undefined, 1),
+          createFakeCellWithCapacity(1000 * 1e8, onChainLocks2, undefined, 3),
+        ],
+        offChainLocks: [offChainLock1],
+        groupedSignature: [[onChainLocks1, WITNESS_LOCK_PLACEHOLDER]],
+      });
+
+      // input 2000 1e8 CKB
+      // output1: 1000 1e8 CKB, but this onchain lock has a type script
+      // output2: 1000 1e8 CKB, lock only
+      // expected: deduct output2 capacity for transaction fee
+      const txSkeleton = TransactionSkeleton()
+        .update('inputs', (inputs) => inputs.push(createFakeCellWithCapacity(2000 * 1e8, onChainLocks1)))
+        .update('outputs', (outputs) =>
+          outputs.push(
+            createFakeCellWithCapacity(1000 * 1e8, onChainLocks1),
+            createFakeCellWithCapacity(1000 * 1e8, onChainLocks2),
+          ),
+        )
+        .update('witnesses', (witnesses) =>
+          witnesses.push(SECP256K1_BLAKE160_WITNESS_PLACEHOLDER, SECP256K1_BLAKE160_WITNESS_PLACEHOLDER),
+        );
+
+      const payFee = jest.spyOn(provider, 'payFee');
+
+      const signTransaction = jest.spyOn(provider, 'signTransaction');
+
+      await provider.sendTransaction(txSkeleton);
+      expect(provider.payFee).toHaveBeenCalledWith(txSkeleton, { autoInject: true, byOutputIndexes: [1] });
+
+      const txWithPayFee: TransactionSkeletonType = await payFee.mock.results[0].value;
+      const deductedCapacity = txWithPayFee.outputs.get(1)?.cellOutput.capacity!;
+
+      expect(
+        BI.from(1000 * 1e8)
+          .sub(deductedCapacity)
+          .toBigInt(),
+      ).toBe(getExpectedFee(txSkeleton).toBigInt());
+
+      expect(provider.signTransaction).toHaveBeenCalledWith(txWithPayFee);
+      expect(mockProviderConfig.ckb.request).toBeCalledWith({
+        method: 'wallet_fullOwnership_signTransaction',
+        params: {
+          tx: createTransactionFromSkeleton(txWithPayFee),
+        },
+      });
+
+      const signedTransaction = await signTransaction.mock.results[0].value;
+      expect(mockProviderConfig.ckb.request).toBeCalledWith({
+        method: 'ckb_sendTransaction',
+        params: { tx: createTransactionFromSkeleton(signedTransaction) },
+      });
+    });
+    it('Should throw error when witnesses is not enough', async () => {
+      const provider = createFakeProvider({
+        cells: [],
+        offChainLocks: [offChainLock1],
+      });
+
+      const txSkeleton = TransactionSkeleton()
+        .update('inputs', (inputs) => inputs.push(createFakeCellWithCapacity(1000 * 1e8, onChainLocks1)))
+        .update('outputs', (outputs) => outputs.push(createFakeCellWithCapacity(500 * 1e8, onChainLocks1)));
+
+      await expect(() => provider.sendTransaction(txSkeleton)).rejects.toThrowError(
+        'Some witnesses are missing!, required: 1 from inputs, got: 0',
+      );
+    });
   });
 });
diff --git a/packages/ownership-providers/src/FullOwnershipProvider.ts b/packages/ownership-providers/src/FullOwnershipProvider.ts
index a501e59c..28a537ed 100644
--- a/packages/ownership-providers/src/FullOwnershipProvider.ts
+++ b/packages/ownership-providers/src/FullOwnershipProvider.ts
@@ -7,39 +7,27 @@ import {
   minimalCellCapacityCompatible,
   TransactionSkeletonType,
 } from '@ckb-lumos/helpers';
-import { Address, blockchain, Cell, CellDep, HexString, Script, Transaction } from '@ckb-lumos/base';
-import { bytes, PackParam } from '@ckb-lumos/codec';
+import { blockchain, Cell, CellDep, HexString, Script } from '@ckb-lumos/base';
+import { bytes } from '@ckb-lumos/codec';
 import { secp256k1Blake160 } from '@ckb-lumos/common-scripts';
 import { Config as LumosConfig, getConfig as getLumosConfig, ScriptConfig } from '@ckb-lumos/config-manager';
-import { Uint8ArrayCodec } from '@ckb-lumos/codec/lib/base';
 import { OutputValidator } from '@nexus-wallet/protocol/lib/base';
-
-function equalPack<C extends Uint8ArrayCodec>(codec: C, a: PackParam<C>, b: PackParam<C>): boolean {
-  return bytes.equal(codec.pack(a), codec.pack(b));
-}
+import { Suffix } from './types';
+import {
+  calculateFeeCompatible,
+  equalPack,
+  getTransactionSizeByTx,
+  hexifyScript,
+  SECP256K1_BLAKE160_WITNESS_PLACEHOLDER,
+  sumCapacity,
+} from './utils';
 
 // util types for FullOwnership
-
-type Suffix<T extends string, P extends string> = T extends `${P}${infer S}` ? S : never;
 type FullOwnershipPrefix = 'wallet_fullOwnership_';
 type OwnershipMethodNames = Suffix<keyof FullOwnership, FullOwnershipPrefix>;
 type ParamOf<K extends OwnershipMethodNames> = Parameters<FullOwnership[`${FullOwnershipPrefix}${K}`]>[0];
 type ReturnOf<K extends OwnershipMethodNames> = ReturnType<FullOwnership[`${FullOwnershipPrefix}${K}`]>;
 
-/** Must be a full format address if it's an address */
-export type LockScriptLike = Address | Script;
-
-const SECP256K1_SIGNATURE_SIZE = 65;
-
-/**
- * @internal
- */
-export const SECP256K1_BLAKE160_WITNESS_PLACEHOLDER = bytes.hexify(
-  blockchain.WitnessArgs.pack({
-    lock: new Uint8Array(SECP256K1_SIGNATURE_SIZE),
-  }),
-);
-
 export type PayFeeOptions = {
   /**
    * The fee rate, in Shannons per byte. If not specified, the fee rate will be calculated automatically.
@@ -57,34 +45,6 @@ export type PayFeeOptions = {
   autoInject: boolean;
 };
 
-// TODO: let lumos export `getTransactionSizeByTx` and `calculateFeeCompatible` and `lockToScript`
-/* istanbul ignore next */
-function getTransactionSizeByTx(tx: Transaction): number {
-  const serializedTx = blockchain.Transaction.pack(tx);
-  // 4 is serialized offset bytesize
-  const size = serializedTx.byteLength + 4;
-  return size;
-}
-
-/* istanbul ignore next */
-function calculateFeeCompatible(size: number, feeRate: BIish): BI {
-  const ratio = BI.from(1000);
-  const base = BI.from(size).mul(feeRate);
-  const fee = base.div(ratio);
-  if (fee.mul(ratio).lt(base)) {
-    return fee.add(1);
-  }
-  return BI.from(fee);
-}
-
-function sumCapacity(cells: TransactionSkeletonType['inputs' | 'outputs']) {
-  return cells.reduce((prev, cur) => prev.add(cur.cellOutput.capacity), BI.from(0));
-}
-
-function hexifyScript(script: Script) {
-  return bytes.hexify(blockchain.Script.pack(script));
-}
-
 export type FullOwnershipProviderConfig = {
   ckb: InjectedCkb<RpcMethods, Events>;
 };
@@ -166,8 +126,8 @@ export class FullOwnershipProvider {
         continue;
       }
 
-      // a cell with lock-only will be injected
-      if (cell.cellOutput.type || cell.data !== '0x') {
+      // lock-only will be injected
+      if (!this.isLockOnlyCell(cell)) {
         continue;
       }
 
@@ -364,7 +324,6 @@ export class FullOwnershipProvider {
         equalPack(blockchain.Script, input.cellOutput.lock, lock),
       );
 
-      /* istanbul ignore next */
       if (witnessIndex === -1) {
         continue;
       }
@@ -408,7 +367,7 @@ export class FullOwnershipProvider {
     });
   }
 
-  private async isOwnedLocks(locks: Script[], noTypeScript = false): Promise<Map<string, boolean>> {
+  private async isOwnedLocks(locks: Script[], onlyLockOnlyCell = false): Promise<Map<string, boolean>> {
     const result: Map<string, boolean> = new Map();
     if (locks.length === 0) return result;
 
@@ -430,7 +389,7 @@ export class FullOwnershipProvider {
 
     const onChainLockSet = new Set();
     for await (const cell of this.collector()) {
-      if (cell.cellOutput.type && noTypeScript) continue;
+      if (onlyLockOnlyCell && !this.isLockOnlyCell(cell)) continue;
       onChainLockSet.add(bytes.hexify(blockchain.Script.pack(cell.cellOutput.lock)));
     }
 
@@ -492,6 +451,10 @@ export class FullOwnershipProvider {
     return byOutputIndex;
   }
 
+  private isLockOnlyCell(cell: Cell): boolean {
+    return !cell.cellOutput.type && cell.data === '0x';
+  }
+
   private async getSecp256k1Blake160CellDep(): Promise<CellDep> {
     const config = await this.getSecp256k1Blake160Config();
     return { depType: config.DEP_TYPE, outPoint: { txHash: config.TX_HASH, index: config.INDEX } };
diff --git a/packages/ownership-providers/src/types.ts b/packages/ownership-providers/src/types.ts
new file mode 100644
index 00000000..c0d18dae
--- /dev/null
+++ b/packages/ownership-providers/src/types.ts
@@ -0,0 +1 @@
+export type Suffix<T extends string, P extends string> = T extends `${P}${infer S}` ? S : never;
diff --git a/packages/ownership-providers/src/utils.ts b/packages/ownership-providers/src/utils.ts
new file mode 100644
index 00000000..b82456b3
--- /dev/null
+++ b/packages/ownership-providers/src/utils.ts
@@ -0,0 +1,48 @@
+import { Address, blockchain, HexString, Script, Transaction } from '@ckb-lumos/base';
+import { BI, BIish } from '@ckb-lumos/bi';
+import { bytes } from '@ckb-lumos/codec';
+import { PackParam, Uint8ArrayCodec } from '@ckb-lumos/codec/lib/base';
+import { TransactionSkeletonType } from '@ckb-lumos/helpers';
+
+export function equalPack<C extends Uint8ArrayCodec>(codec: C, a: PackParam<C>, b: PackParam<C>): boolean {
+  return bytes.equal(codec.pack(a), codec.pack(b));
+}
+
+export const WITNESS_LOCK_PLACEHOLDER = bytes.hexify(new Uint8Array(65));
+
+export const SECP256K1_BLAKE160_WITNESS_PLACEHOLDER = bytes.hexify(
+  blockchain.WitnessArgs.pack({
+    lock: WITNESS_LOCK_PLACEHOLDER,
+  }),
+);
+
+/** Must be a full format address if it's an address */
+export type LockScriptLike = Address | Script;
+
+// TODO: let lumos export `getTransactionSizeByTx` and `calculateFeeCompatible` and `lockToScript`
+/* istanbul ignore next */
+export function getTransactionSizeByTx(tx: Transaction): number {
+  const serializedTx = blockchain.Transaction.pack(tx);
+  // 4 is serialized offset bytesize
+  const size = serializedTx.byteLength + 4;
+  return size;
+}
+
+/* istanbul ignore next */
+export function calculateFeeCompatible(size: number, feeRate: BIish): BI {
+  const ratio = BI.from(1000);
+  const base = BI.from(size).mul(feeRate);
+  const fee = base.div(ratio);
+  if (fee.mul(ratio).lt(base)) {
+    return fee.add(1);
+  }
+  return BI.from(fee);
+}
+
+export function sumCapacity(cells: TransactionSkeletonType['inputs' | 'outputs']): BI {
+  return cells.reduce((prev, cur) => prev.add(cur.cellOutput.capacity), BI.from(0));
+}
+
+export function hexifyScript(script: Script): HexString {
+  return bytes.hexify(blockchain.Script.pack(script));
+}

From 9d9ba2c14ccfc682e23ad5d7a2138891c17f00a3 Mon Sep 17 00:00:00 2001
From: IronLu233 <ironlu233.dev@outlook.com>
Date: Fri, 28 Apr 2023 19:00:24 +0800
Subject: [PATCH 07/11] test: modify code for coverage

---
 .../__tests__/FullOwnershipProvider.test.ts                | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts b/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts
index 84b24922..2b1c5d07 100644
--- a/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts
+++ b/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts
@@ -578,7 +578,12 @@ describe('class FullOwnershipProvider', () => {
       // output: 100CKB
       // unsigned
       const txSkeleton = TransactionSkeleton()
-        .update('inputs', (inputs) => inputs.push(createFakeCellWithCapacity(1000 * 1e8, onChainLocks1)))
+        .update('inputs', (inputs) =>
+          inputs.push(
+            createFakeCellWithCapacity(500 * 1e8, onChainLocks1),
+            createFakeCellWithCapacity(500 * 1e8, onChainLocks1),
+          ),
+        )
         .update('outputs', (outputs) =>
           outputs.push(createFakeCellWithCapacity(100 * 1e8, onChainLocks1, undefined, 2)),
         )

From 671b2060973be0d213c1a8e7518032cd2193ba76 Mon Sep 17 00:00:00 2001
From: IronLu233 <ironlu233.dev@outlook.com>
Date: Fri, 28 Apr 2023 21:30:42 +0800
Subject: [PATCH 08/11] fix: logic bug

---
 .../__tests__/FullOwnershipProvider.test.ts   | 24 +++++---
 .../src/FullOwnershipProvider.ts              | 59 +++++++++----------
 packages/ownership-providers/src/utils.ts     | 17 +++++-
 3 files changed, 60 insertions(+), 40 deletions(-)

diff --git a/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts b/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts
index 2b1c5d07..38e66107 100644
--- a/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts
+++ b/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts
@@ -107,7 +107,7 @@ function createFakeProvider({
       case 'wallet_fullOwnership_getOffChainLocks':
         return offChainLocks;
       case 'wallet_fullOwnership_getOnChainLocks':
-        return params.cursor ? [] : { objects: onChainLocks, cursor: '25' };
+        return params.cursor ? { objects: [], cursor: '25' } : { objects: onChainLocks, cursor: '25' };
       case 'wallet_fullOwnership_getLiveCells':
         const cursor = parseInt(params.cursor || 0);
         return { objects: cells.slice(cursor, cursor + 1), cursor: cursor + 1 };
@@ -605,23 +605,33 @@ describe('class FullOwnershipProvider', () => {
     it('Should fee unpaid transaction be pay fee, sign and sent', async () => {
       const provider = createFakeProvider({
         cells: [
-          createFakeCellWithCapacity(1000 * 1e8, onChainLocks1, createScript('0x255')),
+          createFakeCellWithCapacity(1000 * 1e8, onChainLocks1),
           createFakeCellWithCapacity(1000 * 1e8, onChainLocks2, undefined, 1),
           createFakeCellWithCapacity(1000 * 1e8, onChainLocks2, undefined, 3),
         ],
         offChainLocks: [offChainLock1],
+        onChainLocks: [onChainLocks1, onChainLocks2, onChainLocks3],
         groupedSignature: [[onChainLocks1, WITNESS_LOCK_PLACEHOLDER]],
       });
 
-      // input 2000 1e8 CKB
+      // input1 1000 1e8 CKB
+      // input2 1000 1e8 CKB
       // output1: 1000 1e8 CKB, but this onchain lock has a type script
       // output2: 1000 1e8 CKB, lock only
       // expected: deduct output2 capacity for transaction fee
       const txSkeleton = TransactionSkeleton()
-        .update('inputs', (inputs) => inputs.push(createFakeCellWithCapacity(2000 * 1e8, onChainLocks1)))
+        .update('inputs', (inputs) =>
+          inputs.push(
+            createFakeCellWithCapacity(1000 * 1e8, onChainLocks1),
+            createFakeCellWithCapacity(1000 * 1e8, onChainLocks1, undefined, 2),
+          ),
+        )
         .update('outputs', (outputs) =>
           outputs.push(
-            createFakeCellWithCapacity(1000 * 1e8, onChainLocks1),
+            // output cell with type script
+            createFakeCellWithCapacity(500 * 1e8, onChainLocks1, createScript('0x22')),
+            // output cell with data
+            createFakeCellWithCapacity(500 * 1e8, onChainLocks1, undefined, 1, '0x1234'),
             createFakeCellWithCapacity(1000 * 1e8, onChainLocks2),
           ),
         )
@@ -634,10 +644,10 @@ describe('class FullOwnershipProvider', () => {
       const signTransaction = jest.spyOn(provider, 'signTransaction');
 
       await provider.sendTransaction(txSkeleton);
-      expect(provider.payFee).toHaveBeenCalledWith(txSkeleton, { autoInject: true, byOutputIndexes: [1] });
+      expect(provider.payFee).toHaveBeenCalledWith(txSkeleton, { autoInject: true, byOutputIndexes: [2] });
 
       const txWithPayFee: TransactionSkeletonType = await payFee.mock.results[0].value;
-      const deductedCapacity = txWithPayFee.outputs.get(1)?.cellOutput.capacity!;
+      const deductedCapacity = txWithPayFee.outputs.get(2)?.cellOutput.capacity!;
 
       expect(
         BI.from(1000 * 1e8)
diff --git a/packages/ownership-providers/src/FullOwnershipProvider.ts b/packages/ownership-providers/src/FullOwnershipProvider.ts
index 28a537ed..0bd87002 100644
--- a/packages/ownership-providers/src/FullOwnershipProvider.ts
+++ b/packages/ownership-providers/src/FullOwnershipProvider.ts
@@ -11,13 +11,15 @@ import { blockchain, Cell, CellDep, HexString, Script } from '@ckb-lumos/base';
 import { bytes } from '@ckb-lumos/codec';
 import { secp256k1Blake160 } from '@ckb-lumos/common-scripts';
 import { Config as LumosConfig, getConfig as getLumosConfig, ScriptConfig } from '@ckb-lumos/config-manager';
-import { OutputValidator } from '@nexus-wallet/protocol/lib/base';
+import { OutputValidator, Paginate } from '@nexus-wallet/protocol/lib/base';
 import { Suffix } from './types';
 import {
   calculateFeeCompatible,
   equalPack,
   getTransactionSizeByTx,
   hexifyScript,
+  isLockOnlyCell,
+  isTransactionFeePaid,
   SECP256K1_BLAKE160_WITNESS_PLACEHOLDER,
   sumCapacity,
 } from './utils';
@@ -127,7 +129,7 @@ export class FullOwnershipProvider {
       }
 
       // lock-only will be injected
-      if (!this.isLockOnlyCell(cell)) {
+      if (!isLockOnlyCell(cell)) {
         continue;
       }
 
@@ -351,8 +353,8 @@ export class FullOwnershipProvider {
    * @returns Transaction hash in CKB network
    */
   async sendTransaction(txSkeleton: TransactionSkeletonType, outputsValidator?: OutputValidator): Promise<HexString> {
-    if (!this.isTransactionFeePaid(txSkeleton)) {
-      const byOutputIndexes = await this.getByOutputIndexesFromOriginal(txSkeleton);
+    if (!isTransactionFeePaid(txSkeleton)) {
+      const byOutputIndexes = await this.getOwnedOutputIndexes(txSkeleton);
       txSkeleton = await this.payFee(txSkeleton, { byOutputIndexes, autoInject: true });
     }
 
@@ -367,7 +369,7 @@ export class FullOwnershipProvider {
     });
   }
 
-  private async isOwnedLocks(locks: Script[], onlyLockOnlyCell = false): Promise<Map<string, boolean>> {
+  private async isOwnedLocks(locks: Script[]): Promise<Map<string, boolean>> {
     const result: Map<string, boolean> = new Map();
     if (locks.length === 0) return result;
 
@@ -387,17 +389,20 @@ export class FullOwnershipProvider {
       result.set(key, result.get(key) || offChainLockSet.has(key));
     });
 
-    const onChainLockSet = new Set();
-    for await (const cell of this.collector()) {
-      if (onlyLockOnlyCell && !this.isLockOnlyCell(cell)) continue;
-      onChainLockSet.add(bytes.hexify(blockchain.Script.pack(cell.cellOutput.lock)));
+    for (const change of ['internal', 'external'] as const) {
+      let cursor: string | undefined = undefined;
+      let page: Paginate<Script>;
+      do {
+        page = await this.getOnChainLocks({ change, cursor });
+        cursor = page.cursor;
+        const onChainLockSet = new Set(page.objects.map(hexifyScript));
+        locks.forEach((lock) => {
+          const key = bytes.hexify(blockchain.Script.pack(lock));
+          result.set(key, result.get(key) || onChainLockSet.has(key));
+        });
+      } while (page.objects.length > 0);
     }
 
-    locks.forEach((lock) => {
-      const key = bytes.hexify(blockchain.Script.pack(lock));
-      result.set(key, result.get(key) || onChainLockSet.has(key));
-    });
-
     return result;
   }
 
@@ -410,7 +415,7 @@ export class FullOwnershipProvider {
       `Some witnesses are missing!, required: ${walletOwnedInputs.size} from inputs, got: ${txSkeleton.witnesses.size} from witnesses.`,
     );
     const visitedLocks = new Set<string>();
-    let requireSign = true;
+    let isSigned = true;
     let witnessIndex = 0;
     for (const cell of txSkeleton.inputs) {
       const lock = hexifyScript(cell.cellOutput.lock);
@@ -423,38 +428,30 @@ export class FullOwnershipProvider {
         walletOwnedInputs.get(lock) &&
         txSkeleton.witnesses.get(witnessIndex) === SECP256K1_BLAKE160_WITNESS_PLACEHOLDER
       ) {
-        requireSign = false;
+        isSigned = false;
         break;
       } else {
         witnessIndex++;
       }
     }
 
-    return requireSign;
+    return isSigned;
   }
 
-  private isTransactionFeePaid(txSkeleton: TransactionSkeletonType, feeRate: BIish = 1000): boolean {
-    return calculateFeeCompatible(getTransactionSizeByTx(createTransactionFromSkeleton(txSkeleton)), feeRate)
-      .sub(sumCapacity(txSkeleton.get('inputs')).sub(sumCapacity(txSkeleton.get('outputs'))))
-      .lte(0);
-  }
-
-  private async getByOutputIndexesFromOriginal(txSkeleton: TransactionSkeletonType): Promise<number[]> {
+  private async getOwnedOutputIndexes(txSkeleton: TransactionSkeletonType): Promise<number[]> {
     const walletOwnedOutputs = await this.isOwnedLocks(
       txSkeleton.outputs.map((input) => input.cellOutput.lock).toArray(),
-      true,
     );
-    const byOutputIndex = [...walletOwnedOutputs.values()].reduce(
-      (prev: number[], cur, index) => (cur ? [...prev, index] : prev),
+
+    // pick lock only and wallet owned cells
+    const byOutputIndex = txSkeleton.outputs.reduce<number[]>(
+      (prev, cell, index) =>
+        isLockOnlyCell(cell) && walletOwnedOutputs.get(hexifyScript(cell.cellOutput.lock)) ? [...prev, index] : prev,
       [],
     );
     return byOutputIndex;
   }
 
-  private isLockOnlyCell(cell: Cell): boolean {
-    return !cell.cellOutput.type && cell.data === '0x';
-  }
-
   private async getSecp256k1Blake160CellDep(): Promise<CellDep> {
     const config = await this.getSecp256k1Blake160Config();
     return { depType: config.DEP_TYPE, outPoint: { txHash: config.TX_HASH, index: config.INDEX } };
diff --git a/packages/ownership-providers/src/utils.ts b/packages/ownership-providers/src/utils.ts
index b82456b3..99c3151f 100644
--- a/packages/ownership-providers/src/utils.ts
+++ b/packages/ownership-providers/src/utils.ts
@@ -1,8 +1,8 @@
-import { Address, blockchain, HexString, Script, Transaction } from '@ckb-lumos/base';
+import { Address, blockchain, Cell, HexString, Script, Transaction } from '@ckb-lumos/base';
 import { BI, BIish } from '@ckb-lumos/bi';
 import { bytes } from '@ckb-lumos/codec';
 import { PackParam, Uint8ArrayCodec } from '@ckb-lumos/codec/lib/base';
-import { TransactionSkeletonType } from '@ckb-lumos/helpers';
+import { createTransactionFromSkeleton, TransactionSkeletonType } from '@ckb-lumos/helpers';
 
 export function equalPack<C extends Uint8ArrayCodec>(codec: C, a: PackParam<C>, b: PackParam<C>): boolean {
   return bytes.equal(codec.pack(a), codec.pack(b));
@@ -46,3 +46,16 @@ export function sumCapacity(cells: TransactionSkeletonType['inputs' | 'outputs']
 export function hexifyScript(script: Script): HexString {
   return bytes.hexify(blockchain.Script.pack(script));
 }
+
+export function isLockOnlyCell(cell: Cell): boolean {
+  return !cell.cellOutput.type && cell.data === '0x';
+}
+
+export function isTransactionFeePaid(txSkeleton: TransactionSkeletonType, feeRate: BIish = 1000): boolean {
+  // TODO: support DAO
+  const txSize = getTransactionSizeByTx(createTransactionFromSkeleton(txSkeleton));
+  const expectedFee = calculateFeeCompatible(txSize, feeRate);
+  const actualFee = sumCapacity(txSkeleton.get('inputs')).sub(sumCapacity(txSkeleton.get('outputs')));
+
+  return actualFee.gte(expectedFee);
+}

From 565f6e49131f14e983c12d2b941d1a422609f026 Mon Sep 17 00:00:00 2001
From: IronLu233 <ironlu233.dev@outlook.com>
Date: Fri, 28 Apr 2023 23:36:25 +0800
Subject: [PATCH 09/11] test: make txWithFee calculation more clear

---
 .../__tests__/FullOwnershipProvider.test.ts            | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts b/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts
index 38e66107..0e8759e5 100644
--- a/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts
+++ b/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts
@@ -647,13 +647,11 @@ describe('class FullOwnershipProvider', () => {
       expect(provider.payFee).toHaveBeenCalledWith(txSkeleton, { autoInject: true, byOutputIndexes: [2] });
 
       const txWithPayFee: TransactionSkeletonType = await payFee.mock.results[0].value;
-      const deductedCapacity = txWithPayFee.outputs.get(2)?.cellOutput.capacity!;
 
-      expect(
-        BI.from(1000 * 1e8)
-          .sub(deductedCapacity)
-          .toBigInt(),
-      ).toBe(getExpectedFee(txSkeleton).toBigInt());
+      expect(getTxSkeletonFee(txWithPayFee)).toEqual(getExpectedFee(txSkeleton));
+
+      expect(txWithPayFee.inputs.size).toBe(txSkeleton.inputs.size);
+      expect(txWithPayFee.outputs.size).toBe(txSkeleton.outputs.size);
 
       expect(provider.signTransaction).toHaveBeenCalledWith(txWithPayFee);
       expect(mockProviderConfig.ckb.request).toBeCalledWith({

From 5551a239a4320baba1d54737feb82607bb370bb5 Mon Sep 17 00:00:00 2001
From: IronLu233 <ironlu233.dev@outlook.com>
Date: Wed, 3 May 2023 11:55:57 +0800
Subject: [PATCH 10/11] refactor: use extended map for clearify code

---
 .../__tests__/FullOwnershipProvider.test.ts   | 108 +++++++++---------
 .../src/FullOwnershipProvider.ts              |  30 +++--
 packages/ownership-providers/src/utils.ts     |  51 ++++++++-
 3 files changed, 117 insertions(+), 72 deletions(-)

diff --git a/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts b/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts
index 0e8759e5..2bc33a16 100644
--- a/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts
+++ b/packages/ownership-providers/__tests__/FullOwnershipProvider.test.ts
@@ -140,39 +140,43 @@ describe('class FullOwnershipProvider', () => {
 
     it('Should throw error when all cells capacity is not enough', async () => {
       const provider = createFakeProvider({
-        cells: [createFakeCellWithCapacity(100 * 1e8), createFakeCellWithCapacity(200)],
+        cells: [createFakeCellWithCapacity('100ckb'), createFakeCellWithCapacity(200)],
       });
 
-      await expect(provider.injectCapacity(emptyTxSkeleton, { amount: 400 * 1e8 })).rejects.toThrowError(
+      await expect(provider.injectCapacity(emptyTxSkeleton, { amount: parseUnit('400', 'ckb') })).rejects.toThrowError(
         /No cell sufficient to inject/,
       );
     });
     it('Should pick lock-only cell', async () => {
       const provider = createFakeProvider({
         cells: [
-          createFakeCellWithCapacity(500000 * 1e8, offChainLock1, offChainLock1),
-          createFakeCellWithCapacity(500000 * 1e8, onChainLocks1, undefined, 0, '0x123321'),
-          createFakeCellWithCapacity(500 * 1e8, offChainLock1),
-          createFakeCellWithCapacity(200 * 1e8, onChainLocks2),
+          createFakeCellWithCapacity('500000ckb', offChainLock1, offChainLock1),
+          createFakeCellWithCapacity('500000ckb', onChainLocks1, undefined, 0, '0x123321'),
+          createFakeCellWithCapacity('500ckb', offChainLock1),
+          createFakeCellWithCapacity('200ckb', onChainLocks2),
         ],
       });
 
-      const skeleton = await provider.injectCapacity(emptyTxSkeleton, { amount: 144 * 1e8 });
+      const skeleton = await provider.injectCapacity(emptyTxSkeleton, { amount: parseUnit('144', 'ckb') });
       expect(skeleton.get('inputs').size).toBe(1);
-      expect(skeleton.get('inputs').get(0)?.cellOutput.capacity).toBe(BI.from(500 * 1e8).toHexString());
+      expect(skeleton.get('inputs').get(0)?.cellOutput.capacity).toBe(BI.from(parseUnit('500', 'ckb')).toHexString());
       expect(skeleton.get('outputs').size).toBe(1);
-      expect(skeleton.get('outputs').get(0)?.cellOutput.capacity).toBe(BI.from(500 * 1e8 - 144 * 1e8).toHexString());
+      expect(skeleton.get('outputs').get(0)?.cellOutput.capacity).toBe(
+        parseUnit((500 - 144).toString(), 'ckb').toHexString(),
+      );
     });
 
     it('Should pick one cell when capacity is enough', async () => {
       const provider = createFakeProvider({
-        cells: [createFakeCellWithCapacity(500 * 1e8), createFakeCellWithCapacity(200 * 1e8)],
+        cells: [createFakeCellWithCapacity('500ckb'), createFakeCellWithCapacity('200ckb')],
       });
-      const skeleton = await provider.injectCapacity(emptyTxSkeleton, { amount: 144 * 1e8 });
+      const skeleton = await provider.injectCapacity(emptyTxSkeleton, { amount: parseUnit('144', 'ckb') });
       expect(skeleton.get('inputs').size).toBe(1);
-      expect(skeleton.get('inputs').get(0)?.cellOutput.capacity).toBe(BI.from(500 * 1e8).toHexString());
+      expect(skeleton.get('inputs').get(0)?.cellOutput.capacity).toBe(BI.from(parseUnit('500', 'ckb')).toHexString());
       expect(skeleton.get('outputs').size).toBe(1);
-      expect(skeleton.get('outputs').get(0)?.cellOutput.capacity).toBe(BI.from(500 * 1e8 - 144 * 1e8).toHexString());
+      expect(skeleton.get('outputs').get(0)?.cellOutput.capacity).toBe(
+        parseUnit((500 - 144).toString(), 'ckb').toHexString(),
+      );
     });
 
     it('Should pick multiple cells when single cell capacity is not enough', async () => {
@@ -257,10 +261,10 @@ describe('class FullOwnershipProvider', () => {
 
     it('Should skip the cell which already in inputs', async () => {
       // the collected1 is already in inputs
-      const txInputCell = createFakeCellWithCapacity(100 * 1e8, onChainLocks1, undefined, 0);
-      const collectedCell = createFakeCellWithCapacity(200 * 1e8, onChainLocks1, undefined, 1);
+      const txInputCell = createFakeCellWithCapacity('100ckb', onChainLocks1, undefined, 0);
+      const collectedCell = createFakeCellWithCapacity('200ckb', onChainLocks1, undefined, 1);
 
-      const txSkeleton = createFakeSkeleton([txInputCell], [createFakeCellWithCapacity(200 * 1e8, onChainLocks2)]);
+      const txSkeleton = createFakeSkeleton([txInputCell], [createFakeCellWithCapacity('200ckb', onChainLocks2)]);
       const provider = buildProvider([txInputCell, collectedCell]);
 
       const withFee = await provider.payFee(txSkeleton, { autoInject: true });
@@ -275,8 +279,8 @@ describe('class FullOwnershipProvider', () => {
     it('Should throw error when autoInject is true but cell is not available', async () => {
       const provider = buildProvider([]);
       const txSkeleton = createFakeSkeleton(
-        [createFakeCellWithCapacity(200 * 1e8, offChainLock1)],
-        [createFakeCellWithCapacity(200 * 1e8, onChainLocks2)],
+        [createFakeCellWithCapacity('200ckb', offChainLock1)],
+        [createFakeCellWithCapacity('200ckb', onChainLocks2)],
       );
       // await provider.injectCapacity(txSkeleton, { amount: 150 });
 
@@ -288,8 +292,8 @@ describe('class FullOwnershipProvider', () => {
     it('Should return directly when sum(inputs_capacity) - sum(outputs_capacity) ≥ fee', async () => {
       const provider = buildProvider([]);
       const txSkeleton = createFakeSkeleton(
-        [createFakeCellWithCapacity(200 * 1e8, offChainLock1)],
-        [createFakeCellWithCapacity(100 * 1e8, onChainLocks2)],
+        [createFakeCellWithCapacity('200ckb', offChainLock1)],
+        [createFakeCellWithCapacity('100ckb', onChainLocks2)],
       );
 
       await expect(provider.payFee(txSkeleton, { autoInject: true })).resolves.toEqual(txSkeleton);
@@ -298,11 +302,11 @@ describe('class FullOwnershipProvider', () => {
     it('Should use the provided `byOutputIndexes` cell for paying fee', async () => {
       const provider = buildProvider([]);
       const txSkeleton = createFakeSkeleton(
-        [createFakeCellWithCapacity(300 * 1e8, offChainLock1)],
+        [createFakeCellWithCapacity('300ckb', offChainLock1)],
         [
-          createFakeCellWithCapacity(100 * 1e8, onChainLocks2),
-          createFakeCellWithCapacity(100 * 1e8, onChainLocks2),
-          createFakeCellWithCapacity(100 * 1e8, onChainLocks2),
+          createFakeCellWithCapacity('100ckb', onChainLocks2),
+          createFakeCellWithCapacity('100ckb', onChainLocks2),
+          createFakeCellWithCapacity('100ckb', onChainLocks2),
         ],
       );
       const withFee = await provider.payFee(txSkeleton, { byOutputIndexes: [1, 2], autoInject: false });
@@ -314,8 +318,8 @@ describe('class FullOwnershipProvider', () => {
     it('Should throw error when payer lock is not provided and auto inject is false', async () => {
       const provider = buildProvider([]);
       const txSkeleton = createFakeSkeleton(
-        [createFakeCellWithCapacity(100 * 1e8, offChainLock1)],
-        [createFakeCellWithCapacity(100 * 1e8, onChainLocks2)],
+        [createFakeCellWithCapacity('100ckb', offChainLock1)],
+        [createFakeCellWithCapacity('100ckb', onChainLocks2)],
       );
       await expect(provider.payFee(txSkeleton, { autoInject: false, byOutputIndexes: [] })).rejects.toThrowError(
         'no byOutputIndexes is provided, but autoInject is `false`',
@@ -323,10 +327,10 @@ describe('class FullOwnershipProvider', () => {
     });
 
     it('Should throw error when payer lock is not available and auto inject is false', async () => {
-      const provider = buildProvider([createFakeCellWithCapacity(300 * 1e8, onChainLocks1)]);
+      const provider = buildProvider([createFakeCellWithCapacity('300ckb', onChainLocks1)]);
       const txSkeleton = createFakeSkeleton(
-        [createFakeCellWithCapacity(300 * 1e8, offChainLock1)],
-        [createFakeCellWithCapacity(300 * 1e8, offChainLock1), createFakeCellWithCapacity(300, onChainLocks2)],
+        [createFakeCellWithCapacity('300ckb', offChainLock1)],
+        [createFakeCellWithCapacity('300ckb', offChainLock1), createFakeCellWithCapacity(300, onChainLocks2)],
       );
       await expect(provider.payFee(txSkeleton, { autoInject: false, byOutputIndexes: [1] })).rejects.toThrowError(
         'cells from `byOutputIndexes` sufficient to pay fee',
@@ -336,8 +340,8 @@ describe('class FullOwnershipProvider', () => {
     it('Should throw error when byOutputIndexes is out of range', async () => {
       const provider = buildProvider([]);
       const txSkeleton = createFakeSkeleton(
-        [createFakeCellWithCapacity(300 * 1e8, offChainLock1)],
-        [createFakeCellWithCapacity(300 * 1e8, offChainLock1)],
+        [createFakeCellWithCapacity('300ckb', offChainLock1)],
+        [createFakeCellWithCapacity('300ckb', offChainLock1)],
       );
 
       await (
@@ -346,15 +350,15 @@ describe('class FullOwnershipProvider', () => {
     });
 
     it('Should use wallet cell when `byOutputIndexes` is not sufficient', async () => {
-      const txInputCell = createFakeCellWithCapacity(190 * 1e8 + 100, onChainLocks1, undefined, 0);
-      const collectedCell = createFakeCellWithCapacity(100 * 1e8, onChainLocks1, undefined, 1);
+      const txInputCell = createFakeCellWithCapacity(parseUnit('190', 'ckb').add(100), onChainLocks1, undefined, 0);
+      const collectedCell = createFakeCellWithCapacity('100ckb', onChainLocks1, undefined, 1);
       const provider = buildProvider([collectedCell]);
       const txSkeleton = createFakeSkeleton(
         [txInputCell],
         [
-          createFakeCellWithCapacity(100 * 1e8, onChainLocks2),
-          createFakeCellWithCapacity(45 * 1e8 + 50, onChainLocks3),
-          createFakeCellWithCapacity(45 * 1e8 + 50, onChainLocks3),
+          createFakeCellWithCapacity('100ckb', onChainLocks2),
+          createFakeCellWithCapacity(parseUnit('45', 'ckb').add(50), onChainLocks3),
+          createFakeCellWithCapacity(parseUnit('45', 'ckb').add(50), onChainLocks3),
         ],
       );
       const withFee = await provider.payFee(txSkeleton, { autoInject: true, byOutputIndexes: [1, 2], feeRate: 1000 });
@@ -567,8 +571,8 @@ describe('class FullOwnershipProvider', () => {
     it('Should fee paid transaction be signed and sent', async () => {
       const provider = createFakeProvider({
         cells: [
-          createFakeCellWithCapacity(1000 * 1e8, onChainLocks1),
-          createFakeCellWithCapacity(100 * 1e8, onChainLocks1),
+          createFakeCellWithCapacity('1000ckb', onChainLocks1),
+          createFakeCellWithCapacity('100ckb', onChainLocks1),
         ],
         offChainLocks: [offChainLock1],
         groupedSignature: [[onChainLocks1, WITNESS_LOCK_PLACEHOLDER]],
@@ -580,13 +584,11 @@ describe('class FullOwnershipProvider', () => {
       const txSkeleton = TransactionSkeleton()
         .update('inputs', (inputs) =>
           inputs.push(
-            createFakeCellWithCapacity(500 * 1e8, onChainLocks1),
-            createFakeCellWithCapacity(500 * 1e8, onChainLocks1),
+            createFakeCellWithCapacity('500ckb', onChainLocks1),
+            createFakeCellWithCapacity('500ckb', onChainLocks1),
           ),
         )
-        .update('outputs', (outputs) =>
-          outputs.push(createFakeCellWithCapacity(100 * 1e8, onChainLocks1, undefined, 2)),
-        )
+        .update('outputs', (outputs) => outputs.push(createFakeCellWithCapacity('100ckb', onChainLocks1, undefined, 2)))
         .update('witnesses', (witnesses) => witnesses.push(SECP256K1_BLAKE160_WITNESS_PLACEHOLDER));
 
       jest.spyOn(provider, 'payFee');
@@ -605,9 +607,9 @@ describe('class FullOwnershipProvider', () => {
     it('Should fee unpaid transaction be pay fee, sign and sent', async () => {
       const provider = createFakeProvider({
         cells: [
-          createFakeCellWithCapacity(1000 * 1e8, onChainLocks1),
-          createFakeCellWithCapacity(1000 * 1e8, onChainLocks2, undefined, 1),
-          createFakeCellWithCapacity(1000 * 1e8, onChainLocks2, undefined, 3),
+          createFakeCellWithCapacity('1000ckb', onChainLocks1),
+          createFakeCellWithCapacity('1000ckb', onChainLocks2, undefined, 1),
+          createFakeCellWithCapacity('1000ckb', onChainLocks2, undefined, 3),
         ],
         offChainLocks: [offChainLock1],
         onChainLocks: [onChainLocks1, onChainLocks2, onChainLocks3],
@@ -622,17 +624,17 @@ describe('class FullOwnershipProvider', () => {
       const txSkeleton = TransactionSkeleton()
         .update('inputs', (inputs) =>
           inputs.push(
-            createFakeCellWithCapacity(1000 * 1e8, onChainLocks1),
-            createFakeCellWithCapacity(1000 * 1e8, onChainLocks1, undefined, 2),
+            createFakeCellWithCapacity('1000ckb', onChainLocks1),
+            createFakeCellWithCapacity('1000ckb', onChainLocks1, undefined, 2),
           ),
         )
         .update('outputs', (outputs) =>
           outputs.push(
             // output cell with type script
-            createFakeCellWithCapacity(500 * 1e8, onChainLocks1, createScript('0x22')),
+            createFakeCellWithCapacity('500ckb', onChainLocks1, createScript('0x22')),
             // output cell with data
-            createFakeCellWithCapacity(500 * 1e8, onChainLocks1, undefined, 1, '0x1234'),
-            createFakeCellWithCapacity(1000 * 1e8, onChainLocks2),
+            createFakeCellWithCapacity('500ckb', onChainLocks1, undefined, 1, '0x1234'),
+            createFakeCellWithCapacity('1000ckb', onChainLocks2),
           ),
         )
         .update('witnesses', (witnesses) =>
@@ -674,8 +676,8 @@ describe('class FullOwnershipProvider', () => {
       });
 
       const txSkeleton = TransactionSkeleton()
-        .update('inputs', (inputs) => inputs.push(createFakeCellWithCapacity(1000 * 1e8, onChainLocks1)))
-        .update('outputs', (outputs) => outputs.push(createFakeCellWithCapacity(500 * 1e8, onChainLocks1)));
+        .update('inputs', (inputs) => inputs.push(createFakeCellWithCapacity('1000ckb', onChainLocks1)))
+        .update('outputs', (outputs) => outputs.push(createFakeCellWithCapacity('500ckb', onChainLocks1)));
 
       await expect(() => provider.sendTransaction(txSkeleton)).rejects.toThrowError(
         'Some witnesses are missing!, required: 1 from inputs, got: 0',
diff --git a/packages/ownership-providers/src/FullOwnershipProvider.ts b/packages/ownership-providers/src/FullOwnershipProvider.ts
index 0bd87002..e8bbeec7 100644
--- a/packages/ownership-providers/src/FullOwnershipProvider.ts
+++ b/packages/ownership-providers/src/FullOwnershipProvider.ts
@@ -17,9 +17,10 @@ import {
   calculateFeeCompatible,
   equalPack,
   getTransactionSizeByTx,
-  hexifyScript,
   isLockOnlyCell,
   isTransactionFeePaid,
+  ScriptSerializedMap,
+  ScriptSerializedSet,
   SECP256K1_BLAKE160_WITNESS_PLACEHOLDER,
   sumCapacity,
 } from './utils';
@@ -369,24 +370,21 @@ export class FullOwnershipProvider {
     });
   }
 
-  private async isOwnedLocks(locks: Script[]): Promise<Map<string, boolean>> {
-    const result: Map<string, boolean> = new Map();
+  private async isOwnedLocks(locks: Script[]): Promise<ScriptSerializedMap<boolean>> {
+    const result = new ScriptSerializedMap<boolean>();
     if (locks.length === 0) return result;
 
-    const offChainLockSet = new Set(
+    const offChainLockSet = new ScriptSerializedSet(
       (
         await Promise.all([
           this.getOffChainLocks({ change: 'internal' }),
           this.getOffChainLocks({ change: 'external' }),
         ])
-      )
-        .flat()
-        .map(hexifyScript),
+      ).flat(),
     );
 
     locks.forEach((lock) => {
-      const key = bytes.hexify(blockchain.Script.pack(lock));
-      result.set(key, result.get(key) || offChainLockSet.has(key));
+      result.set(lock, result.get(lock) || offChainLockSet.has(lock));
     });
 
     for (const change of ['internal', 'external'] as const) {
@@ -395,10 +393,9 @@ export class FullOwnershipProvider {
       do {
         page = await this.getOnChainLocks({ change, cursor });
         cursor = page.cursor;
-        const onChainLockSet = new Set(page.objects.map(hexifyScript));
+        const onChainLockSet = new ScriptSerializedSet(page.objects);
         locks.forEach((lock) => {
-          const key = bytes.hexify(blockchain.Script.pack(lock));
-          result.set(key, result.get(key) || onChainLockSet.has(key));
+          result.set(lock, result.get(lock) || onChainLockSet.has(lock));
         });
       } while (page.objects.length > 0);
     }
@@ -414,11 +411,11 @@ export class FullOwnershipProvider {
       walletOwnedInputs.size <= txSkeleton.witnesses.size,
       `Some witnesses are missing!, required: ${walletOwnedInputs.size} from inputs, got: ${txSkeleton.witnesses.size} from witnesses.`,
     );
-    const visitedLocks = new Set<string>();
+    const visitedLocks = new ScriptSerializedSet();
     let isSigned = true;
     let witnessIndex = 0;
     for (const cell of txSkeleton.inputs) {
-      const lock = hexifyScript(cell.cellOutput.lock);
+      const { lock } = cell.cellOutput;
       if (visitedLocks.has(lock)) {
         continue;
       } else {
@@ -428,8 +425,7 @@ export class FullOwnershipProvider {
         walletOwnedInputs.get(lock) &&
         txSkeleton.witnesses.get(witnessIndex) === SECP256K1_BLAKE160_WITNESS_PLACEHOLDER
       ) {
-        isSigned = false;
-        break;
+        return false;
       } else {
         witnessIndex++;
       }
@@ -446,7 +442,7 @@ export class FullOwnershipProvider {
     // pick lock only and wallet owned cells
     const byOutputIndex = txSkeleton.outputs.reduce<number[]>(
       (prev, cell, index) =>
-        isLockOnlyCell(cell) && walletOwnedOutputs.get(hexifyScript(cell.cellOutput.lock)) ? [...prev, index] : prev,
+        isLockOnlyCell(cell) && walletOwnedOutputs.has(cell.cellOutput.lock) ? [...prev, index] : prev,
       [],
     );
     return byOutputIndex;
diff --git a/packages/ownership-providers/src/utils.ts b/packages/ownership-providers/src/utils.ts
index 99c3151f..73b6c1ac 100644
--- a/packages/ownership-providers/src/utils.ts
+++ b/packages/ownership-providers/src/utils.ts
@@ -43,8 +43,8 @@ export function sumCapacity(cells: TransactionSkeletonType['inputs' | 'outputs']
   return cells.reduce((prev, cur) => prev.add(cur.cellOutput.capacity), BI.from(0));
 }
 
-export function hexifyScript(script: Script): HexString {
-  return bytes.hexify(blockchain.Script.pack(script));
+export function hexifyScript<C extends Uint8ArrayCodec>(value: PackParam<C>): HexString {
+  return bytes.hexify(blockchain.Script.pack(value));
 }
 
 export function isLockOnlyCell(cell: Cell): boolean {
@@ -59,3 +59,50 @@ export function isTransactionFeePaid(txSkeleton: TransactionSkeletonType, feeRat
 
   return actualFee.gte(expectedFee);
 }
+
+export class ScriptSerializedMap<V> extends Map<string, V> {
+  constructor(values: [Script, V][] = []) {
+    super(values.map(([key, value]) => [hexifyScript(key), value]));
+  }
+  private hashKey(key: Script | string): string {
+    return typeof key === 'string' ? key : hexifyScript(key);
+  }
+
+  get(key: Script | string): V | undefined {
+    return super.get(this.hashKey(key));
+  }
+
+  set(key: Script | string, value: V): this {
+    return super.set(this.hashKey(key), value);
+  }
+
+  has(key: Script | string): boolean {
+    return super.has(this.hashKey(key));
+  }
+
+  delete(key: string | Script): boolean {
+    return super.delete(this.hashKey(key));
+  }
+}
+
+export class ScriptSerializedSet extends Set<string> {
+  constructor(values: Script[] = []) {
+    super(values.map(hexifyScript));
+  }
+
+  private hashKey(key: Script | string): string {
+    return typeof key === 'string' ? key : hexifyScript(key);
+  }
+
+  add(key: Script | string): this {
+    return super.add(this.hashKey(key));
+  }
+
+  has(key: Script | string): boolean {
+    return super.has(this.hashKey(key));
+  }
+
+  delete(key: Script | string): boolean {
+    return super.delete(this.hashKey(key));
+  }
+}

From 364602d46cea1dbb8ab9a408434f34953aedfc60 Mon Sep 17 00:00:00 2001
From: IronLu233 <ironlu233.dev@outlook.com>
Date: Wed, 3 May 2023 12:55:13 +0800
Subject: [PATCH 11/11] refactor: optimize Map structures

---
 packages/ownership-providers/src/utils.ts | 64 ++++++++++++++---------
 1 file changed, 40 insertions(+), 24 deletions(-)

diff --git a/packages/ownership-providers/src/utils.ts b/packages/ownership-providers/src/utils.ts
index 73b6c1ac..ceb48b14 100644
--- a/packages/ownership-providers/src/utils.ts
+++ b/packages/ownership-providers/src/utils.ts
@@ -60,49 +60,65 @@ export function isTransactionFeePaid(txSkeleton: TransactionSkeletonType, feeRat
   return actualFee.gte(expectedFee);
 }
 
-export class ScriptSerializedMap<V> extends Map<string, V> {
-  constructor(values: [Script, V][] = []) {
-    super(values.map(([key, value]) => [hexifyScript(key), value]));
+export class HashMap<K, V> {
+  private internal = new Map<string, V>();
+
+  constructor(public readonly hasher: (k: K) => string, values: [K, V][] = []) {
+    this.internal = new Map(values.map(([k, v]) => [hasher(k), v] as [string, V]));
   }
-  private hashKey(key: Script | string): string {
-    return typeof key === 'string' ? key : hexifyScript(key);
+
+  public get(key: K): V | undefined {
+    return this.internal.get(this.hasher(key));
   }
 
-  get(key: Script | string): V | undefined {
-    return super.get(this.hashKey(key));
+  set(key: K, value: V): void {
+    this.internal.set(this.hasher(key), value);
   }
 
-  set(key: Script | string, value: V): this {
-    return super.set(this.hashKey(key), value);
+  has(key: K): boolean {
+    return this.internal.has(this.hasher(key));
   }
 
-  has(key: Script | string): boolean {
-    return super.has(this.hashKey(key));
+  delete(key: K): boolean {
+    return this.internal.delete(this.hasher(key));
   }
 
-  delete(key: string | Script): boolean {
-    return super.delete(this.hashKey(key));
+  get size(): number {
+    return this.internal.size;
   }
 }
 
-export class ScriptSerializedSet extends Set<string> {
-  constructor(values: Script[] = []) {
-    super(values.map(hexifyScript));
+export class ScriptSerializedMap<V> extends HashMap<Script, V> {
+  constructor(values: [Script, V][] = []) {
+    super(hexifyScript, values);
+  }
+}
+
+export class HashSet<V> {
+  private internal = new Set<string>();
+  constructor(public readonly hasher: (v: V) => string, values: V[] = []) {
+    this.internal = new Set(values.map(hasher));
+  }
+
+  add(value: V): void {
+    this.internal.add(this.hasher(value));
   }
 
-  private hashKey(key: Script | string): string {
-    return typeof key === 'string' ? key : hexifyScript(key);
+  has(value: V): boolean {
+    return this.internal.has(this.hasher(value));
   }
 
-  add(key: Script | string): this {
-    return super.add(this.hashKey(key));
+  delete(value: V): boolean {
+    return this.internal.delete(this.hasher(value));
   }
 
-  has(key: Script | string): boolean {
-    return super.has(this.hashKey(key));
+  get size(): number {
+    return this.internal.size;
   }
+}
 
-  delete(key: Script | string): boolean {
-    return super.delete(this.hashKey(key));
+export class ScriptSerializedSet extends HashSet<Script> {
+  constructor(values: Script[] = []) {
+    super(hexifyScript, values);
   }
 }