feat: normalize exit codes for ownable and merkle multi proof

Author: patricios-space

contracts/contracts/lib/access/ownable_2step.tolk

@@ -1,16 +1,15 @@
 import "./../utils.tolk";
 
-// Exit codes
-
-// TODO: follow namespaced exitcodes structure
-/// Matches the exit code for `TactExitCodeAccessDenied` from `@stdlib`.
-const ERROR_ONLY_CALLABLE_BY_OWNER = 132;
-
-/// Custom exit code indicating that the new owner is the same as the current one.
-const ERROR_CANNOT_TRANSFER_TO_SELF = 1001;
+// getFacilityId(stringCrc32(com.chainlink.ton.lib.access.Ownable2Step))
+const Ownable2Step_FACILITY_ID = 204;
+const Ownable2Step_ERROR_CODE = Ownable2Step_FACILITY_ID * 100;
 
-/// Custom exit code indicating that only the proposed (pending) owner may accept ownership.
-const ERROR_MUST_BE_PROPOSED_OWNER = 1002;
+// Exit codes
+enum Ownable2Step_Error {
+    OnlyCallableByOwner = Ownable2Step_ERROR_CODE; // only the current owner may call this function.
+    CannotTransferToSelf, // the new owner is the same as the current one.
+    MustBeProposedOwner, // only the proposed (pending) owner may accept ownership.
+}
 
 /// Ownable2Step trait provides ownership two-step transfer functionality.
 struct Ownable2Step {
@@ -98,7 +97,7 @@ fun Ownable2Step.onInternalMessage(mutate self, sender: address, body: slice): b
 /// #### Exit codes
 /// * 132: ERROR_ONLY_CALLABLE_BY_OWNER
 fun Ownable2Step.requireOwner(self, sender: address) {
-    assert(sender == self.owner, ERROR_ONLY_CALLABLE_BY_OWNER);
+    assert(sender == self.owner, Ownable2Step_Error.OnlyCallableByOwner);
 }
 
 /// Initiates ownership transfer to a new address.
@@ -108,7 +107,7 @@ fun Ownable2Step.requireOwner(self, sender: address) {
 /// * 1001: ERROR_CANNOT_TRANSFER_TO_SELF
 fun Ownable2Step.transferOwnership(mutate self, sender: address, to: address) {
     self.requireOwner(sender);
-    assert(to != self.owner, ERROR_CANNOT_TRANSFER_TO_SELF);
+    assert(to != self.owner, Ownable2Step_Error.CannotTransferToSelf);
 
     self.pendingOwner = to;
 }
@@ -118,8 +117,8 @@ fun Ownable2Step.transferOwnership(mutate self, sender: address, to: address) {
 /// #### Exit codes
 /// * 1002: ERROR_MUST_BE_PROPOSED_OWNER
 fun Ownable2Step.acceptOwnership(mutate self, sender: address) {
-    assert(self.pendingOwner != null, ERROR_MUST_BE_PROPOSED_OWNER);
-    assert(sender == self.pendingOwner, ERROR_MUST_BE_PROPOSED_OWNER);
+    assert(self.pendingOwner != null, Ownable2Step_Error.MustBeProposedOwner);
+    assert(sender == self.pendingOwner, Ownable2Step_Error.MustBeProposedOwner);
 
     var previousOwner = self.owner;
     self.owner = sender;

contracts/contracts/lib/crypto/merkle_multi_proof.tolk

@@ -1,12 +1,17 @@
 import "../utils.tolk"
 
+// getFacilityId(stringCrc32(com.chainlink.ton.lib.crypto.MerkleMultiProof))
+const MerkleMultiProof_FACILITY_ID= 462;
+const MerkleMultiProof_ERROR_CODE= MerkleMultiProof_FACILITY_ID * 100;
+
 // --- Errror Codes ---
 
-const ERROR_INVALID_PROOF_LEAVES_CANNOT_BE_EMPTY: int = 1001;
-const ERROR_INVALID_PROOF_LEAVES_TOO_LARGE: int = 1002;
-const ERROR_INVALID_PROOF_PROOFS_TOO_LARGE: int = 1003;
-const ERROR_INVALID_PROOF_TOTAL_HASHES_EXCEEDED_MAX: int = 1004;
-const ERROR_INVALID_PROOF_DATA_SIZE_MISMATCH: int = 1005;
+enum MerkleMultiProof_Error {
+    InvalidProofLeavesCannotBeEmpty = MerkleMultiProof_ERROR_CODE,
+    InvalidProofLeavesTooLarge,
+    InvalidProofProofsTooLarge,
+    InvalidProofTotalHashesExceededMax,
+}
 
 /// @notice internal domain separator, should be used as the first 32 bytes of an internal node's preimage.
 const INTERNAL_DOMAIN_SEPARATOR: int = 0x0000000000000000000000000000000000000000000000000000000000000001;
@@ -24,12 +29,12 @@ fun merkleRoot<I>(
     val leavesLen = leaves.size(32);
     val proofsLen = proofs.size(32);
 
-    assert (leavesLen != 0, ERROR_INVALID_PROOF_LEAVES_CANNOT_BE_EMPTY);
-    assert (leavesLen <= MAX_NUM_HASHES, ERROR_INVALID_PROOF_LEAVES_TOO_LARGE + 1);
-    assert (proofsLen <= MAX_NUM_HASHES, ERROR_INVALID_PROOF_PROOFS_TOO_LARGE + 1);
+    assert (leavesLen != 0, MerkleMultiProof_Error.InvalidProofLeavesCannotBeEmpty);
+    assert (leavesLen <= MAX_NUM_HASHES, MerkleMultiProof_Error.InvalidProofLeavesTooLarge as int + 1);
+    assert (proofsLen <= MAX_NUM_HASHES, MerkleMultiProof_Error.InvalidProofProofsTooLarge as int + 1);
 
     var totalHashes: int = leavesLen + proofsLen - 1;
-    assert (totalHashes <= MAX_NUM_HASHES, ERROR_INVALID_PROOF_TOTAL_HASHES_EXCEEDED_MAX);
+    assert (totalHashes <= MAX_NUM_HASHES, MerkleMultiProof_Error.InvalidProofTotalHashesExceededMax);
 
     if (totalHashes == 0) {
         return leaves.next();

contracts/tests/lib/access/Ownable2Step.spec.ts

@@ -5,6 +5,14 @@ import { compile } from '@ton/blueprint'
 
 import * as ownable2Step from '../../../wrappers/libraries/access/Ownable2Step'
 import * as counter from '../../../wrappers/examples/Counter'
+import { facilityId } from '../../../wrappers/utils'
+import { crc32 } from 'zlib'
+
+describe('Ownable2Step Unit Tests', () => {
+  it('should match facility ID', async () => {
+    expect(ownable2Step.FACILITY_ID).toBe(facilityId(crc32(ownable2Step.FACILITY_NAME)))
+  })
+})
 
 describe('Ownable2Step Counter', () => {
   let blockchain: Blockchain

contracts/tests/lib/merkle_proof/MerkleMultiProof.spec.ts

@@ -1,18 +1,28 @@
 import { Blockchain, SandboxContract, TreasuryContract } from '@ton/sandbox'
 import { toNano, Cell } from '@ton/core'
-import {
-  MerkleMultiProofCalculator,
-  MerkleMultiProofCalculatorStorage,
-} from '../../../wrappers/libraries/merkle_proof/MerkleMultiProofCalculator'
 import { sha256_sync } from '@ton/crypto'
-
 import '@ton/test-utils'
-import { MerkleHelper, HashFunction } from './helpers/MerkleMultiProofHelper'
+
+import { crc32 } from 'zlib'
 import { loadContractCode } from '../../../wrappers/codeLoader'
 import { asSnakeDataUint } from '../../../src/utils'
-import { TestVector, testVectors } from './TestVectors'
+import { testVectors } from './TestVectors'
 import { keccak256 } from '@ethersproject/keccak256'
 
+import { MerkleHelper, HashFunction } from './helpers/MerkleMultiProofHelper'
+import * as mmp from '../../../wrappers/libraries/merkle_proof/MerkleMultiProof'
+import { facilityId } from '../../../wrappers/utils'
+import {
+  MerkleMultiProofCalculator,
+  MerkleMultiProofCalculatorStorage,
+} from '../../../wrappers/libraries/merkle_proof/MerkleMultiProofCalculator'
+
+describe('MerkleMultiProof Unit Tests', () => {
+  it('should match facility ID', async () => {
+    expect(mmp.FACILITY_ID).toBe(facilityId(crc32(mmp.FACILITY_NAME)))
+  })
+})
+
 describe('MerkleMultiProofTests', () => {
   let blockchain: Blockchain
   let deployer: SandboxContract<TreasuryContract>

contracts/wrappers/libraries/access/Ownable2Step.ts

@@ -13,10 +13,14 @@ import { crc32 } from 'zlib'
 import { CellCodec } from '../../utils'
 import { Maybe } from '@ton/core/dist/utils/maybe'
 
+export const FACILITY_NAME = 'com.chainlink.ton.lib.access.Ownable2Step'
+export const FACILITY_ID = 204
+export const ERROR_CODE = FACILITY_ID * 100
+
 export enum Errors {
-  OnlyCallableByOwner = 132,
-  CannotTransferToSelf = 1001,
-  MustBeProposedOwner = 1002,
+  OnlyCallableByOwner = ERROR_CODE,
+  CannotTransferToSelf,
+  MustBeProposedOwner,
 }
 
 // @dev Message sent by the owner to transfer ownership of a contract.

contracts/wrappers/libraries/merkle_proof/MerkleMultiProof.ts

@@ -0,0 +1,10 @@
+export const FACILITY_NAME = 'com.chainlink.ton.lib.crypto.MerkleMultiProof'
+export const FACILITY_ID = 462
+export const ERROR_CODE = FACILITY_ID * 100
+
+export enum Errors {
+  InvalidProofLeavesCannotBeEmpty = ERROR_CODE,
+  InvalidProofLeavesTooLarge,
+  InvalidProofProofsTooLarge,
+  InvalidProofTotalHashesExceededMax,
+}

pkg/ccip/bindings/merkleroot/exitcode_string.go

@@ -4,6 +4,8 @@ import (
 	"math/big"
 
 	"github.com/xssnick/tonutils-go/address"
+
+	"github.com/smartcontractkit/chainlink-ton/pkg/ton/tvm"
 )
 
 type Storage struct {
@@ -15,3 +17,23 @@ type Storage struct {
 	MessageStates         *big.Int         `tlb:"## 128"`
 	DeliveredMessageCount uint16           `tlb:"## 16"`
 }
+
+//go:generate go run golang.org/x/tools/cmd/stringer@v0.38.0 -type=ExitCode
+type ExitCode tvm.ExitCode
+
+var ExitCodeCodec tvm.ExitCodeCodecInt[ExitCode] = ExitCode(tvm.ExitCode(-1))
+
+func (ExitCode) NewFrom(ec tvm.ExitCode) (ExitCode, error) {
+	const (
+		ecMin = int32(ErrorInvalidProofLeavesCannotBeEmpty)
+		ecMax = int32(ErrorInvalidProofTotalHashesExceededMax)
+	)
+	return tvm.NewExitCodeInRange(ExitCode(ec), ecMin, ecMax)
+}
+
+const (
+	ErrorInvalidProofLeavesCannotBeEmpty ExitCode = iota + 20400
+	ErrorInvalidProofLeavesTooLarge
+	ErrorInvalidProofProofsTooLarge
+	ErrorInvalidProofTotalHashesExceededMax
+)

pkg/ccip/bindings/merkleroot/merkle_root.go

@@ -41,7 +41,7 @@ func (ExitCode) NewFrom(ec tvm.ExitCode) (ExitCode, error) {
 }
 
 const (
-	ErrorOnlyCallableByOwner  ExitCode = ExitCode(132)
-	ErrorCannotTransferToSelf          = ExitCode(1001)
-	ErrorMustBeProposedOwner           = ExitCode(1002)
+	ErrorOnlyCallableByOwner ExitCode = iota + 20400
+	ErrorCannotTransferToSelf
+	ErrorMustBeProposedOwner
 )